.opencode/node_modules/@opencode-ai/sdk/dist/v2/gen/sdk.gen.js

// This file is auto-generated by @hey-api/openapi-ts
import { client } from "./client.gen.js";
import { buildClientParams } from "./client/index.js";
class HeyApiClient {
    client;
    constructor(args) {
        this.client = args?.client ?? client;
    }
}
class HeyApiRegistry {
    defaultKey = "default";
    instances = new Map();
    get(key) {
        const instance = this.instances.get(key ?? this.defaultKey);
        if (!instance) {
            throw new Error(`No SDK client found. Create one with "new OpencodeClient()" to fix this error.`);
        }
        return instance;
    }
    set(value, key) {
        this.instances.set(key ?? this.defaultKey, value);
    }
}
export class Auth extends HeyApiClient {
    /**
     * Remove auth credentials
     *
     * Remove authentication credentials
     */
    remove(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "providerID" }] }]);
        return (options?.client ?? this.client).delete({
            url: "/auth/{providerID}",
            ...options,
            ...params,
        });
    }
    /**
     * Set auth credentials
     *
     * Set authentication credentials
     */
    set(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "providerID" },
                    { key: "auth", map: "body" },
                ],
            },
        ]);
        return (options?.client ?? this.client).put({
            url: "/auth/{providerID}",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class App extends HeyApiClient {
    /**
     * Write log
     *
     * Write a log entry to the server logs with specified level and metadata.
     */
    log(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "service" },
                    { in: "body", key: "level" },
                    { in: "body", key: "message" },
                    { in: "body", key: "extra" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/log",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * List agents
     *
     * Get a list of all available AI agents in the OpenCode system.
     */
    agents(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/agent",
            ...options,
            ...params,
        });
    }
    /**
     * List skills
     *
     * Get a list of all available skills in the OpenCode system.
     */
    skills(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/skill",
            ...options,
            ...params,
        });
    }
}
export class ControlPlane extends HeyApiClient {
    /**
     * Move session
     *
     * Move a session to another project directory, optionally transferring local changes.
     */
    moveSession(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "body", key: "sessionID" },
                    { in: "body", key: "destination" },
                    { in: "body", key: "moveChanges" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/experimental/control-plane/move-session",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Capabilities extends HeyApiClient {
    /**
     * Get experimental capabilities
     *
     * Get experimental features enabled on the OpenCode server.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/experimental/capabilities",
            ...options,
            ...params,
        });
    }
}
export class Console extends HeyApiClient {
    /**
     * Get active Console provider metadata
     *
     * Get the active Console org name and the set of provider IDs managed by that Console org.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/experimental/console",
            ...options,
            ...params,
        });
    }
    /**
     * List switchable Console orgs
     *
     * Get the available Console orgs across logged-in accounts, including the current active org.
     */
    listOrgs(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/experimental/console/orgs",
            ...options,
            ...params,
        });
    }
    /**
     * Switch active Console org
     *
     * Persist a new active Console account/org selection for the current local OpenCode state.
     */
    switchOrg(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "accountID" },
                    { in: "body", key: "orgID" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/experimental/console/switch",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Session extends HeyApiClient {
    /**
     * List sessions
     *
     * Get a list of all OpenCode sessions across projects, sorted by most recently updated. Archived sessions are excluded by default.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "query", key: "roots" },
                    { in: "query", key: "start" },
                    { in: "query", key: "cursor" },
                    { in: "query", key: "search" },
                    { in: "query", key: "limit" },
                    { in: "query", key: "archived" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/experimental/session",
            ...options,
            ...params,
        });
    }
    /**
     * Background subagents
     *
     * Detach any synchronous subagents currently blocking the session and continue them in the background.
     */
    background(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/experimental/session/{sessionID}/background",
            ...options,
            ...params,
        });
    }
}
export class Resource extends HeyApiClient {
    /**
     * Get MCP resources
     *
     * Get all available MCP resources from connected servers. Optionally filter by name.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/experimental/resource",
            ...options,
            ...params,
        });
    }
}
export class ProjectCopy extends HeyApiClient {
    /**
     * Generate project copy name
     *
     * Generate a short name for a project copy from task context.
     */
    generateName(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "projectID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "context" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/experimental/project/{projectID}/copy/generate-name",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Adapter extends HeyApiClient {
    /**
     * List workspace adapters
     *
     * List all available workspace adapters for the current project.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/experimental/workspace/adapter",
            ...options,
            ...params,
        });
    }
}
export class Workspace extends HeyApiClient {
    /**
     * List workspaces
     *
     * List all workspaces.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/experimental/workspace",
            ...options,
            ...params,
        });
    }
    /**
     * Create workspace
     *
     * Create a workspace for the current project.
     */
    create(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "id" },
                    { in: "body", key: "type" },
                    { in: "body", key: "branch" },
                    { in: "body", key: "extra" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/experimental/workspace",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Sync workspace list
     *
     * Register missing workspaces returned by workspace adapters.
     */
    syncList(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/experimental/workspace/sync-list",
            ...options,
            ...params,
        });
    }
    /**
     * Workspace status
     *
     * Get connection status for workspaces in the current project.
     */
    status(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/experimental/workspace/status",
            ...options,
            ...params,
        });
    }
    /**
     * Remove workspace
     *
     * Remove an existing workspace.
     */
    remove(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "id" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).delete({
            url: "/experimental/workspace/{id}",
            ...options,
            ...params,
        });
    }
    /**
     * Warp session into workspace
     *
     * Move a session's sync history into the target workspace, or detach it to the local project.
     */
    warp(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "id" },
                    { in: "body", key: "sessionID" },
                    { in: "body", key: "copyChanges" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/experimental/workspace/warp",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    _adapter;
    get adapter() {
        return (this._adapter ??= new Adapter({ client: this.client }));
    }
}
export class Experimental extends HeyApiClient {
    _controlPlane;
    get controlPlane() {
        return (this._controlPlane ??= new ControlPlane({ client: this.client }));
    }
    _capabilities;
    get capabilities() {
        return (this._capabilities ??= new Capabilities({ client: this.client }));
    }
    _console;
    get console() {
        return (this._console ??= new Console({ client: this.client }));
    }
    _session;
    get session() {
        return (this._session ??= new Session({ client: this.client }));
    }
    _resource;
    get resource() {
        return (this._resource ??= new Resource({ client: this.client }));
    }
    _projectCopy;
    get projectCopy() {
        return (this._projectCopy ??= new ProjectCopy({ client: this.client }));
    }
    _workspace;
    get workspace() {
        return (this._workspace ??= new Workspace({ client: this.client }));
    }
}
export class Config extends HeyApiClient {
    /**
     * Get global configuration
     *
     * Retrieve the current global OpenCode configuration settings and preferences.
     */
    get(options) {
        return (options?.client ?? this.client).get({
            url: "/global/config",
            ...options,
        });
    }
    /**
     * Update global configuration
     *
     * Update global OpenCode configuration settings and preferences.
     */
    update(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ key: "config", map: "body" }] }]);
        return (options?.client ?? this.client).patch({
            url: "/global/config",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Global extends HeyApiClient {
    /**
     * Get health
     *
     * Get health information about the OpenCode server.
     */
    health(options) {
        return (options?.client ?? this.client).get({
            url: "/global/health",
            ...options,
        });
    }
    /**
     * Get global events
     *
     * Subscribe to global events from the OpenCode system using server-sent events.
     */
    event(options) {
        return (options?.client ?? this.client).sse.get({
            url: "/global/event",
            ...options,
        });
    }
    /**
     * Dispose instance
     *
     * Clean up and dispose all OpenCode instances, releasing all resources.
     */
    dispose(options) {
        return (options?.client ?? this.client).post({
            url: "/global/dispose",
            ...options,
        });
    }
    /**
     * Upgrade opencode
     *
     * Upgrade opencode to the specified version or latest if not specified.
     */
    upgrade(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "body", key: "target" }] }]);
        return (options?.client ?? this.client).post({
            url: "/global/upgrade",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    _config;
    get config() {
        return (this._config ??= new Config({ client: this.client }));
    }
}
export class Event extends HeyApiClient {
    /**
     * Subscribe to events
     *
     * Get events
     */
    subscribe(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).sse.get({
            url: "/event",
            ...options,
            ...params,
        });
    }
}
export class Config2 extends HeyApiClient {
    /**
     * Get configuration
     *
     * Retrieve the current OpenCode configuration settings and preferences.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/config",
            ...options,
            ...params,
        });
    }
    /**
     * Update configuration
     *
     * Update OpenCode configuration settings and preferences.
     */
    update(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { key: "config", map: "body" },
                ],
            },
        ]);
        return (options?.client ?? this.client).patch({
            url: "/config",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * List config providers
     *
     * Get a list of all configured AI providers and their default models.
     */
    providers(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/config/providers",
            ...options,
            ...params,
        });
    }
}
export class Tool extends HeyApiClient {
    /**
     * List tools
     *
     * Get a list of available tools with their JSON schema parameters for a specific provider and model combination.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "query", key: "provider" },
                    { in: "query", key: "model" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/experimental/tool",
            ...options,
            ...params,
        });
    }
    /**
     * List tool IDs
     *
     * Get a list of all available tool IDs, including both built-in tools and dynamically registered tools.
     */
    ids(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/experimental/tool/ids",
            ...options,
            ...params,
        });
    }
}
export class Worktree extends HeyApiClient {
    /**
     * Remove worktree
     *
     * Remove a git worktree and delete its branch.
     */
    remove(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { key: "worktreeRemoveInput", map: "body" },
                ],
            },
        ]);
        return (options?.client ?? this.client).delete({
            url: "/experimental/worktree",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * List worktrees
     *
     * List all sandbox worktrees for the current project.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/experimental/worktree",
            ...options,
            ...params,
        });
    }
    /**
     * Create worktree
     *
     * Create a new git worktree for the current project and run any configured startup scripts.
     */
    create(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { key: "worktreeCreateInput", map: "body" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/experimental/worktree",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Reset worktree
     *
     * Reset a worktree branch to the primary default branch.
     */
    reset(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { key: "worktreeResetInput", map: "body" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/experimental/worktree/reset",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Find extends HeyApiClient {
    /**
     * Find text
     *
     * Search for text patterns across files in the project using ripgrep.
     */
    text(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "query", key: "pattern" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/find",
            ...options,
            ...params,
        });
    }
    /**
     * Find files
     *
     * Search for files or directories by name or pattern in the project directory.
     */
    files(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "query", key: "query" },
                    { in: "query", key: "dirs" },
                    { in: "query", key: "type" },
                    { in: "query", key: "limit" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/find/file",
            ...options,
            ...params,
        });
    }
    /**
     * Find symbols
     *
     * Search for workspace symbols like functions, classes, and variables using LSP.
     */
    symbols(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "query", key: "query" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/find/symbol",
            ...options,
            ...params,
        });
    }
}
export class File extends HeyApiClient {
    /**
     * List files
     *
     * List files and directories in a specified path.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "query", key: "path" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/file",
            ...options,
            ...params,
        });
    }
    /**
     * Read file
     *
     * Read the content of a specified file.
     */
    read(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "query", key: "path" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/file/content",
            ...options,
            ...params,
        });
    }
    /**
     * Get file status
     *
     * Get the git status of all files in the project.
     */
    status(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/file/status",
            ...options,
            ...params,
        });
    }
}
export class Instance extends HeyApiClient {
    /**
     * Dispose instance
     *
     * Clean up and dispose the current OpenCode instance, releasing all resources.
     */
    dispose(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/instance/dispose",
            ...options,
            ...params,
        });
    }
}
export class Path extends HeyApiClient {
    /**
     * Get paths
     *
     * Retrieve the current working directory and related path information for the OpenCode instance.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/path",
            ...options,
            ...params,
        });
    }
}
export class Diff extends HeyApiClient {
    /**
     * Get raw VCS diff
     *
     * Retrieve a raw patch for current uncommitted changes.
     */
    raw(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/vcs/diff/raw",
            ...options,
            ...params,
        });
    }
}
export class Vcs extends HeyApiClient {
    /**
     * Get VCS info
     *
     * Retrieve version control system (VCS) information for the current project, such as git branch.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/vcs",
            ...options,
            ...params,
        });
    }
    /**
     * Get VCS status
     *
     * Retrieve changed files in the current working tree without patches.
     */
    status(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/vcs/status",
            ...options,
            ...params,
        });
    }
    /**
     * Get VCS diff
     *
     * Retrieve the current git diff for the working tree or against the default branch.
     */
    diff(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "query", key: "mode" },
                    { in: "query", key: "context" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/vcs/diff",
            ...options,
            ...params,
        });
    }
    /**
     * Apply VCS patch
     *
     * Apply a raw patch to the current working tree.
     */
    apply(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "patch" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/vcs/apply",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    _diff;
    get diff2() {
        return (this._diff ??= new Diff({ client: this.client }));
    }
}
export class Command extends HeyApiClient {
    /**
     * List commands
     *
     * Get a list of all available commands in the OpenCode system.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/command",
            ...options,
            ...params,
        });
    }
}
export class Lsp extends HeyApiClient {
    /**
     * Get LSP status
     *
     * Get LSP server status
     */
    status(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/lsp",
            ...options,
            ...params,
        });
    }
}
export class Formatter extends HeyApiClient {
    /**
     * Get formatter status
     *
     * Get formatter status
     */
    status(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/formatter",
            ...options,
            ...params,
        });
    }
}
export class Auth2 extends HeyApiClient {
    /**
     * Remove MCP OAuth
     *
     * Remove OAuth credentials for an MCP server.
     */
    remove(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "name" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).delete({
            url: "/mcp/{name}/auth",
            ...options,
            ...params,
        });
    }
    /**
     * Start MCP OAuth
     *
     * Start OAuth authentication flow for a Model Context Protocol (MCP) server.
     */
    start(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "name" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/mcp/{name}/auth",
            ...options,
            ...params,
        });
    }
    /**
     * Complete MCP OAuth
     *
     * Complete OAuth authentication for a Model Context Protocol (MCP) server using the authorization code.
     */
    callback(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "name" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "code" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/mcp/{name}/auth/callback",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Authenticate MCP OAuth
     *
     * Start OAuth flow and wait for callback (opens browser).
     */
    authenticate(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "name" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/mcp/{name}/auth/authenticate",
            ...options,
            ...params,
        });
    }
}
export class Mcp extends HeyApiClient {
    /**
     * Get MCP status
     *
     * Get the status of all Model Context Protocol (MCP) servers.
     */
    status(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/mcp",
            ...options,
            ...params,
        });
    }
    /**
     * Add MCP server
     *
     * Dynamically add a new Model Context Protocol (MCP) server to the system.
     */
    add(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "name" },
                    { in: "body", key: "config" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/mcp",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Connect an MCP server.
     */
    connect(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "name" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/mcp/{name}/connect",
            ...options,
            ...params,
        });
    }
    /**
     * Disconnect an MCP server.
     */
    disconnect(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "name" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/mcp/{name}/disconnect",
            ...options,
            ...params,
        });
    }
    _auth;
    get auth() {
        return (this._auth ??= new Auth2({ client: this.client }));
    }
}
export class Project extends HeyApiClient {
    /**
     * List all projects
     *
     * Get a list of projects that have been opened with OpenCode.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/project",
            ...options,
            ...params,
        });
    }
    /**
     * Get current project
     *
     * Retrieve the currently active project that OpenCode is working with.
     */
    current(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/project/current",
            ...options,
            ...params,
        });
    }
    /**
     * Initialize git repository
     *
     * Create a git repository for the current project and return the refreshed project info.
     */
    initGit(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/project/git/init",
            ...options,
            ...params,
        });
    }
    /**
     * Update project
     *
     * Update project properties such as name, icon, and commands.
     */
    update(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "projectID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "name" },
                    { in: "body", key: "icon" },
                    { in: "body", key: "commands" },
                ],
            },
        ]);
        return (options?.client ?? this.client).patch({
            url: "/project/{projectID}",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * List project directories
     *
     * List known local absolute directories for a project.
     */
    directories(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "projectID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/project/{projectID}/directories",
            ...options,
            ...params,
        });
    }
}
export class Pty extends HeyApiClient {
    /**
     * List available shells
     *
     * Get a list of available shells on the system.
     */
    shells(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/pty/shells",
            ...options,
            ...params,
        });
    }
    /**
     * List PTY sessions
     *
     * Get a list of all active pseudo-terminal (PTY) sessions managed by OpenCode.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/pty",
            ...options,
            ...params,
        });
    }
    /**
     * Create PTY session
     *
     * Create a new pseudo-terminal (PTY) session for running shell commands and processes.
     */
    create(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "command" },
                    { in: "body", key: "args" },
                    { in: "body", key: "cwd" },
                    { in: "body", key: "title" },
                    { in: "body", key: "env" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/pty",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Remove PTY session
     *
     * Remove and terminate a specific pseudo-terminal (PTY) session.
     */
    remove(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "ptyID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).delete({
            url: "/pty/{ptyID}",
            ...options,
            ...params,
        });
    }
    /**
     * Get PTY session
     *
     * Retrieve detailed information about a specific pseudo-terminal (PTY) session.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "ptyID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/pty/{ptyID}",
            ...options,
            ...params,
        });
    }
    /**
     * Update PTY session
     *
     * Update properties of an existing pseudo-terminal (PTY) session.
     */
    update(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "ptyID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "title" },
                    { in: "body", key: "size" },
                ],
            },
        ]);
        return (options?.client ?? this.client).put({
            url: "/pty/{ptyID}",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Create PTY WebSocket token
     *
     * Create a short-lived ticket for opening a PTY WebSocket connection.
     */
    connectToken(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "ptyID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/pty/{ptyID}/connect-token",
            ...options,
            ...params,
        });
    }
    /**
     * Connect to PTY session
     *
     * Establish a WebSocket connection to interact with a pseudo-terminal (PTY) session in real-time.
     */
    connect(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "ptyID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "query", key: "cursor" },
                    { in: "query", key: "ticket" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/pty/{ptyID}/connect",
            ...options,
            ...params,
        });
    }
}
export class Question extends HeyApiClient {
    /**
     * List pending questions
     *
     * Get all pending question requests across all sessions.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/question",
            ...options,
            ...params,
        });
    }
    /**
     * Reply to question request
     *
     * Provide answers to a question request from the AI assistant.
     */
    reply(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "requestID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "answers" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/question/{requestID}/reply",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Reject question request
     *
     * Reject a question request from the AI assistant.
     */
    reject(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "requestID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/question/{requestID}/reject",
            ...options,
            ...params,
        });
    }
}
export class Permission extends HeyApiClient {
    /**
     * List pending permissions
     *
     * Get all pending permission requests across all sessions.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/permission",
            ...options,
            ...params,
        });
    }
    /**
     * Respond to permission request
     *
     * Approve or deny a permission request from the AI assistant.
     */
    reply(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "requestID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "reply" },
                    { in: "body", key: "message" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/permission/{requestID}/reply",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Respond to permission
     *
     * Approve or deny a permission request from the AI assistant.
     *
     * @deprecated
     */
    respond(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "path", key: "permissionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "response" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session/{sessionID}/permissions/{permissionID}",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Oauth extends HeyApiClient {
    /**
     * Start OAuth authorization
     *
     * Start the OAuth authorization flow for a provider.
     */
    authorize(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "providerID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "method" },
                    { in: "body", key: "inputs" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/provider/{providerID}/oauth/authorize",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Handle OAuth callback
     *
     * Handle the OAuth callback from a provider after user authorization.
     */
    callback(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "providerID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "method" },
                    { in: "body", key: "code" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/provider/{providerID}/oauth/callback",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Provider extends HeyApiClient {
    /**
     * List providers
     *
     * Get a list of all available AI providers, including both available and connected ones.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/provider",
            ...options,
            ...params,
        });
    }
    /**
     * Get provider auth methods
     *
     * Retrieve available authentication methods for all AI providers.
     */
    auth(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/provider/auth",
            ...options,
            ...params,
        });
    }
    _oauth;
    get oauth() {
        return (this._oauth ??= new Oauth({ client: this.client }));
    }
}
export class Session2 extends HeyApiClient {
    /**
     * List sessions
     *
     * Get a list of all OpenCode sessions, sorted by most recently updated.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "query", key: "scope" },
                    { in: "query", key: "path" },
                    { in: "query", key: "roots" },
                    { in: "query", key: "start" },
                    { in: "query", key: "search" },
                    { in: "query", key: "limit" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/session",
            ...options,
            ...params,
        });
    }
    /**
     * Create session
     *
     * Create a new OpenCode session for interacting with AI assistants and managing conversations.
     */
    create(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "parentID" },
                    { in: "body", key: "title" },
                    { in: "body", key: "agent" },
                    { in: "body", key: "model" },
                    { in: "body", key: "metadata" },
                    { in: "body", key: "permission" },
                    { in: "body", key: "workspaceID" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Get session status
     *
     * Retrieve the current status of all sessions, including active, idle, and completed states.
     */
    status(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/session/status",
            ...options,
            ...params,
        });
    }
    /**
     * Delete session
     *
     * Delete a session and permanently remove all associated data, including messages and history.
     */
    delete(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).delete({
            url: "/session/{sessionID}",
            ...options,
            ...params,
        });
    }
    /**
     * Get session
     *
     * Retrieve detailed information about a specific OpenCode session.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/session/{sessionID}",
            ...options,
            ...params,
        });
    }
    /**
     * Update session
     *
     * Update properties of an existing session, such as title or other metadata.
     */
    update(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "title" },
                    { in: "body", key: "metadata" },
                    { in: "body", key: "permission" },
                    { in: "body", key: "time" },
                ],
            },
        ]);
        return (options?.client ?? this.client).patch({
            url: "/session/{sessionID}",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Get session children
     *
     * Retrieve all child sessions that were forked from the specified parent session.
     */
    children(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/session/{sessionID}/children",
            ...options,
            ...params,
        });
    }
    /**
     * Get session todos
     *
     * Retrieve the todo list associated with a specific session, showing tasks and action items.
     */
    todo(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/session/{sessionID}/todo",
            ...options,
            ...params,
        });
    }
    /**
     * Get message diff
     *
     * Get the file changes (diff) that resulted from a specific user message in the session.
     */
    diff(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "query", key: "messageID" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/session/{sessionID}/diff",
            ...options,
            ...params,
        });
    }
    /**
     * Get session messages
     *
     * Retrieve all messages in a session, including user prompts and AI responses.
     */
    messages(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "query", key: "limit" },
                    { in: "query", key: "before" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/session/{sessionID}/message",
            ...options,
            ...params,
        });
    }
    /**
     * Send message
     *
     * Create and send a new message to a session, streaming the AI response.
     */
    prompt(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "messageID" },
                    { in: "body", key: "model" },
                    { in: "body", key: "agent" },
                    { in: "body", key: "noReply" },
                    { in: "body", key: "tools" },
                    { in: "body", key: "format" },
                    { in: "body", key: "system" },
                    { in: "body", key: "variant" },
                    { in: "body", key: "parts" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session/{sessionID}/message",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Delete message
     *
     * Permanently delete a specific message and all of its parts from a session without reverting file changes.
     */
    deleteMessage(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "path", key: "messageID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).delete({
            url: "/session/{sessionID}/message/{messageID}",
            ...options,
            ...params,
        });
    }
    /**
     * Get message
     *
     * Retrieve a specific message from a session by its message ID.
     */
    message(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "path", key: "messageID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/session/{sessionID}/message/{messageID}",
            ...options,
            ...params,
        });
    }
    /**
     * Fork session
     *
     * Create a new session by forking an existing session at a specific message point.
     */
    fork(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "messageID" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session/{sessionID}/fork",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Abort session
     *
     * Abort an active session and stop any ongoing AI processing or command execution.
     */
    abort(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session/{sessionID}/abort",
            ...options,
            ...params,
        });
    }
    /**
     * Initialize session
     *
     * Analyze the current application and create an AGENTS.md file with project-specific agent configurations.
     */
    init(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "modelID" },
                    { in: "body", key: "providerID" },
                    { in: "body", key: "messageID" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session/{sessionID}/init",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Unshare session
     *
     * Remove the shareable link for a session, making it private again.
     */
    unshare(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).delete({
            url: "/session/{sessionID}/share",
            ...options,
            ...params,
        });
    }
    /**
     * Share session
     *
     * Create a shareable link for a session, allowing others to view the conversation.
     */
    share(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session/{sessionID}/share",
            ...options,
            ...params,
        });
    }
    /**
     * Summarize session
     *
     * Generate a concise summary of the session using AI compaction to preserve key information.
     */
    summarize(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "providerID" },
                    { in: "body", key: "modelID" },
                    { in: "body", key: "auto" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session/{sessionID}/summarize",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Send async message
     *
     * Create and send a new message to a session asynchronously, starting the session if needed and returning immediately.
     */
    promptAsync(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "messageID" },
                    { in: "body", key: "model" },
                    { in: "body", key: "agent" },
                    { in: "body", key: "noReply" },
                    { in: "body", key: "tools" },
                    { in: "body", key: "format" },
                    { in: "body", key: "system" },
                    { in: "body", key: "variant" },
                    { in: "body", key: "parts" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session/{sessionID}/prompt_async",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Send command
     *
     * Send a new command to a session for execution by the AI assistant.
     */
    command(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "messageID" },
                    { in: "body", key: "agent" },
                    { in: "body", key: "model" },
                    { in: "body", key: "arguments" },
                    { in: "body", key: "command" },
                    { in: "body", key: "variant" },
                    { in: "body", key: "parts" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session/{sessionID}/command",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Run shell command
     *
     * Execute a shell command within the session context and return the AI's response.
     */
    shell(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "messageID" },
                    { in: "body", key: "agent" },
                    { in: "body", key: "model" },
                    { in: "body", key: "command" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session/{sessionID}/shell",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Revert message
     *
     * Revert a specific message in a session, undoing its effects and restoring the previous state.
     */
    revert(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "messageID" },
                    { in: "body", key: "partID" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session/{sessionID}/revert",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Restore reverted messages
     *
     * Restore all previously reverted messages in a session.
     */
    unrevert(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/session/{sessionID}/unrevert",
            ...options,
            ...params,
        });
    }
}
export class Part extends HeyApiClient {
    /**
     * Delete a part from a message.
     */
    delete(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "path", key: "messageID" },
                    { in: "path", key: "partID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).delete({
            url: "/session/{sessionID}/message/{messageID}/part/{partID}",
            ...options,
            ...params,
        });
    }
    /**
     * Update a part in a message.
     */
    update(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "path", key: "messageID" },
                    { in: "path", key: "partID" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { key: "part", map: "body" },
                ],
            },
        ]);
        return (options?.client ?? this.client).patch({
            url: "/session/{sessionID}/message/{messageID}/part/{partID}",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class History extends HeyApiClient {
    /**
     * List sync events
     *
     * List sync events for all aggregates. Keys are aggregate IDs the client already knows about, values are the last known sequence ID. Events with seq > value are returned for those aggregates. Aggregates not listed in the input get their full history.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { key: "body", map: "body" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/sync/history",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Sync extends HeyApiClient {
    /**
     * Start workspace sync
     *
     * Start sync loops for workspaces in the current project that have active sessions.
     */
    start(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/sync/start",
            ...options,
            ...params,
        });
    }
    /**
     * Replay sync events
     *
     * Validate and replay a complete sync event history.
     */
    replay(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    {
                        in: "query",
                        key: "query_directory",
                        map: "directory",
                    },
                    { in: "query", key: "workspace" },
                    {
                        in: "body",
                        key: "body_directory",
                        map: "directory",
                    },
                    { in: "body", key: "events" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/sync/replay",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Steal session into workspace
     *
     * Update a session to belong to the current workspace through the sync event system.
     */
    steal(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "sessionID" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/sync/steal",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    _history;
    get history() {
        return (this._history ??= new History({ client: this.client }));
    }
}
export class Control extends HeyApiClient {
    /**
     * Get next TUI request
     *
     * Retrieve the next TUI request from the queue for processing.
     */
    next(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/tui/control/next",
            ...options,
            ...params,
        });
    }
    /**
     * Submit TUI response
     *
     * Submit a response to the TUI request queue to complete a pending request.
     */
    response(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { key: "body", map: "body" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/tui/control/response",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Tui extends HeyApiClient {
    /**
     * Append TUI prompt
     *
     * Append prompt to the TUI.
     */
    appendPrompt(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "text" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/tui/append-prompt",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Open help dialog
     *
     * Open the help dialog in the TUI to display user assistance information.
     */
    openHelp(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/tui/open-help",
            ...options,
            ...params,
        });
    }
    /**
     * Open sessions dialog
     *
     * Open the session dialog.
     */
    openSessions(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/tui/open-sessions",
            ...options,
            ...params,
        });
    }
    /**
     * Open themes dialog
     *
     * Open the theme dialog.
     */
    openThemes(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/tui/open-themes",
            ...options,
            ...params,
        });
    }
    /**
     * Open models dialog
     *
     * Open the model dialog.
     */
    openModels(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/tui/open-models",
            ...options,
            ...params,
        });
    }
    /**
     * Submit TUI prompt
     *
     * Submit the prompt.
     */
    submitPrompt(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/tui/submit-prompt",
            ...options,
            ...params,
        });
    }
    /**
     * Clear TUI prompt
     *
     * Clear the prompt.
     */
    clearPrompt(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/tui/clear-prompt",
            ...options,
            ...params,
        });
    }
    /**
     * Execute TUI command
     *
     * Execute a TUI command.
     */
    executeCommand(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "command" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/tui/execute-command",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Show TUI toast
     *
     * Show a toast notification in the TUI.
     */
    showToast(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "title" },
                    { in: "body", key: "message" },
                    { in: "body", key: "variant" },
                    { in: "body", key: "duration" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/tui/show-toast",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Publish TUI event
     *
     * Publish a TUI event.
     */
    publish(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { key: "body", map: "body" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/tui/publish",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Select session
     *
     * Navigate the TUI to display the specified session.
     */
    selectSession(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "directory" },
                    { in: "query", key: "workspace" },
                    { in: "body", key: "sessionID" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/tui/select-session",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    _control;
    get control() {
        return (this._control ??= new Control({ client: this.client }));
    }
}
export class Health extends HeyApiClient {
    /**
     * Check server health
     *
     * Check whether the API server is ready to accept requests.
     */
    get(options) {
        return (options?.client ?? this.client).get({
            url: "/api/health",
            ...options,
        });
    }
}
export class Location extends HeyApiClient {
    /**
     * Get location
     *
     * Resolve the requested location or the server default location.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/location",
            ...options,
            ...params,
        });
    }
}
export class Agent extends HeyApiClient {
    /**
     * List agents
     *
     * Retrieve currently registered agents.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/agent",
            ...options,
            ...params,
        });
    }
}
export class Revert extends HeyApiClient {
    /**
     * Stage session revert
     *
     * Stage or move a reversible session boundary and optionally apply its file changes.
     */
    stage(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "body", key: "messageID" },
                    { in: "body", key: "files" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/revert/stage",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Clear staged revert
     */
    clear(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "sessionID" }] }]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/revert/clear",
            ...options,
            ...params,
        });
    }
    /**
     * Commit staged revert
     */
    commit(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "sessionID" }] }]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/revert/commit",
            ...options,
            ...params,
        });
    }
}
export class Permission2 extends HeyApiClient {
    /**
     * List session permission requests
     *
     * Retrieve pending permission requests owned by a session.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "sessionID" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/session/{sessionID}/permission",
            ...options,
            ...params,
        });
    }
    /**
     * Create permission request
     *
     * Evaluate and, when approval is required, create a permission request for a session.
     */
    create(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "body", key: "id" },
                    { in: "body", key: "action" },
                    { in: "body", key: "resources" },
                    { in: "body", key: "save" },
                    { in: "body", key: "metadata" },
                    { in: "body", key: "source" },
                    { in: "body", key: "agent" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/permission",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Get permission request
     *
     * Retrieve a pending permission request owned by a session.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "path", key: "requestID" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/api/session/{sessionID}/permission/{requestID}",
            ...options,
            ...params,
        });
    }
    /**
     * Reply to pending permission request
     *
     * Respond to a pending permission request owned by a session.
     */
    reply(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "path", key: "requestID" },
                    { in: "body", key: "reply" },
                    { in: "body", key: "message" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/permission/{requestID}/reply",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Question2 extends HeyApiClient {
    /**
     * List session question requests
     *
     * Retrieve pending question requests owned by a session.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "sessionID" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/session/{sessionID}/question",
            ...options,
            ...params,
        });
    }
    /**
     * Reply to pending question request
     *
     * Answer a pending question request owned by a session.
     */
    reply(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "path", key: "requestID" },
                    { key: "questionV2Reply", map: "body" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/question/{requestID}/reply",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Reject pending question request
     *
     * Reject a pending question request owned by a session.
     */
    reject(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "path", key: "requestID" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/question/{requestID}/reject",
            ...options,
            ...params,
        });
    }
}
export class Session3 extends HeyApiClient {
    /**
     * List sessions
     *
     * Retrieve sessions in the requested order. Items keep that order across pages; use cursor.next or cursor.previous to move through the ordered list.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "workspace" },
                    { in: "query", key: "limit" },
                    { in: "query", key: "order" },
                    { in: "query", key: "search" },
                    { in: "query", key: "directory" },
                    { in: "query", key: "project" },
                    { in: "query", key: "subpath" },
                    { in: "query", key: "cursor" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/api/session",
            ...options,
            ...params,
        });
    }
    /**
     * Create session
     *
     * Create a session at the requested location.
     */
    create(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "body", key: "id" },
                    { in: "body", key: "agent" },
                    { in: "body", key: "model" },
                    { in: "body", key: "location" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/session",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * List active sessions
     *
     * Retrieve foreground Session drains currently owned by this OpenCode process. Sessions absent from the result are inactive.
     */
    active(options) {
        return (options?.client ?? this.client).get({
            url: "/api/session/active",
            ...options,
        });
    }
    /**
     * Get session
     *
     * Retrieve a session by ID.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "sessionID" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/session/{sessionID}",
            ...options,
            ...params,
        });
    }
    /**
     * Switch session agent
     *
     * Switch the agent used by subsequent provider turns.
     */
    switchAgent(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "body", key: "agent" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/agent",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Switch session model
     *
     * Switch the model used by subsequent provider turns.
     */
    switchModel(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "body", key: "model" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/model",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Send message
     *
     * Durably admit one session input and schedule agent-loop execution unless resume is false.
     */
    prompt(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "body", key: "id" },
                    { in: "body", key: "prompt" },
                    { in: "body", key: "delivery" },
                    { in: "body", key: "resume" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/prompt",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Compact session
     *
     * Compact a session conversation.
     */
    compact(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "sessionID" }] }]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/compact",
            ...options,
            ...params,
        });
    }
    /**
     * Wait for session
     *
     * Wait for a session agent loop to become idle.
     */
    wait(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "sessionID" }] }]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/wait",
            ...options,
            ...params,
        });
    }
    /**
     * Get session context
     *
     * Retrieve the active context messages for a session (all messages after the last compaction).
     */
    context(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "sessionID" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/session/{sessionID}/context",
            ...options,
            ...params,
        });
    }
    /**
     * Get session history
     *
     * Read one finite page of public durable Session events after an exclusive aggregate sequence. Newly committed events may appear on later pages.
     */
    history(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "limit" },
                    { in: "query", key: "after" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/api/session/{sessionID}/history",
            ...options,
            ...params,
        });
    }
    /**
     * Subscribe to session events
     *
     * Replay durable events after an aggregate sequence, then continue with new durable events.
     */
    events(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "after" },
                ],
            },
        ]);
        return (options?.client ?? this.client).sse.get({
            url: "/api/session/{sessionID}/event",
            ...options,
            ...params,
        });
    }
    /**
     * Interrupt session execution
     *
     * Interrupt active execution owned by this OpenCode process. Idle interruption is a no-op.
     */
    interrupt(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "sessionID" }] }]);
        return (options?.client ?? this.client).post({
            url: "/api/session/{sessionID}/interrupt",
            ...options,
            ...params,
        });
    }
    /**
     * Get session message
     *
     * Retrieve one projected message owned by the Session.
     */
    message(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "path", key: "messageID" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/api/session/{sessionID}/message/{messageID}",
            ...options,
            ...params,
        });
    }
    /**
     * Get session messages
     *
     * Retrieve projected messages for a session. Items keep the requested order across pages; use cursor.next or cursor.previous to move through the ordered timeline.
     */
    messages(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "sessionID" },
                    { in: "query", key: "limit" },
                    { in: "query", key: "order" },
                    { in: "query", key: "cursor" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/api/session/{sessionID}/message",
            ...options,
            ...params,
        });
    }
    _revert;
    get revert() {
        return (this._revert ??= new Revert({ client: this.client }));
    }
    _permission;
    get permission() {
        return (this._permission ??= new Permission2({ client: this.client }));
    }
    _question;
    get question() {
        return (this._question ??= new Question2({ client: this.client }));
    }
}
export class Model extends HeyApiClient {
    /**
     * List models
     *
     * Retrieve available models ordered by release date.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/model",
            ...options,
            ...params,
        });
    }
}
export class Provider2 extends HeyApiClient {
    /**
     * List providers
     *
     * Retrieve active AI providers so clients can show provider availability and configuration.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/provider",
            ...options,
            ...params,
        });
    }
    /**
     * Get provider
     *
     * Retrieve a single AI provider so clients can inspect its availability and endpoint settings.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "providerID" },
                    { in: "query", key: "location" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/api/provider/{providerID}",
            ...options,
            ...params,
        });
    }
}
export class Connect extends HeyApiClient {
    /**
     * Connect with key
     *
     * Run a key authentication method and store the resulting credential.
     */
    key(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "integrationID" },
                    { in: "query", key: "location" },
                    { in: "body", key: "key" },
                    { in: "body", key: "label" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/integration/{integrationID}/connect/key",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Begin OAuth connection
     *
     * Start an OAuth attempt and return the authorization details.
     */
    oauth(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "integrationID" },
                    { in: "query", key: "location" },
                    { in: "body", key: "methodID" },
                    { in: "body", key: "inputs" },
                    { in: "body", key: "label" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/integration/{integrationID}/connect/oauth",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Attempt extends HeyApiClient {
    /**
     * Cancel OAuth connection
     *
     * Cancel an OAuth attempt and release its resources.
     */
    cancel(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "attemptID" },
                    { in: "query", key: "location" },
                ],
            },
        ]);
        return (options?.client ?? this.client).delete({
            url: "/api/integration/attempt/{attemptID}",
            ...options,
            ...params,
        });
    }
    /**
     * Get OAuth attempt status
     *
     * Poll the current status of an OAuth attempt.
     */
    status(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "attemptID" },
                    { in: "query", key: "location" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/api/integration/attempt/{attemptID}",
            ...options,
            ...params,
        });
    }
    /**
     * Complete OAuth connection
     *
     * Complete a code-based OAuth attempt and store the resulting credential.
     */
    complete(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "attemptID" },
                    { in: "query", key: "location" },
                    { in: "body", key: "code" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/integration/attempt/{attemptID}/complete",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Integration extends HeyApiClient {
    /**
     * List integrations
     *
     * Retrieve available integrations and their authentication methods.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/integration",
            ...options,
            ...params,
        });
    }
    /**
     * Get integration
     *
     * Retrieve one integration and its authentication methods.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "integrationID" },
                    { in: "query", key: "location" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/api/integration/{integrationID}",
            ...options,
            ...params,
        });
    }
    _connect;
    get connect() {
        return (this._connect ??= new Connect({ client: this.client }));
    }
    _attempt;
    get attempt() {
        return (this._attempt ??= new Attempt({ client: this.client }));
    }
}
export class Credential extends HeyApiClient {
    /**
     * Remove credential
     *
     * Remove a stored integration credential.
     */
    remove(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "credentialID" },
                    { in: "query", key: "location" },
                ],
            },
        ]);
        return (options?.client ?? this.client).delete({
            url: "/api/credential/{credentialID}",
            ...options,
            ...params,
        });
    }
    /**
     * Update credential
     *
     * Update a stored credential label.
     */
    update(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "credentialID" },
                    { in: "query", key: "location" },
                    { in: "body", key: "label" },
                ],
            },
        ]);
        return (options?.client ?? this.client).patch({
            url: "/api/credential/{credentialID}",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
}
export class Request extends HeyApiClient {
    /**
     * List pending permission requests
     *
     * Retrieve pending permission requests for a location.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/permission/request",
            ...options,
            ...params,
        });
    }
}
export class Saved extends HeyApiClient {
    /**
     * List saved permissions
     *
     * Retrieve saved permissions, optionally filtered by project.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "projectID" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/permission/saved",
            ...options,
            ...params,
        });
    }
    /**
     * Remove saved permission
     *
     * Remove a saved permission by ID.
     */
    remove(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "id" }] }]);
        return (options?.client ?? this.client).delete({
            url: "/api/permission/saved/{id}",
            ...options,
            ...params,
        });
    }
}
export class Permission3 extends HeyApiClient {
    _request;
    get request() {
        return (this._request ??= new Request({ client: this.client }));
    }
    _saved;
    get saved() {
        return (this._saved ??= new Saved({ client: this.client }));
    }
}
export class Fs extends HeyApiClient {
    /**
     * Read file
     *
     * Serve one file relative to the requested location.
     */
    read(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/fs/read/*",
            ...options,
            ...params,
        });
    }
    /**
     * List directory
     *
     * List direct children of one directory relative to the requested location.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "location" },
                    { in: "query", key: "path" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/api/fs/list",
            ...options,
            ...params,
        });
    }
    /**
     * Find files
     *
     * Find recursively ranked filesystem entries relative to the requested location.
     */
    find(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "location" },
                    { in: "query", key: "query" },
                    { in: "query", key: "type" },
                    { in: "query", key: "limit" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/api/fs/find",
            ...options,
            ...params,
        });
    }
}
export class Command2 extends HeyApiClient {
    /**
     * List commands
     *
     * Retrieve currently registered commands.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/command",
            ...options,
            ...params,
        });
    }
}
export class Skill extends HeyApiClient {
    /**
     * List skills
     *
     * Retrieve currently registered skills.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/skill",
            ...options,
            ...params,
        });
    }
}
export class Event2 extends HeyApiClient {
    /**
     * Subscribe to events
     *
     * Subscribe to native event payloads for the server.
     */
    subscribe(options) {
        return (options?.client ?? this.client).sse.get({
            url: "/api/event",
            ...options,
        });
    }
}
export class Pty2 extends HeyApiClient {
    /**
     * List PTY sessions
     *
     * List PTY sessions for a location, including exited sessions retained until removal.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/pty",
            ...options,
            ...params,
        });
    }
    /**
     * Create PTY session
     *
     * Create a pseudo-terminal session for a location.
     */
    create(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "query", key: "location" },
                    { in: "body", key: "command" },
                    { in: "body", key: "args" },
                    { in: "body", key: "cwd" },
                    { in: "body", key: "title" },
                    { in: "body", key: "env" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/pty",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Remove PTY session
     *
     * Terminate and remove one PTY session.
     */
    remove(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "ptyID" },
                    { in: "query", key: "location" },
                ],
            },
        ]);
        return (options?.client ?? this.client).delete({
            url: "/api/pty/{ptyID}",
            ...options,
            ...params,
        });
    }
    /**
     * Get PTY session
     *
     * Get one PTY session, including its exit code once exited.
     */
    get(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "ptyID" },
                    { in: "query", key: "location" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/api/pty/{ptyID}",
            ...options,
            ...params,
        });
    }
    /**
     * Update PTY session
     *
     * Update the title or viewport size of one PTY session.
     */
    update(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "ptyID" },
                    { in: "query", key: "location" },
                    { in: "body", key: "title" },
                    { in: "body", key: "size" },
                ],
            },
        ]);
        return (options?.client ?? this.client).put({
            url: "/api/pty/{ptyID}",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    /**
     * Create PTY WebSocket token
     *
     * Create a short-lived single-use ticket for opening a PTY WebSocket connection.
     */
    connectToken(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "ptyID" },
                    { in: "query", key: "location" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/api/pty/{ptyID}/connect-token",
            ...options,
            ...params,
        });
    }
    /**
     * Connect to PTY session
     *
     * Establish a WebSocket connection streaming PTY output and accepting terminal input.
     */
    connect(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "ptyID" },
                    { in: "query", key: "location[directory]" },
                    { in: "query", key: "location[workspace]" },
                    { in: "query", key: "cursor" },
                    { in: "query", key: "ticket" },
                ],
            },
        ]);
        return (options?.client ?? this.client).get({
            url: "/api/pty/{ptyID}/connect",
            ...options,
            ...params,
        });
    }
}
export class Request2 extends HeyApiClient {
    /**
     * List pending question requests
     *
     * Retrieve pending question requests for a location.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/question/request",
            ...options,
            ...params,
        });
    }
}
export class Question3 extends HeyApiClient {
    _request;
    get request() {
        return (this._request ??= new Request2({ client: this.client }));
    }
}
export class Reference extends HeyApiClient {
    /**
     * List references
     *
     * List references available in the requested location.
     */
    list(parameters, options) {
        const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
        return (options?.client ?? this.client).get({
            url: "/api/reference",
            ...options,
            ...params,
        });
    }
}
export class ProjectCopy2 extends HeyApiClient {
    remove(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "projectID" },
                    { in: "query", key: "location" },
                    { in: "body", key: "directory" },
                    { in: "body", key: "force" },
                ],
            },
        ]);
        return (options?.client ?? this.client).delete({
            url: "/experimental/project/{projectID}/copy",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    create(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "projectID" },
                    { in: "query", key: "location" },
                    { in: "body", key: "strategy" },
                    { in: "body", key: "directory" },
                    { in: "body", key: "name" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/experimental/project/{projectID}/copy",
            ...options,
            ...params,
            headers: {
                "Content-Type": "application/json",
                ...options?.headers,
                ...params.headers,
            },
        });
    }
    refresh(parameters, options) {
        const params = buildClientParams([parameters], [
            {
                args: [
                    { in: "path", key: "projectID" },
                    { in: "query", key: "location" },
                ],
            },
        ]);
        return (options?.client ?? this.client).post({
            url: "/experimental/project/{projectID}/copy/refresh",
            ...options,
            ...params,
        });
    }
}
export class V2 extends HeyApiClient {
    _health;
    get health() {
        return (this._health ??= new Health({ client: this.client }));
    }
    _location;
    get location() {
        return (this._location ??= new Location({ client: this.client }));
    }
    _agent;
    get agent() {
        return (this._agent ??= new Agent({ client: this.client }));
    }
    _session;
    get session() {
        return (this._session ??= new Session3({ client: this.client }));
    }
    _model;
    get model() {
        return (this._model ??= new Model({ client: this.client }));
    }
    _provider;
    get provider() {
        return (this._provider ??= new Provider2({ client: this.client }));
    }
    _integration;
    get integration() {
        return (this._integration ??= new Integration({ client: this.client }));
    }
    _credential;
    get credential() {
        return (this._credential ??= new Credential({ client: this.client }));
    }
    _permission;
    get permission() {
        return (this._permission ??= new Permission3({ client: this.client }));
    }
    _fs;
    get fs() {
        return (this._fs ??= new Fs({ client: this.client }));
    }
    _command;
    get command() {
        return (this._command ??= new Command2({ client: this.client }));
    }
    _skill;
    get skill() {
        return (this._skill ??= new Skill({ client: this.client }));
    }
    _event;
    get event() {
        return (this._event ??= new Event2({ client: this.client }));
    }
    _pty;
    get pty() {
        return (this._pty ??= new Pty2({ client: this.client }));
    }
    _question;
    get question() {
        return (this._question ??= new Question3({ client: this.client }));
    }
    _reference;
    get reference() {
        return (this._reference ??= new Reference({ client: this.client }));
    }
    _projectCopy;
    get projectCopy() {
        return (this._projectCopy ??= new ProjectCopy2({ client: this.client }));
    }
}
export class OpencodeClient extends HeyApiClient {
    static __registry = new HeyApiRegistry();
    constructor(args) {
        super(args);
        OpencodeClient.__registry.set(this, args?.key);
    }
    _auth;
    get auth() {
        return (this._auth ??= new Auth({ client: this.client }));
    }
    _app;
    get app() {
        return (this._app ??= new App({ client: this.client }));
    }
    _experimental;
    get experimental() {
        return (this._experimental ??= new Experimental({ client: this.client }));
    }
    _global;
    get global() {
        return (this._global ??= new Global({ client: this.client }));
    }
    _event;
    get event() {
        return (this._event ??= new Event({ client: this.client }));
    }
    _config;
    get config() {
        return (this._config ??= new Config2({ client: this.client }));
    }
    _tool;
    get tool() {
        return (this._tool ??= new Tool({ client: this.client }));
    }
    _worktree;
    get worktree() {
        return (this._worktree ??= new Worktree({ client: this.client }));
    }
    _find;
    get find() {
        return (this._find ??= new Find({ client: this.client }));
    }
    _file;
    get file() {
        return (this._file ??= new File({ client: this.client }));
    }
    _instance;
    get instance() {
        return (this._instance ??= new Instance({ client: this.client }));
    }
    _path;
    get path() {
        return (this._path ??= new Path({ client: this.client }));
    }
    _vcs;
    get vcs() {
        return (this._vcs ??= new Vcs({ client: this.client }));
    }
    _command;
    get command() {
        return (this._command ??= new Command({ client: this.client }));
    }
    _lsp;
    get lsp() {
        return (this._lsp ??= new Lsp({ client: this.client }));
    }
    _formatter;
    get formatter() {
        return (this._formatter ??= new Formatter({ client: this.client }));
    }
    _mcp;
    get mcp() {
        return (this._mcp ??= new Mcp({ client: this.client }));
    }
    _project;
    get project() {
        return (this._project ??= new Project({ client: this.client }));
    }
    _pty;
    get pty() {
        return (this._pty ??= new Pty({ client: this.client }));
    }
    _question;
    get question() {
        return (this._question ??= new Question({ client: this.client }));
    }
    _permission;
    get permission() {
        return (this._permission ??= new Permission({ client: this.client }));
    }
    _provider;
    get provider() {
        return (this._provider ??= new Provider({ client: this.client }));
    }
    _session;
    get session() {
        return (this._session ??= new Session2({ client: this.client }));
    }
    _part;
    get part() {
        return (this._part ??= new Part({ client: this.client }));
    }
    _sync;
    get sync() {
        return (this._sync ??= new Sync({ client: this.client }));
    }
    _tui;
    get tui() {
        return (this._tui ??= new Tui({ client: this.client }));
    }
    _v2;
    get v2() {
        return (this._v2 ??= new V2({ client: this.client }));
    }
}