export type ClientOptions = {
    baseURL: `${string}://${string}` | (string & {});
};
export type McpServer = {
    name: string;
    transport: 'stdio' | 'http' | 'sse';
    command?: string;
    args: Array<string>;
    url?: string;
    env?: {
        [key: string]: string;
    };
    headers?: {
        [key: string]: string;
    };
    disabled: boolean;
    connected: boolean;
    tools: Array<string>;
    error?: string;
    authRequired: boolean;
    authenticated: boolean;
    scope: 'global' | 'project';
    authType?: string;
    sourceKind?: 'user' | 'plugin';
    sourcePlugin?: string;
    sourceLabel?: string;
    managedByPlugin?: boolean;
    overridesPlugin?: string;
    [key: string]: unknown | string | 'stdio' | 'http' | 'sse' | Array<string> | {
        [key: string]: string;
    } | {
        [key: string]: string;
    } | boolean | Array<string> | 'global' | 'project' | 'user' | 'plugin' | undefined;
};
export type UsageStats = {
    scope: 'project' | 'global';
    project: string;
    generatedAt: number;
    range: {
        days: number | null;
        since: number | null;
    };
    totals: {
        messages: number;
        sessions: number;
        inputTokens: number;
        outputTokens: number;
        cachedInputTokens: number;
        cacheCreationInputTokens: number;
        reasoningTokens: number;
        costUsd: number;
        notionalCostUsd: number;
        savedUsd: number;
        costByAuth: {
            oauth: number;
            api: number;
            subscription: number;
        };
        messagesByAuth: {
            oauth: number;
            api: number;
            subscription: number;
        };
    };
    previousTotals: {
        messages: number;
        sessions: number;
        inputTokens: number;
        outputTokens: number;
        cachedInputTokens: number;
        cacheCreationInputTokens: number;
        reasoningTokens: number;
        costUsd: number;
        notionalCostUsd: number;
        savedUsd: number;
        costByAuth: {
            oauth: number;
            api: number;
            subscription: number;
        };
        messagesByAuth: {
            oauth: number;
            api: number;
            subscription: number;
        };
    } | null;
    providers: Array<{
        provider: string;
        authType: 'oauth' | 'api' | 'wallet' | 'subscription' | 'unknown';
        messages: number;
        sessions: number;
        inputTokens: number;
        outputTokens: number;
        cachedInputTokens: number;
        cacheCreationInputTokens: number;
        reasoningTokens: number;
        costUsd: number;
        notionalCostUsd: number;
    }>;
    models: Array<{
        provider: string;
        model: string;
        authType: 'oauth' | 'api' | 'wallet' | 'subscription' | 'unknown';
        messages: number;
        inputTokens: number;
        outputTokens: number;
        cachedInputTokens: number;
        cacheCreationInputTokens: number;
        reasoningTokens: number;
        costUsd: number;
        notionalCostUsd: number;
    }>;
    daily: Array<{
        date: string;
        messages: number;
        inputTokens: number;
        outputTokens: number;
        costUsd: number;
        notionalCostUsd: number;
        costByAuth: {
            oauth: number;
            api: number;
            subscription: number;
        };
        notionalByAuth: {
            oauth: number;
            api: number;
            subscription: number;
        };
    }>;
    notes: {
        oauthProviders: Array<string>;
        subscriptionProviders: Array<string>;
        missingPricing: Array<string>;
    };
    projects?: {
        included: Array<{
            id: string;
            name: string;
            path: string;
            lastSeenAt: number;
            messages: number;
            notionalCostUsd: number;
        }>;
        unavailable: Array<{
            id: string;
            name: string;
            path: string;
            reason: string;
        }>;
    };
};
export type GetRootData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/';
};
export type GetRootResponses = {
    /**
     * Server is running
     */
    200: string;
};
export type GetRootResponse = GetRootResponses[keyof GetRootResponses];
export type GetServerInfoData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/server/info';
};
export type GetServerInfoResponses = {
    /**
     * Server runtime metadata
     */
    200: {
        port: number | null;
        version: string | null;
        pid: number;
        daemonId: string | null;
        startedAt: number;
        protocol: {
            version: number;
            minVersion: number;
            maxVersion: number;
            capabilities: Array<string>;
        };
    };
};
export type GetServerInfoResponse = GetServerInfoResponses[keyof GetServerInfoResponses];
export type StageServerUpgradeData = {
    body: {
        targetVersion: string;
    };
    path?: never;
    query?: never;
    url: '/v1/server/upgrade';
};
export type StageServerUpgradeResponses = {
    /**
     * Upgrade staged; reconnect after an owner-managed restart
     */
    200: {
        status: 'staged';
        targetVersion: string;
        stagedPath: string;
        restartRequired: true;
    };
};
export type StageServerUpgradeResponse = StageServerUpgradeResponses[keyof StageServerUpgradeResponses];
export type RestartServerData = {
    body: {
        targetVersion?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/server/restart';
};
export type RestartServerResponses = {
    /**
     * Supervised daemon restart queued
     */
    202: {
        status: 'restarting';
        targetVersion: string | null;
    };
};
export type RestartServerResponse = RestartServerResponses[keyof RestartServerResponses];
export type ListProjectsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/projects';
};
export type ListProjectsResponses = {
    /**
     * OK
     */
    200: {
        projects: Array<{
            id: string;
            name: string;
            path: string;
            stateDir: string;
            dbPath: string;
            openedAt?: number;
            lastUsedAt: number;
            open: boolean;
            pinned: boolean;
        }>;
    };
};
export type ListProjectsResponse = ListProjectsResponses[keyof ListProjectsResponses];
export type OpenProjectData = {
    body: {
        path: string;
    };
    path?: never;
    query?: never;
    url: '/v1/projects/open';
};
export type OpenProjectResponses = {
    /**
     * OK
     */
    200: {
        id: string;
        name: string;
        path: string;
        stateDir: string;
        dbPath: string;
        openedAt?: number;
        lastUsedAt: number;
        open: boolean;
        pinned: boolean;
    };
};
export type OpenProjectResponse = OpenProjectResponses[keyof OpenProjectResponses];
export type ListProjectDirectoriesData = {
    body?: never;
    path?: never;
    query?: {
        path?: string;
    };
    url: '/v1/projects/directories';
};
export type ListProjectDirectoriesResponses = {
    /**
     * Host directory listing
     */
    200: {
        path: string;
        parent: string | null;
        directories: Array<{
            name: string;
            path: string;
        }>;
        truncated: boolean;
    };
};
export type ListProjectDirectoriesResponse = ListProjectDirectoriesResponses[keyof ListProjectDirectoriesResponses];
export type OpenGeneralProjectData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/projects/general/open';
};
export type OpenGeneralProjectResponses = {
    /**
     * General project
     */
    200: {
        id: string;
        name: string;
        path: string;
        stateDir: string;
        dbPath: string;
        openedAt?: number;
        lastUsedAt: number;
        open: boolean;
        pinned: boolean;
    };
};
export type OpenGeneralProjectResponse = OpenGeneralProjectResponses[keyof OpenGeneralProjectResponses];
export type ForgetProjectData = {
    body?: never;
    path: {
        /**
         * Stable otto project id
         */
        projectId: string;
    };
    query?: never;
    url: '/v1/projects/{projectId}';
};
export type ForgetProjectErrors = {
    /**
     * Not Found
     */
    404: {
        error: string;
    };
};
export type ForgetProjectError = ForgetProjectErrors[keyof ForgetProjectErrors];
export type ForgetProjectResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
    };
};
export type ForgetProjectResponse = ForgetProjectResponses[keyof ForgetProjectResponses];
export type GetProjectData = {
    body?: never;
    path: {
        /**
         * Stable otto project id
         */
        projectId: string;
    };
    query?: never;
    url: '/v1/projects/{projectId}';
};
export type GetProjectErrors = {
    /**
     * Not Found
     */
    404: {
        error: string;
    };
};
export type GetProjectError = GetProjectErrors[keyof GetProjectErrors];
export type GetProjectResponses = {
    /**
     * OK
     */
    200: {
        id: string;
        name: string;
        path: string;
        stateDir: string;
        dbPath: string;
        openedAt?: number;
        lastUsedAt: number;
        open: boolean;
        pinned: boolean;
    };
};
export type GetProjectResponse = GetProjectResponses[keyof GetProjectResponses];
export type SetProjectPinnedData = {
    body: {
        pinned: boolean;
    };
    path: {
        /**
         * Stable otto project id
         */
        projectId: string;
    };
    query?: never;
    url: '/v1/projects/{projectId}/pinned';
};
export type SetProjectPinnedErrors = {
    /**
     * Not Found
     */
    404: {
        error: string;
    };
};
export type SetProjectPinnedError = SetProjectPinnedErrors[keyof SetProjectPinnedErrors];
export type SetProjectPinnedResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
    };
};
export type SetProjectPinnedResponse = SetProjectPinnedResponses[keyof SetProjectPinnedResponses];
export type CloseProjectData = {
    body?: never;
    path: {
        /**
         * Stable otto project id
         */
        projectId: string;
    };
    query?: never;
    url: '/v1/projects/{projectId}/close';
};
export type CloseProjectResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
    };
};
export type CloseProjectResponse = CloseProjectResponses[keyof CloseProjectResponses];
export type TouchProjectRuntimeData = {
    body?: never;
    path: {
        /**
         * Stable otto project id
         */
        projectId: string;
    };
    query?: never;
    url: '/v1/projects/{projectId}/touch';
};
export type TouchProjectRuntimeResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
    };
};
export type TouchProjectRuntimeResponse = TouchProjectRuntimeResponses[keyof TouchProjectRuntimeResponses];
export type ListSessionsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
        /**
         * Maximum number of sessions to return
         */
        limit?: number;
        /**
         * Offset for pagination
         */
        offset?: number | null;
        /**
         * Filter to a specific session type. Currently only "looper" is supported; omit for the default listing (which excludes looper sessions).
         */
        sessionType?: 'looper';
    };
    url: '/v1/sessions';
};
export type ListSessionsResponses = {
    /**
     * OK
     */
    200: {
        items: Array<{
            id: string;
            title: string | null;
            agent: string;
            provider: string;
            model: string;
            projectPath: string;
            createdAt: number;
            lastActiveAt: number | null;
            lastViewedAt?: number | null;
            pinnedAt?: number | null;
            totalInputTokens: number | null;
            totalOutputTokens: number | null;
            totalCachedTokens?: number | null;
            totalCacheCreationTokens?: number | null;
            totalReasoningTokens?: number | null;
            totalToolTimeMs: number | null;
            currentContextTokens?: number | null;
            ownCostUsd?: number;
            subagentCostUsd?: number;
            totalCostUsd?: number;
            contextSummary?: string | null;
            lastCompactedAt?: number | null;
            parentSessionId?: string | null;
            branchPointMessageId?: string | null;
            sessionType?: 'main' | 'branch' | 'handoff' | 'btw' | 'looper' | 'subagent';
            toolCounts?: {
                [key: string]: number;
            };
            isRunning?: boolean;
            needsAttention?: boolean;
            fileStats?: {
                changedFiles: number;
                additions: number;
                deletions: number;
                operations: number;
            };
            [key: string]: unknown | string | string | null | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | string | null | number | null | string | null | string | null | 'main' | 'branch' | 'handoff' | 'btw' | 'looper' | 'subagent' | {
                [key: string]: number;
            } | boolean | {
                changedFiles: number;
                additions: number;
                deletions: number;
                operations: number;
            } | undefined;
        }>;
        hasMore: boolean;
        nextOffset: number | null;
    };
};
export type ListSessionsResponse = ListSessionsResponses[keyof ListSessionsResponses];
export type CreateSessionData = {
    body?: {
        title?: string | null;
        /**
         * Agent name. Defaults to config. Agent provider/model overrides are used when provider/model are omitted.
         */
        agent?: string;
        /**
         * Provider override. If omitted, selected agent provider override, then config default are used.
         */
        provider?: string;
        /**
         * Model override. If omitted, selected agent model override, then config default are used.
         */
        model?: string;
        /**
         * Allow a model override that is not present in the configured model catalog.
         */
        allowUnknownModel?: boolean;
        parentSessionId?: string | null;
        sessionType?: 'main' | 'btw' | 'looper';
    };
    path?: never;
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions';
};
export type CreateSessionErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type CreateSessionError = CreateSessionErrors[keyof CreateSessionErrors];
export type CreateSessionResponses = {
    /**
     * Created
     */
    201: {
        id: string;
        title: string | null;
        agent: string;
        provider: string;
        model: string;
        projectPath: string;
        createdAt: number;
        lastActiveAt: number | null;
        lastViewedAt?: number | null;
        pinnedAt?: number | null;
        totalInputTokens: number | null;
        totalOutputTokens: number | null;
        totalCachedTokens?: number | null;
        totalCacheCreationTokens?: number | null;
        totalReasoningTokens?: number | null;
        totalToolTimeMs: number | null;
        currentContextTokens?: number | null;
        ownCostUsd?: number;
        subagentCostUsd?: number;
        totalCostUsd?: number;
        contextSummary?: string | null;
        lastCompactedAt?: number | null;
        parentSessionId?: string | null;
        branchPointMessageId?: string | null;
        sessionType?: 'main' | 'branch' | 'handoff' | 'btw' | 'looper' | 'subagent';
        toolCounts?: {
            [key: string]: number;
        };
        isRunning?: boolean;
        needsAttention?: boolean;
        fileStats?: {
            changedFiles: number;
            additions: number;
            deletions: number;
            operations: number;
        };
        [key: string]: unknown | string | string | null | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | string | null | number | null | string | null | string | null | 'main' | 'branch' | 'handoff' | 'btw' | 'looper' | 'subagent' | {
            [key: string]: number;
        } | boolean | {
            changedFiles: number;
            additions: number;
            deletions: number;
            operations: number;
        } | undefined;
    };
};
export type CreateSessionResponse = CreateSessionResponses[keyof CreateSessionResponses];
export type DeleteSessionData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{sessionId}';
};
export type DeleteSessionErrors = {
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
};
export type DeleteSessionError = DeleteSessionErrors[keyof DeleteSessionErrors];
export type DeleteSessionResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
    };
};
export type DeleteSessionResponse = DeleteSessionResponses[keyof DeleteSessionResponses];
export type GetSessionData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{sessionId}';
};
export type GetSessionErrors = {
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
};
export type GetSessionError = GetSessionErrors[keyof GetSessionErrors];
export type GetSessionResponses = {
    /**
     * OK
     */
    200: {
        id: string;
        title: string | null;
        agent: string;
        provider: string;
        model: string;
        projectPath: string;
        createdAt: number;
        lastActiveAt: number | null;
        lastViewedAt?: number | null;
        pinnedAt?: number | null;
        totalInputTokens: number | null;
        totalOutputTokens: number | null;
        totalCachedTokens?: number | null;
        totalCacheCreationTokens?: number | null;
        totalReasoningTokens?: number | null;
        totalToolTimeMs: number | null;
        currentContextTokens?: number | null;
        ownCostUsd?: number;
        subagentCostUsd?: number;
        totalCostUsd?: number;
        contextSummary?: string | null;
        lastCompactedAt?: number | null;
        parentSessionId?: string | null;
        branchPointMessageId?: string | null;
        sessionType?: 'main' | 'branch' | 'handoff' | 'btw' | 'looper' | 'subagent';
        toolCounts?: {
            [key: string]: number;
        };
        isRunning?: boolean;
        needsAttention?: boolean;
        fileStats?: {
            changedFiles: number;
            additions: number;
            deletions: number;
            operations: number;
        };
        [key: string]: unknown | string | string | null | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | string | null | number | null | string | null | string | null | 'main' | 'branch' | 'handoff' | 'btw' | 'looper' | 'subagent' | {
            [key: string]: number;
        } | boolean | {
            changedFiles: number;
            additions: number;
            deletions: number;
            operations: number;
        } | undefined;
    };
};
export type GetSessionResponse = GetSessionResponses[keyof GetSessionResponses];
export type UpdateSessionData = {
    body: {
        title?: string;
        agent?: string;
        provider?: string;
        model?: string;
        allowUnknownModel?: boolean;
        isPinned?: boolean;
    };
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{sessionId}';
};
export type UpdateSessionErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
};
export type UpdateSessionError = UpdateSessionErrors[keyof UpdateSessionErrors];
export type UpdateSessionResponses = {
    /**
     * OK
     */
    200: {
        id: string;
        title: string | null;
        agent: string;
        provider: string;
        model: string;
        projectPath: string;
        createdAt: number;
        lastActiveAt: number | null;
        lastViewedAt?: number | null;
        pinnedAt?: number | null;
        totalInputTokens: number | null;
        totalOutputTokens: number | null;
        totalCachedTokens?: number | null;
        totalCacheCreationTokens?: number | null;
        totalReasoningTokens?: number | null;
        totalToolTimeMs: number | null;
        currentContextTokens?: number | null;
        ownCostUsd?: number;
        subagentCostUsd?: number;
        totalCostUsd?: number;
        contextSummary?: string | null;
        lastCompactedAt?: number | null;
        parentSessionId?: string | null;
        branchPointMessageId?: string | null;
        sessionType?: 'main' | 'branch' | 'handoff' | 'btw' | 'looper' | 'subagent';
        toolCounts?: {
            [key: string]: number;
        };
        isRunning?: boolean;
        needsAttention?: boolean;
        fileStats?: {
            changedFiles: number;
            additions: number;
            deletions: number;
            operations: number;
        };
        [key: string]: unknown | string | string | null | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | string | null | number | null | string | null | string | null | 'main' | 'branch' | 'handoff' | 'btw' | 'looper' | 'subagent' | {
            [key: string]: number;
        } | boolean | {
            changedFiles: number;
            additions: number;
            deletions: number;
            operations: number;
        } | undefined;
    };
};
export type UpdateSessionResponse = UpdateSessionResponses[keyof UpdateSessionResponses];
export type MarkSessionViewedData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{sessionId}/viewed';
};
export type MarkSessionViewedErrors = {
    /**
     * Not Found
     */
    404: unknown;
};
export type MarkSessionViewedResponses = {
    /**
     * OK
     */
    200: {
        id: string;
        title: string | null;
        agent: string;
        provider: string;
        model: string;
        projectPath: string;
        createdAt: number;
        lastActiveAt: number | null;
        lastViewedAt?: number | null;
        pinnedAt?: number | null;
        totalInputTokens: number | null;
        totalOutputTokens: number | null;
        totalCachedTokens?: number | null;
        totalCacheCreationTokens?: number | null;
        totalReasoningTokens?: number | null;
        totalToolTimeMs: number | null;
        currentContextTokens?: number | null;
        ownCostUsd?: number;
        subagentCostUsd?: number;
        totalCostUsd?: number;
        contextSummary?: string | null;
        lastCompactedAt?: number | null;
        parentSessionId?: string | null;
        branchPointMessageId?: string | null;
        sessionType?: 'main' | 'branch' | 'handoff' | 'btw' | 'looper' | 'subagent';
        toolCounts?: {
            [key: string]: number;
        };
        isRunning?: boolean;
        needsAttention?: boolean;
        fileStats?: {
            changedFiles: number;
            additions: number;
            deletions: number;
            operations: number;
        };
        [key: string]: unknown | string | string | null | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | string | null | number | null | string | null | string | null | 'main' | 'branch' | 'handoff' | 'btw' | 'looper' | 'subagent' | {
            [key: string]: number;
        } | boolean | {
            changedFiles: number;
            additions: number;
            deletions: number;
            operations: number;
        } | undefined;
    };
};
export type MarkSessionViewedResponse = MarkSessionViewedResponses[keyof MarkSessionViewedResponses];
export type AbortSessionData = {
    body?: {
        messageId?: string;
        clearQueue?: boolean;
    };
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{sessionId}/abort';
};
export type AbortSessionResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        wasRunning?: boolean;
        messageId?: string;
    };
};
export type AbortSessionResponse = AbortSessionResponses[keyof AbortSessionResponses];
export type GetSessionQueueData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{sessionId}/queue';
};
export type GetSessionQueueResponses = {
    /**
     * OK
     */
    200: {
        currentMessageId: string | null;
        queuedMessages: Array<{
            assistantMessageId: string;
            agent: string;
            provider: string;
            model: string;
        }>;
        isRunning: boolean;
    };
};
export type GetSessionQueueResponse = GetSessionQueueResponses[keyof GetSessionQueueResponses];
export type SendQueuedMessageNowData = {
    body?: never;
    path: {
        sessionId: string;
        messageId: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{sessionId}/queue/{messageId}/send-now';
};
export type SendQueuedMessageNowErrors = {
    /**
     * Queued message not found
     */
    404: {
        success: boolean;
        promoted: boolean;
        wasQueued?: boolean;
        wasRunning?: boolean;
        preemptedMessageId?: string | null;
    };
};
export type SendQueuedMessageNowError = SendQueuedMessageNowErrors[keyof SendQueuedMessageNowErrors];
export type SendQueuedMessageNowResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        promoted: boolean;
        wasQueued?: boolean;
        wasRunning?: boolean;
        preemptedMessageId?: string | null;
    };
};
export type SendQueuedMessageNowResponse = SendQueuedMessageNowResponses[keyof SendQueuedMessageNowResponses];
export type RemoveFromQueueData = {
    body?: never;
    path: {
        sessionId: string;
        messageId: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{sessionId}/queue/{messageId}';
};
export type RemoveFromQueueErrors = {
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
};
export type RemoveFromQueueError = RemoveFromQueueErrors[keyof RemoveFromQueueErrors];
export type RemoveFromQueueResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        removed?: boolean;
        wasQueued?: boolean;
        wasRunning?: boolean;
        wasStored?: boolean;
    };
};
export type RemoveFromQueueResponse = RemoveFromQueueResponses[keyof RemoveFromQueueResponses];
export type DeleteShareData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/share';
};
export type DeleteShareErrors = {
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
};
export type DeleteShareError = DeleteShareErrors[keyof DeleteShareErrors];
export type DeleteShareResponses = {
    /**
     * OK
     */
    200: {
        deleted: boolean;
        sessionId: string;
    };
};
export type DeleteShareResponse = DeleteShareResponses[keyof DeleteShareResponses];
export type GetShareStatusData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/share';
};
export type GetShareStatusResponses = {
    /**
     * OK
     */
    200: {
        shared: boolean;
        shareId?: string;
        url?: string;
        title?: string | null;
        createdAt?: number;
        lastSyncedAt?: number;
        lastSyncedMessageId?: string;
        syncedMessages?: number;
        totalMessages?: number;
        pendingMessages?: number;
        isSynced?: boolean;
    };
};
export type GetShareStatusResponse = GetShareStatusResponses[keyof GetShareStatusResponses];
export type ShareSessionData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/share';
};
export type ShareSessionErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
};
export type ShareSessionError = ShareSessionErrors[keyof ShareSessionErrors];
export type ShareSessionResponses = {
    /**
     * OK
     */
    200: {
        shared: boolean;
        shareId?: string;
        url?: string;
        message?: string;
    };
};
export type ShareSessionResponse = ShareSessionResponses[keyof ShareSessionResponses];
export type SyncShareData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/share';
};
export type SyncShareErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type SyncShareError = SyncShareErrors[keyof SyncShareErrors];
export type SyncShareResponses = {
    /**
     * OK
     */
    200: {
        synced: boolean;
        url?: string;
        newMessages?: number;
        message?: string;
    };
};
export type SyncShareResponse = SyncShareResponses[keyof SyncShareResponses];
export type ListSharesData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/shares';
};
export type ListSharesResponses = {
    /**
     * OK
     */
    200: {
        shares: Array<{
            sessionId: string;
            shareId: string;
            url: string;
            title?: string | null;
            createdAt: number;
            lastSyncedAt: number;
        }>;
    };
};
export type ListSharesResponse = ListSharesResponses[keyof ListSharesResponses];
export type CreateSessionHandoffData = {
    body?: never;
    path: {
        /**
         * Source session ID
         */
        sessionId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/handoff';
};
export type CreateSessionHandoffErrors = {
    /**
     * Session not found
     */
    404: {
        error: string;
    };
};
export type CreateSessionHandoffError = CreateSessionHandoffErrors[keyof CreateSessionHandoffErrors];
export type CreateSessionHandoffResponses = {
    /**
     * Created
     */
    201: {
        session: {
            id: string;
            title: string | null;
            agent: string;
            provider: string;
            model: string;
            projectPath: string;
            createdAt: number;
            lastActiveAt: number | null;
            lastViewedAt?: number | null;
            totalInputTokens: number | null;
            totalOutputTokens: number | null;
            totalCachedTokens?: number | null;
            totalCacheCreationTokens?: number | null;
            totalToolTimeMs: number | null;
            currentContextTokens?: number | null;
            toolCounts?: {
                [key: string]: number;
            };
            parentSessionId?: string | null;
            branchPointMessageId?: string | null;
            sessionType?: 'main' | 'branch' | 'handoff';
            [key: string]: unknown | string | string | null | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | {
                [key: string]: number;
            } | string | null | string | null | 'main' | 'branch' | 'handoff' | undefined;
        };
        sessionId: string;
        sourceSessionId: string;
        message: string;
    };
};
export type CreateSessionHandoffResponse = CreateSessionHandoffResponses[keyof CreateSessionHandoffResponses];
export type RetryMessageData = {
    body?: never;
    path: {
        sessionId: string;
        messageId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/messages/{messageId}/retry';
};
export type RetryMessageErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
    /**
     * Not Found
     */
    404: {
        error: string;
    };
};
export type RetryMessageError = RetryMessageErrors[keyof RetryMessageErrors];
export type RetryMessageResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        messageId: string;
    };
};
export type RetryMessageResponse = RetryMessageResponses[keyof RetryMessageResponses];
export type ResolveApprovalData = {
    body: {
        callId: string;
        approved: boolean;
    };
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/sessions/{id}/approval';
};
export type ResolveApprovalErrors = {
    /**
     * Bad Request
     */
    400: {
        ok?: false;
        error: string;
    };
    /**
     * Forbidden
     */
    403: {
        ok?: false;
        error: string;
    };
    /**
     * Not Found
     */
    404: {
        ok?: false;
        error: string;
    };
};
export type ResolveApprovalError = ResolveApprovalErrors[keyof ResolveApprovalErrors];
export type ResolveApprovalResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        callId: string;
        approved: boolean;
    };
};
export type ResolveApprovalResponse = ResolveApprovalResponses[keyof ResolveApprovalResponses];
export type GetPendingApprovalsData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/sessions/{id}/approval/pending';
};
export type GetPendingApprovalsResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        pending: Array<{
            callId: string;
            toolName: string;
            args?: {
                [key: string]: unknown;
            };
            messageId?: string;
            createdAt: number;
        }>;
    };
};
export type GetPendingApprovalsResponse = GetPendingApprovalsResponses[keyof GetPendingApprovalsResponses];
export type ResolveSecureInputData = {
    body: {
        promptId: string;
        value?: string;
        cancelled?: boolean;
        remember?: boolean;
    };
    path: {
        /**
         * Session ID
         */
        id: string;
    };
    query?: never;
    url: '/v1/sessions/{id}/secure-input';
};
export type ResolveSecureInputErrors = {
    /**
     * Bad Request
     */
    400: {
        ok: false;
        error: string;
    };
    /**
     * Secure input does not belong to the session
     */
    403: {
        ok: false;
        error: string;
    };
    /**
     * Pending secure input not found
     */
    404: {
        ok: false;
        error: string;
    };
};
export type ResolveSecureInputError = ResolveSecureInputErrors[keyof ResolveSecureInputErrors];
export type ResolveSecureInputResponses = {
    /**
     * Secure input resolved
     */
    200: {
        ok: true;
        promptId: string;
        cancelled: boolean;
    };
};
export type ResolveSecureInputResponse = ResolveSecureInputResponses[keyof ResolveSecureInputResponses];
export type ListPendingSecureInputsData = {
    body?: never;
    path: {
        /**
         * Session ID
         */
        id: string;
    };
    query?: never;
    url: '/v1/sessions/{id}/secure-input/pending';
};
export type ListPendingSecureInputsResponses = {
    /**
     * Pending secure input prompts
     */
    200: {
        ok: true;
        pending: Array<{
            promptId: string;
            messageId: string;
            callId?: string;
            prompt: string;
            inputKind: 'password' | 'text';
            allowRemember: boolean;
            allowEmpty: boolean;
            createdAt: number;
        }>;
    };
};
export type ListPendingSecureInputsResponse = ListPendingSecureInputsResponses[keyof ListPendingSecureInputsResponses];
export type ListMessagesData = {
    body?: never;
    path: {
        id: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
        /**
         * Exclude parts from the response. By default, parts are included.
         */
        without?: 'parts';
        parsed?: string;
    };
    url: '/v1/sessions/{id}/messages';
};
export type ListMessagesResponses = {
    /**
     * OK
     */
    200: Array<{
        id: string;
        sessionId: string;
        role: string;
        status: string;
        agent: string;
        provider: string;
        model: string;
        createdAt: number;
        completedAt?: number | null;
        latencyMs?: number | null;
        inputTokens?: number | null;
        outputTokens?: number | null;
        totalTokens?: number | null;
        cachedInputTokens?: number | null;
        cacheCreationInputTokens?: number | null;
        reasoningTokens?: number | null;
        finishReason?: string | null;
        rawFinishReason?: string | null;
        finishDetails?: string | null;
        error?: string | null;
        errorType?: string | null;
        errorDetails?: string | null;
        isAborted?: boolean | null;
        parts?: Array<{
            id: string;
            messageId: string;
            index: number;
            stepIndex?: number | null;
            type: string;
            content: string | {
                [key: string]: unknown;
            };
            contentJson?: unknown;
            agent: string;
            provider: string;
            model: string;
            startedAt?: number | null;
            completedAt?: number | null;
            compactedAt?: number | null;
            toolName?: string | null;
            toolCallId?: string | null;
            toolDurationMs?: number | null;
            [key: string]: unknown | string | number | number | null | string | {
                [key: string]: unknown;
            } | number | null | number | null | number | null | string | null | string | null | number | null | undefined;
        }>;
        [key: string]: unknown | string | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | string | null | string | null | string | null | string | null | string | null | string | null | boolean | null | Array<{
            id: string;
            messageId: string;
            index: number;
            stepIndex?: number | null;
            type: string;
            content: string | {
                [key: string]: unknown;
            };
            contentJson?: unknown;
            agent: string;
            provider: string;
            model: string;
            startedAt?: number | null;
            completedAt?: number | null;
            compactedAt?: number | null;
            toolName?: string | null;
            toolCallId?: string | null;
            toolDurationMs?: number | null;
            [key: string]: unknown | string | number | number | null | string | {
                [key: string]: unknown;
            } | number | null | number | null | number | null | string | null | string | null | number | null | undefined;
        }> | undefined;
    }>;
};
export type ListMessagesResponse = ListMessagesResponses[keyof ListMessagesResponses];
export type CreateMessageData = {
    body: {
        content: string;
        /**
         * Agent name. Defaults to the session agent, then config default. When explicitly changed and provider/model are omitted, the selected agent provider/model overrides are used before the session/default provider/model.
         */
        agent?: string;
        /**
         * Provider override for this message. If omitted, explicit agent provider override, session provider, then config default are used.
         */
        provider?: string;
        /**
         * Model override for this message. If omitted, explicit agent model override, session model, then config default are used.
         */
        model?: string;
        /**
         * Allow a model id that is not present in the configured model catalog.
         */
        allowUnknownModel?: boolean;
        /**
         * Optional user-provided context to include in the system prompt.
         */
        userContext?: string | null;
        /**
         * Enable extended thinking / reasoning for models that support it.
         */
        reasoningText?: boolean;
        /**
         * Reasoning intensity level for providers/models that support it.
         */
        reasoningLevel?: 'minimal' | 'low' | 'medium' | 'high' | 'max' | 'xhigh';
        images?: Array<unknown>;
        files?: Array<unknown>;
        /**
         * File references to preload as synthetic read tool calls immediately before the assistant runs.
         */
        context?: {
            files: Array<{
                path: string;
                startLine?: number;
                endLine?: number;
                maxLines?: number;
            }>;
        };
        oneShot?: boolean;
    };
    path: {
        id: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{id}/messages';
};
export type CreateMessageErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
    /**
     * Message or attachments exceed size limits
     */
    413: {
        error: string;
    };
};
export type CreateMessageError = CreateMessageErrors[keyof CreateMessageErrors];
export type CreateMessageResponses = {
    /**
     * Plugin command started in a visible terminal
     */
    200: {
        messageId?: string;
        pluginCommand?: {
            command: string;
            terminalId: string;
            title: string;
            previewUrl?: string;
            execution: 'started';
        };
    };
    /**
     * Accepted
     */
    202: {
        messageId?: string;
        pluginCommand?: {
            command: string;
            terminalId: string;
            title: string;
            previewUrl?: string;
            execution: 'started';
        };
    };
};
export type CreateMessageResponse = CreateMessageResponses[keyof CreateMessageResponses];
export type ListMessagePageData = {
    body?: never;
    path: {
        id: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
        /**
         * Exclude parts from the response. By default, parts are included.
         */
        without?: 'parts';
        parsed?: string;
        /**
         * Soft message-part target. Pages always contain complete turns and include at least two turns when available.
         */
        limit?: number;
        /**
         * Opaque cursor returned by the previous page.
         */
        cursor?: string;
    };
    url: '/v1/sessions/{id}/messages/page';
};
export type ListMessagePageErrors = {
    /**
     * Invalid cursor
     */
    400: {
        error: string;
    };
};
export type ListMessagePageError = ListMessagePageErrors[keyof ListMessagePageErrors];
export type ListMessagePageResponses = {
    /**
     * A chronological page sized by a soft part target and complete turn boundaries
     */
    200: {
        items: Array<{
            id: string;
            sessionId: string;
            role: string;
            status: string;
            agent: string;
            provider: string;
            model: string;
            createdAt: number;
            completedAt?: number | null;
            latencyMs?: number | null;
            inputTokens?: number | null;
            outputTokens?: number | null;
            totalTokens?: number | null;
            cachedInputTokens?: number | null;
            cacheCreationInputTokens?: number | null;
            reasoningTokens?: number | null;
            finishReason?: string | null;
            rawFinishReason?: string | null;
            finishDetails?: string | null;
            error?: string | null;
            errorType?: string | null;
            errorDetails?: string | null;
            isAborted?: boolean | null;
            parts?: Array<{
                id: string;
                messageId: string;
                index: number;
                stepIndex?: number | null;
                type: string;
                content: string | {
                    [key: string]: unknown;
                };
                contentJson?: unknown;
                agent: string;
                provider: string;
                model: string;
                startedAt?: number | null;
                completedAt?: number | null;
                compactedAt?: number | null;
                toolName?: string | null;
                toolCallId?: string | null;
                toolDurationMs?: number | null;
                [key: string]: unknown | string | number | number | null | string | {
                    [key: string]: unknown;
                } | number | null | number | null | number | null | string | null | string | null | number | null | undefined;
            }>;
            [key: string]: unknown | string | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | string | null | string | null | string | null | string | null | string | null | string | null | boolean | null | Array<{
                id: string;
                messageId: string;
                index: number;
                stepIndex?: number | null;
                type: string;
                content: string | {
                    [key: string]: unknown;
                };
                contentJson?: unknown;
                agent: string;
                provider: string;
                model: string;
                startedAt?: number | null;
                completedAt?: number | null;
                compactedAt?: number | null;
                toolName?: string | null;
                toolCallId?: string | null;
                toolDurationMs?: number | null;
                [key: string]: unknown | string | number | number | null | string | {
                    [key: string]: unknown;
                } | number | null | number | null | number | null | string | null | string | null | number | null | undefined;
            }> | undefined;
        }>;
        partCount: number;
        hasMore: boolean;
        nextCursor: string | null;
    };
};
export type ListMessagePageResponse = ListMessagePageResponses[keyof ListMessagePageResponses];
export type GetMessagePartContentData = {
    body?: never;
    path: {
        id: string;
        partId: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{id}/parts/{partId}/content';
};
export type GetMessagePartContentErrors = {
    /**
     * Message part not found
     */
    404: {
        error: string;
    };
};
export type GetMessagePartContentError = GetMessagePartContentErrors[keyof GetMessagePartContentErrors];
export type GetMessagePartContentResponses = {
    /**
     * Complete persisted part content
     */
    200: string;
};
export type GetMessagePartContentResponse = GetMessagePartContentResponses[keyof GetMessagePartContentResponses];
export type GetToolResultArtifactData = {
    body?: never;
    path: {
        id: string;
        callId: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{id}/tool-results/{callId}/artifact';
};
export type GetToolResultArtifactErrors = {
    /**
     * Browser screenshot not found
     */
    404: {
        error: string;
    };
};
export type GetToolResultArtifactError = GetToolResultArtifactErrors[keyof GetToolResultArtifactErrors];
export type GetToolResultArtifactResponses = {
    /**
     * Raw browser screenshot bytes
     */
    200: Blob | File;
};
export type GetToolResultArtifactResponse = GetToolResultArtifactResponses[keyof GetToolResultArtifactResponses];
export type SubscribeSessionStreamData = {
    body?: never;
    path: {
        id: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{id}/stream';
};
export type SubscribeSessionStreamResponses = {
    /**
     * SSE event stream. Events include session.created, message.created, message.part.delta, tool.call, tool.delta, tool.result, message.completed, error.
     */
    200: string;
};
export type SubscribeSessionStreamResponse = SubscribeSessionStreamResponses[keyof SubscribeSessionStreamResponses];
export type SubscribeSessionStreamPostData = {
    body?: never;
    path: {
        id: string;
    };
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/sessions/{id}/stream';
};
export type SubscribeSessionStreamPostResponses = {
    /**
     * SSE event stream. Events include session.created, message.created, message.part.delta, tool.call, tool.delta, tool.result, message.completed, error.
     */
    200: string;
};
export type SubscribeSessionStreamPostResponse = SubscribeSessionStreamPostResponses[keyof SubscribeSessionStreamPostResponses];
export type SubscribeClientEventsStreamData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/events/stream';
};
export type SubscribeClientEventsStreamResponses = {
    /**
     * SSE event stream. Events include notification, session.status, reference.preparation, and heartbeat.
     */
    200: string;
};
export type SubscribeClientEventsStreamResponse = SubscribeClientEventsStreamResponses[keyof SubscribeClientEventsStreamResponses];
export type SubscribeClientEventsStreamPostData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/events/stream';
};
export type SubscribeClientEventsStreamPostResponses = {
    /**
     * SSE event stream. Events include notification, session.status, reference.preparation, and heartbeat.
     */
    200: string;
};
export type SubscribeClientEventsStreamPostResponse = SubscribeClientEventsStreamPostResponses[keyof SubscribeClientEventsStreamPostResponses];
export type SubscribeProjectEventsStreamData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
        /**
         * Comma-separated session ids to include. Omit for all sessions; pass an empty value for client events only.
         */
        sessions?: string;
    };
    url: '/v1/events/project';
};
export type SubscribeProjectEventsStreamResponses = {
    /**
     * Multiplexed SSE stream carrying all session events for the project plus client events such as notifications, session status, and reference preparation over ONE connection. Session events have `data: {"sessionId": ..., "payload": {...}}`; client events have `data: {"payload": {...}}`.
     */
    200: string;
};
export type SubscribeProjectEventsStreamResponse = SubscribeProjectEventsStreamResponses[keyof SubscribeProjectEventsStreamResponses];
export type SubscribeProjectEventsStreamPostData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
        /**
         * Comma-separated session ids to include. Omit for all sessions; pass an empty value for client events only.
         */
        sessions?: string;
    };
    url: '/v1/events/project';
};
export type SubscribeProjectEventsStreamPostResponses = {
    /**
     * Multiplexed SSE stream carrying all session events for the project plus client events such as notifications, session status, and reference preparation over ONE connection. Session events have `data: {"sessionId": ..., "payload": {...}}`; client events have `data: {"payload": {...}}`.
     */
    200: string;
};
export type SubscribeProjectEventsStreamPostResponse = SubscribeProjectEventsStreamPostResponses[keyof SubscribeProjectEventsStreamPostResponses];
export type SubscribeDesktopEventsStreamData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/events/desktop';
};
export type SubscribeDesktopEventsStreamErrors = {
    /**
     * Unauthorized
     */
    401: unknown;
};
export type SubscribeDesktopEventsStreamResponses = {
    /**
     * Daemon-wide SSE stream used by the native desktop broker. Every event includes project routing metadata when available.
     */
    200: string;
};
export type SubscribeDesktopEventsStreamResponse = SubscribeDesktopEventsStreamResponses[keyof SubscribeDesktopEventsStreamResponses];
export type AskData = {
    body: {
        /**
         * User prompt to send to the assistant.
         */
        prompt: string;
        /**
         * Optional agent name to use for this request.
         */
        agent?: string;
        /**
         * Optional provider override. When omitted the agent and config defaults apply.
         */
        provider?: string;
        /**
         * Optional model override for the selected provider.
         */
        model?: string;
        /**
         * Allow an explicit model id that is not present in the configured model catalog.
         */
        allowUnknownModel?: boolean;
        /**
         * Enable extended thinking / reasoning for models that support it.
         */
        reasoningText?: boolean;
        /**
         * Optional reasoning intensity override for supported providers/models.
         */
        reasoningLevel?: 'minimal' | 'low' | 'medium' | 'high' | 'max' | 'xhigh';
        /**
         * Send the prompt to a specific session.
         */
        sessionId?: string;
        /**
         * If true, reuse the most recent session for the project.
         */
        last?: boolean;
        /**
         * Request structured JSON output when supported by the agent.
         */
        jsonMode?: boolean;
        /**
         * Inline agent prompt for this request.
         */
        agentPrompt?: string;
        /**
         * Inline agent tool configuration split into first-class and loadable tools.
         */
        tools?: {
            firstClass?: Array<string>;
            loadable?: Array<string>;
        };
        skipFileConfig?: boolean;
        config?: {
            [key: string]: unknown;
        };
        credentials?: {
            [key: string]: unknown;
        };
    };
    path?: never;
    query?: {
        /**
         * Absolute project path. Kept for backwards compatibility.
         */
        project?: string;
        /**
         * Stable otto project id returned by project routes.
         */
        projectId?: string;
    };
    url: '/v1/ask';
};
export type AskErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type AskError = AskErrors[keyof AskErrors];
export type AskResponses = {
    /**
     * Accepted
     */
    202: {
        sessionId: string;
        header: {
            sessionId: string;
            agent?: string | null;
            provider?: string | null;
            model?: string | null;
        };
        provider: string;
        model: string;
        agent: string;
        assistantMessageId: string;
        message?: {
            kind: 'created' | 'last';
            sessionId: string;
        } | null;
    };
};
export type AskResponse = AskResponses[keyof AskResponses];
export type GetCwdData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/config/cwd';
};
export type GetCwdResponses = {
    /**
     * OK
     */
    200: {
        cwd: string;
        dirName: string;
    };
};
export type GetCwdResponse = GetCwdResponses[keyof GetCwdResponses];
export type GetConfigData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config';
};
export type GetConfigResponses = {
    /**
     * OK
     */
    200: {
        agents: Array<string>;
        providers: Array<string>;
        providerDetails: Array<{
            id: string;
            label: string;
            source: 'built-in' | 'custom';
            enabled: boolean;
            authorized: boolean;
            custom?: boolean;
            compatibility?: string | null;
            family?: string | null;
            baseURL?: string | null;
            apiKeyEnv?: string | null;
            hasApiKey?: boolean;
            allowAnyModel?: boolean;
            modelCount?: number;
            authType?: string | null;
        }>;
        defaults: {
            agent: string;
            provider: string;
            model: string;
            toolApproval?: 'auto' | 'dangerous' | 'all' | 'yolo';
            guidedMode?: boolean;
            reasoningText?: boolean;
            reasoningLevel?: 'minimal' | 'low' | 'medium' | 'high' | 'max' | 'xhigh';
            theme?: 'otto-dark' | 'otto-light' | 'rose-pine' | 'rose-pine-moon' | 'rose-pine-dawn' | 'ayu-dark' | 'ayu-mirage' | 'ayu-light' | 'tokyo-night' | 'catppuccin-mocha' | 'nord' | 'gruvbox' | 'monokai' | 'dracula' | 'solarized-dark';
            tuiTheme?: string;
            vimMode?: boolean;
            compactThread?: boolean;
            fontFamily?: string;
            smartEdges?: boolean;
            threadNavigatorRail?: boolean;
            releaseToSend?: boolean;
            fullWidthContent?: boolean;
            notificationsEnabled?: boolean;
            dictationKeywords?: Array<{
                keyword: string;
                aliases?: Array<string>;
            }>;
            dictationExcludedProjectKeywords?: Array<string>;
            dictationSmartFormatting?: boolean;
            autoCompactThresholdTokens?: number | null;
            coAuthorCommits?: boolean;
        };
    };
};
export type GetConfigResponse = GetConfigResponses[keyof GetConfigResponses];
export type GetAgentsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/agents';
};
export type GetAgentsResponses = {
    /**
     * OK
     */
    200: {
        agents: Array<string>;
        default: string;
    };
};
export type GetAgentsResponse = GetAgentsResponses[keyof GetAgentsResponses];
export type GetAgentDetailsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/agents/details';
};
export type GetAgentDetailsResponses = {
    /**
     * OK
     */
    200: {
        agents: Array<{
            name: string;
            builtin: boolean;
            custom: boolean;
            source: 'builtin' | 'local' | 'global' | 'merged' | 'plugin' | 'embedded';
            prompt: string;
            promptSource: string;
            description?: string;
            defaultDescription?: string;
            toolConfig: {
                firstClass?: Array<string>;
                loadable?: Array<string>;
            };
            defaultToolConfig: {
                firstClass?: Array<string>;
                loadable?: Array<string>;
            };
            appendToolConfig: {
                firstClass?: Array<string>;
                loadable?: Array<string>;
            };
            provider?: string;
            model?: string;
            editable: boolean;
            hasLocalOverride: boolean;
            hasGlobalOverride: boolean;
        }>;
        default: string;
    };
};
export type GetAgentDetailsResponse = GetAgentDetailsResponses[keyof GetAgentDetailsResponses];
export type DeleteAgentData = {
    body?: never;
    path: {
        /**
         * Agent name.
         */
        agent: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Configuration scope. Defaults to local.
         */
        scope?: 'local' | 'global';
    };
    url: '/v1/config/agents/{agent}';
};
export type DeleteAgentResponses = {
    /**
     * OK
     */
    200: {
        deleted: boolean;
        builtin: boolean;
        agent?: {
            name: string;
            builtin: boolean;
            custom: boolean;
            source: 'builtin' | 'local' | 'global' | 'merged' | 'plugin' | 'embedded';
            prompt: string;
            promptSource: string;
            description?: string;
            defaultDescription?: string;
            toolConfig: {
                firstClass?: Array<string>;
                loadable?: Array<string>;
            };
            defaultToolConfig: {
                firstClass?: Array<string>;
                loadable?: Array<string>;
            };
            appendToolConfig: {
                firstClass?: Array<string>;
                loadable?: Array<string>;
            };
            provider?: string;
            model?: string;
            editable: boolean;
            hasLocalOverride: boolean;
            hasGlobalOverride: boolean;
        };
    };
};
export type DeleteAgentResponse = DeleteAgentResponses[keyof DeleteAgentResponses];
export type GetAgentData = {
    body?: never;
    path: {
        /**
         * Agent name.
         */
        agent: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/agents/{agent}';
};
export type GetAgentResponses = {
    /**
     * OK
     */
    200: {
        agent: {
            name: string;
            builtin: boolean;
            custom: boolean;
            source: 'builtin' | 'local' | 'global' | 'merged' | 'plugin' | 'embedded';
            prompt: string;
            promptSource: string;
            description?: string;
            defaultDescription?: string;
            toolConfig: {
                firstClass?: Array<string>;
                loadable?: Array<string>;
            };
            defaultToolConfig: {
                firstClass?: Array<string>;
                loadable?: Array<string>;
            };
            appendToolConfig: {
                firstClass?: Array<string>;
                loadable?: Array<string>;
            };
            provider?: string;
            model?: string;
            editable: boolean;
            hasLocalOverride: boolean;
            hasGlobalOverride: boolean;
        };
    };
};
export type GetAgentResponse = GetAgentResponses[keyof GetAgentResponses];
export type UpsertAgentData = {
    body: {
        scope?: 'local' | 'global';
        prompt?: string;
        promptStorage?: 'file' | 'inline';
        description?: string | null;
        tools?: {
            firstClass?: Array<string>;
            loadable?: Array<string>;
        };
        appendTools?: {
            firstClass?: Array<string>;
            loadable?: Array<string>;
        };
        provider?: string | null;
        model?: string | null;
    };
    path: {
        /**
         * Agent name.
         */
        agent: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/agents/{agent}';
};
export type UpsertAgentResponses = {
    /**
     * OK
     */
    200: {
        agent: {
            name: string;
            builtin: boolean;
            custom: boolean;
            source: 'builtin' | 'local' | 'global' | 'merged' | 'plugin' | 'embedded';
            prompt: string;
            promptSource: string;
            description?: string;
            defaultDescription?: string;
            toolConfig: {
                firstClass?: Array<string>;
                loadable?: Array<string>;
            };
            defaultToolConfig: {
                firstClass?: Array<string>;
                loadable?: Array<string>;
            };
            appendToolConfig: {
                firstClass?: Array<string>;
                loadable?: Array<string>;
            };
            provider?: string;
            model?: string;
            editable: boolean;
            hasLocalOverride: boolean;
            hasGlobalOverride: boolean;
        };
    };
};
export type UpsertAgentResponse = UpsertAgentResponses[keyof UpsertAgentResponses];
export type GetConfigToolsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/tools';
};
export type GetConfigToolsResponses = {
    /**
     * OK
     */
    200: {
        tools: Array<{
            name: string;
            description?: string;
            category: 'first_class' | 'loadable' | 'core' | 'filesystem' | 'search' | 'editing' | 'shell' | 'git' | 'web' | 'mcp' | 'skill' | 'research' | 'orchestration' | 'custom' | 'other';
            source: 'builtin' | 'mcp' | 'skill' | 'custom';
            activation?: 'first_class' | 'loadable' | 'mcp';
            required?: boolean;
            risky?: boolean;
            available: boolean;
        }>;
    };
};
export type GetConfigToolsResponse = GetConfigToolsResponses[keyof GetConfigToolsResponses];
export type GetProvidersData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/providers';
};
export type GetProvidersResponses = {
    /**
     * OK
     */
    200: {
        providers: Array<string>;
        details: Array<{
            id: string;
            label: string;
            source: 'built-in' | 'custom';
            enabled: boolean;
            authorized: boolean;
            custom?: boolean;
            compatibility?: string | null;
            family?: string | null;
            baseURL?: string | null;
            apiKeyEnv?: string | null;
            hasApiKey?: boolean;
            allowAnyModel?: boolean;
            modelCount?: number;
            authType?: string | null;
        }>;
        default: string;
    };
};
export type GetProvidersResponse = GetProvidersResponses[keyof GetProvidersResponses];
export type DiscoverProviderModelsData = {
    body: {
        /**
         * Provider compatibility mode. Model discovery currently supports ollama.
         */
        compatibility?: string;
        /**
         * Provider base URL to inspect.
         */
        baseURL: string;
        /**
         * Optional API key for the provider.
         */
        apiKey?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/config/providers/discover-models';
};
export type DiscoverProviderModelsErrors = {
    /**
     * Invalid discovery request
     */
    400: {
        error?: string;
    };
};
export type DiscoverProviderModelsError = DiscoverProviderModelsErrors[keyof DiscoverProviderModelsErrors];
export type DiscoverProviderModelsResponses = {
    /**
     * Discovered provider models
     */
    200: {
        baseURL?: string;
        models: Array<{
            id: string;
            label: string;
            toolCall?: boolean;
            reasoningText?: boolean;
            vision?: boolean;
            attachment?: boolean;
            contextWindow?: number;
            maxOutputTokens?: number;
        }>;
        unsupported?: boolean;
        message?: string;
    };
};
export type DiscoverProviderModelsResponse = DiscoverProviderModelsResponses[keyof DiscoverProviderModelsResponses];
export type DeleteProviderSettingsData = {
    body?: never;
    path: {
        provider: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/providers/{provider}';
};
export type DeleteProviderSettingsResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        provider: string;
        details: Array<{
            id: string;
            label: string;
            source: 'built-in' | 'custom';
            enabled: boolean;
            authorized: boolean;
            custom?: boolean;
            compatibility?: string | null;
            family?: string | null;
            baseURL?: string | null;
            apiKeyEnv?: string | null;
            hasApiKey?: boolean;
            allowAnyModel?: boolean;
            modelCount?: number;
            authType?: string | null;
        }>;
    };
};
export type DeleteProviderSettingsResponse = DeleteProviderSettingsResponses[keyof DeleteProviderSettingsResponses];
export type UpdateProviderSettingsData = {
    body: {
        enabled?: boolean;
        custom?: boolean;
        label?: string;
        compatibility?: string;
        family?: string;
        baseURL?: string | null;
        apiKey?: string | null;
        apiKeyEnv?: string | null;
        models?: {
            [key: string]: {
                id?: string;
                ownedBy?: 'openai' | 'anthropic' | 'google' | 'meta' | 'openrouter' | 'xai' | 'kimi' | 'qwen' | 'zai' | 'deepseek' | 'minimax';
                label?: string;
                toolCall?: boolean;
                reasoningText?: boolean;
                attachment?: boolean;
                temperature?: boolean | number;
                limit?: {
                    context?: number;
                    output?: number;
                };
                provider?: {
                    id?: string;
                    npm?: string;
                    compatibility?: 'openai' | 'anthropic' | 'google' | 'openrouter' | 'ollama' | 'openai-compatible';
                    api?: string;
                    baseURL?: string;
                    family?: 'default' | 'anthropic' | 'openai' | 'google' | 'kimi' | 'minimax' | 'glm' | 'openai-compatible';
                };
            };
        };
        allowAnyModel?: boolean;
    };
    path: {
        provider: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/providers/{provider}';
};
export type UpdateProviderSettingsResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        provider: string;
        details: Array<{
            id: string;
            label: string;
            source: 'built-in' | 'custom';
            enabled: boolean;
            authorized: boolean;
            custom?: boolean;
            compatibility?: string | null;
            family?: string | null;
            baseURL?: string | null;
            apiKeyEnv?: string | null;
            hasApiKey?: boolean;
            allowAnyModel?: boolean;
            modelCount?: number;
            authType?: string | null;
        }>;
    };
};
export type UpdateProviderSettingsResponse = UpdateProviderSettingsResponses[keyof UpdateProviderSettingsResponses];
export type GetProviderModelsData = {
    body?: never;
    path: {
        provider: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/providers/{provider}/models';
};
export type GetProviderModelsErrors = {
    /**
     * Provider not authorized
     */
    403: {
        error: string;
    };
    /**
     * Provider not found
     */
    404: {
        error: string;
    };
};
export type GetProviderModelsError = GetProviderModelsErrors[keyof GetProviderModelsErrors];
export type GetProviderModelsResponses = {
    /**
     * OK
     */
    200: {
        models: Array<{
            id: string;
            label: string;
            toolCall?: boolean;
            reasoningText?: boolean;
            vision?: boolean;
            attachment?: boolean;
        }>;
        default?: string | null;
        allowAnyModel: boolean;
        label: string;
    };
};
export type GetProviderModelsResponse = GetProviderModelsResponses[keyof GetProviderModelsResponses];
export type GetAllModelsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/models';
};
export type GetAllModelsResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: {
            label: string;
            authType?: string;
            models: Array<{
                id: string;
                label: string;
                toolCall?: boolean;
                reasoningText?: boolean;
                vision?: boolean;
                attachment?: boolean;
            }>;
        };
    };
};
export type GetAllModelsResponse = GetAllModelsResponses[keyof GetAllModelsResponses];
export type UpdateDefaultsData = {
    body: {
        agent?: string;
        provider?: string;
        model?: string;
        toolApproval?: 'auto' | 'dangerous' | 'all' | 'yolo';
        guidedMode?: boolean;
        reasoningText?: boolean;
        reasoningLevel?: 'minimal' | 'low' | 'medium' | 'high' | 'max' | 'xhigh';
        theme?: 'otto-dark' | 'otto-light' | 'rose-pine' | 'rose-pine-moon' | 'rose-pine-dawn' | 'ayu-dark' | 'ayu-mirage' | 'ayu-light' | 'tokyo-night' | 'catppuccin-mocha' | 'nord' | 'gruvbox' | 'monokai' | 'dracula' | 'solarized-dark';
        tuiTheme?: string;
        vimMode?: boolean;
        compactThread?: boolean;
        fontFamily?: string;
        smartEdges?: boolean;
        threadNavigatorRail?: boolean;
        releaseToSend?: boolean;
        fullWidthContent?: boolean;
        notificationsEnabled?: boolean;
        dictationKeywords?: Array<{
            keyword: string;
            aliases?: Array<string>;
        }>;
        dictationExcludedProjectKeywords?: Array<string>;
        dictationSmartFormatting?: boolean;
        autoCompactThresholdTokens?: number | null;
        coAuthorCommits?: boolean;
        scope?: 'global' | 'local';
    };
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/defaults';
};
export type UpdateDefaultsResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        defaults: {
            agent: string;
            provider: string;
            model: string;
            toolApproval?: 'auto' | 'dangerous' | 'all' | 'yolo';
            guidedMode?: boolean;
            reasoningText?: boolean;
            reasoningLevel?: 'minimal' | 'low' | 'medium' | 'high' | 'max' | 'xhigh';
            theme?: 'otto-dark' | 'otto-light' | 'rose-pine' | 'rose-pine-moon' | 'rose-pine-dawn' | 'ayu-dark' | 'ayu-mirage' | 'ayu-light' | 'tokyo-night' | 'catppuccin-mocha' | 'nord' | 'gruvbox' | 'monokai' | 'dracula' | 'solarized-dark';
            tuiTheme?: string;
            vimMode?: boolean;
            compactThread?: boolean;
            fontFamily?: string;
            smartEdges?: boolean;
            threadNavigatorRail?: boolean;
            releaseToSend?: boolean;
            fullWidthContent?: boolean;
            notificationsEnabled?: boolean;
            dictationKeywords?: Array<{
                keyword: string;
                aliases?: Array<string>;
            }>;
            dictationExcludedProjectKeywords?: Array<string>;
            dictationSmartFormatting?: boolean;
            autoCompactThresholdTokens?: number | null;
            coAuthorCommits?: boolean;
        };
    };
};
export type UpdateDefaultsResponse = UpdateDefaultsResponses[keyof UpdateDefaultsResponses];
export type GetDebugConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/config/debug';
};
export type GetDebugConfigResponses = {
    /**
     * OK
     */
    200: {
        enabled: boolean;
        scopes: Array<string>;
        logPath: string;
        sessionsDir: string;
        debugDir: string;
    };
};
export type GetDebugConfigResponse = GetDebugConfigResponses[keyof GetDebugConfigResponses];
export type UpdateDebugConfigData = {
    body: {
        enabled?: boolean;
        scopes?: Array<string>;
    };
    path?: never;
    query?: never;
    url: '/v1/config/debug';
};
export type UpdateDebugConfigResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        debug: {
            enabled: boolean;
            scopes: Array<string>;
            logPath: string;
            sessionsDir: string;
            debugDir: string;
        };
    };
};
export type UpdateDebugConfigResponse = UpdateDebugConfigResponses[keyof UpdateDebugConfigResponses];
export type ListReferencesData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override.
         */
        project?: string;
        scope?: 'effective' | 'global' | 'local';
    };
    url: '/v1/config/references';
};
export type ListReferencesResponses = {
    /**
     * Configured references
     */
    200: {
        references: {
            [key: string]: {
                description: string;
                enabled?: boolean;
                source: {
                    type: 'git';
                    url: string;
                    ref?: string;
                } | {
                    type: 'local';
                    path: string;
                };
            };
        };
        statuses: {
            [key: string]: {
                status: 'cloning' | 'available' | 'error';
                error?: string;
                output?: Array<string>;
            };
        };
    };
};
export type ListReferencesResponse = ListReferencesResponses[keyof ListReferencesResponses];
export type ListReferenceDirectoriesData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override.
         */
        project?: string;
        path?: string;
    };
    url: '/v1/config/reference-directories';
};
export type ListReferenceDirectoriesResponses = {
    /**
     * Directory listing
     */
    200: {
        path: string;
        parent: string | null;
        directories: Array<{
            name: string;
            path: string;
        }>;
    };
};
export type ListReferenceDirectoriesResponse = ListReferenceDirectoriesResponses[keyof ListReferenceDirectoriesResponses];
export type DeleteReferenceData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Project root override.
         */
        project?: string;
        scope?: 'global' | 'local';
    };
    url: '/v1/config/references/{name}';
};
export type DeleteReferenceResponses = {
    /**
     * Updated references
     */
    200: {
        success: boolean;
        references: {
            [key: string]: {
                description: string;
                enabled?: boolean;
                source: {
                    type: 'git';
                    url: string;
                    ref?: string;
                } | {
                    type: 'local';
                    path: string;
                };
            };
        };
        statuses: {
            [key: string]: {
                status: 'cloning' | 'available' | 'error';
                error?: string;
                output?: Array<string>;
            };
        };
    };
};
export type DeleteReferenceResponse = DeleteReferenceResponses[keyof DeleteReferenceResponses];
export type UpsertReferenceData = {
    body: {
        description: string;
        enabled?: boolean;
        source: {
            type: 'git';
            url: string;
            ref?: string;
        } | {
            type: 'local';
            path: string;
        };
    };
    path: {
        name: string;
    };
    query?: {
        /**
         * Project root override.
         */
        project?: string;
        scope?: 'global' | 'local';
    };
    url: '/v1/config/references/{name}';
};
export type UpsertReferenceResponses = {
    /**
     * Updated references
     */
    200: {
        success: boolean;
        references: {
            [key: string]: {
                description: string;
                enabled?: boolean;
                source: {
                    type: 'git';
                    url: string;
                    ref?: string;
                } | {
                    type: 'local';
                    path: string;
                };
            };
        };
        statuses: {
            [key: string]: {
                status: 'cloning' | 'available' | 'error';
                error?: string;
                output?: Array<string>;
            };
        };
    };
};
export type UpsertReferenceResponse = UpsertReferenceResponses[keyof UpsertReferenceResponses];
export type RetryReferenceData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Project root override.
         */
        project?: string;
    };
    url: '/v1/config/references/{name}/retry';
};
export type RetryReferenceResponses = {
    /**
     * Reference clone retry started
     */
    200: {
        success: boolean;
        references: {
            [key: string]: {
                description: string;
                enabled?: boolean;
                source: {
                    type: 'git';
                    url: string;
                    ref?: string;
                } | {
                    type: 'local';
                    path: string;
                };
            };
        };
        statuses: {
            [key: string]: {
                status: 'cloning' | 'available' | 'error';
                error?: string;
                output?: Array<string>;
            };
        };
    };
};
export type RetryReferenceResponse = RetryReferenceResponses[keyof RetryReferenceResponses];
export type ListFilesData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Maximum directory depth to traverse
         */
        maxDepth?: number | null;
        /**
         * Maximum number of files to return
         */
        limit?: number | null;
    };
    url: '/v1/files';
};
export type ListFilesResponses = {
    /**
     * OK
     */
    200: {
        files: Array<string>;
        changedFiles: Array<{
            path: string;
            status: string;
        }>;
        truncated: boolean;
    };
};
export type ListFilesResponse = ListFilesResponses[keyof ListFilesResponses];
export type SearchFilesData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Search query
         */
        q?: string;
        /**
         * Maximum directory depth to traverse
         */
        maxDepth?: number | null;
        /**
         * Maximum number of files to return
         */
        limit?: number | null;
    };
    url: '/v1/files/search';
};
export type SearchFilesResponses = {
    /**
     * OK
     */
    200: {
        files: Array<string>;
        changedFiles: Array<{
            path: string;
            status: string;
        }>;
        truncated: boolean;
    };
};
export type SearchFilesResponse = SearchFilesResponses[keyof SearchFilesResponses];
export type GetFileTreeData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Directory path relative to project root
         */
        path?: string;
    };
    url: '/v1/files/tree';
};
export type GetFileTreeResponses = {
    /**
     * OK
     */
    200: {
        items: Array<{
            name: string;
            path: string;
            type: 'file' | 'directory';
            gitignored?: boolean;
            vendor?: boolean;
            searchable?: boolean;
        }>;
        path: string;
        truncated: boolean;
    };
};
export type GetFileTreeResponse = GetFileTreeResponses[keyof GetFileTreeResponses];
export type ReadFileData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Absolute file path or path relative to project root
         */
        path: string;
    };
    url: '/v1/files/read';
};
export type ReadFileErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type ReadFileError = ReadFileErrors[keyof ReadFileErrors];
export type ReadFileResponses = {
    /**
     * OK
     */
    200: {
        content: string;
        path: string;
        extension: string;
        lineCount: number;
    };
};
export type ReadFileResponse = ReadFileResponses[keyof ReadFileResponses];
export type GetFileRawData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Absolute file path or path relative to project root
         */
        path: string;
    };
    url: '/v1/files/raw';
};
export type GetFileRawErrors = {
    /**
     * Missing path parameter
     */
    400: unknown;
    /**
     * Path traversal not allowed
     */
    403: unknown;
};
export type GetFileRawResponses = {
    /**
     * Raw file content
     */
    200: Blob | File;
};
export type GetFileRawResponse = GetFileRawResponses[keyof GetFileRawResponses];
export type GetGitStatusData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/git/status';
};
export type GetGitStatusErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type GetGitStatusError = GetGitStatusErrors[keyof GetGitStatusErrors];
export type GetGitStatusResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            branch: string | null;
            headSha: string | null;
            shortHeadSha: string | null;
            isDetached: boolean;
            operation: {
                type: string;
                label: string;
                current?: number;
                total?: number;
                headName?: string;
                onto?: string;
            } | null;
            ahead: number;
            behind: number;
            hasUpstream: boolean;
            remotes: Array<string>;
            gitRoot: string;
            workingDir: string;
            staged: Array<{
                path: string;
                absPath: string;
                status: 'modified' | 'added' | 'deleted' | 'renamed' | 'untracked' | 'conflicted';
                staged: boolean;
                insertions?: number;
                deletions?: number;
                oldPath?: string;
                isNew: boolean;
                conflictType?: 'both-modified' | 'deleted-by-us' | 'deleted-by-them' | 'both-added' | 'both-deleted';
                [key: string]: unknown | string | 'modified' | 'added' | 'deleted' | 'renamed' | 'untracked' | 'conflicted' | boolean | number | 'both-modified' | 'deleted-by-us' | 'deleted-by-them' | 'both-added' | 'both-deleted' | undefined;
            }>;
            unstaged: Array<{
                path: string;
                absPath: string;
                status: 'modified' | 'added' | 'deleted' | 'renamed' | 'untracked' | 'conflicted';
                staged: boolean;
                insertions?: number;
                deletions?: number;
                oldPath?: string;
                isNew: boolean;
                conflictType?: 'both-modified' | 'deleted-by-us' | 'deleted-by-them' | 'both-added' | 'both-deleted';
                [key: string]: unknown | string | 'modified' | 'added' | 'deleted' | 'renamed' | 'untracked' | 'conflicted' | boolean | number | 'both-modified' | 'deleted-by-us' | 'deleted-by-them' | 'both-added' | 'both-deleted' | undefined;
            }>;
            untracked: Array<{
                path: string;
                absPath: string;
                status: 'modified' | 'added' | 'deleted' | 'renamed' | 'untracked' | 'conflicted';
                staged: boolean;
                insertions?: number;
                deletions?: number;
                oldPath?: string;
                isNew: boolean;
                conflictType?: 'both-modified' | 'deleted-by-us' | 'deleted-by-them' | 'both-added' | 'both-deleted';
                [key: string]: unknown | string | 'modified' | 'added' | 'deleted' | 'renamed' | 'untracked' | 'conflicted' | boolean | number | 'both-modified' | 'deleted-by-us' | 'deleted-by-them' | 'both-added' | 'both-deleted' | undefined;
            }>;
            conflicted: Array<{
                path: string;
                absPath: string;
                status: 'modified' | 'added' | 'deleted' | 'renamed' | 'untracked' | 'conflicted';
                staged: boolean;
                insertions?: number;
                deletions?: number;
                oldPath?: string;
                isNew: boolean;
                conflictType?: 'both-modified' | 'deleted-by-us' | 'deleted-by-them' | 'both-added' | 'both-deleted';
                [key: string]: unknown | string | 'modified' | 'added' | 'deleted' | 'renamed' | 'untracked' | 'conflicted' | boolean | number | 'both-modified' | 'deleted-by-us' | 'deleted-by-them' | 'both-added' | 'both-deleted' | undefined;
            }>;
            hasChanges: boolean;
            hasConflicts: boolean;
        };
    };
};
export type GetGitStatusResponse = GetGitStatusResponses[keyof GetGitStatusResponses];
export type GetGitBranchData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/git/branch';
};
export type GetGitBranchErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type GetGitBranchError = GetGitBranchErrors[keyof GetGitBranchErrors];
export type GetGitBranchResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            branch: string | null;
            ahead: number;
            behind: number;
            remotes: Array<string>;
        };
    };
};
export type GetGitBranchResponse = GetGitBranchResponses[keyof GetGitBranchResponses];
export type ListGitBranchesData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/git/branches';
};
export type ListGitBranchesErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type ListGitBranchesError = ListGitBranchesErrors[keyof ListGitBranchesErrors];
export type ListGitBranchesResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            current: string;
            branches: Array<{
                name: string;
                fullName: string;
                current: boolean;
                remote: boolean;
                remoteName?: string;
                upstream?: string;
                sha?: string;
                subject?: string;
            }>;
        };
    };
};
export type ListGitBranchesResponse = ListGitBranchesResponses[keyof ListGitBranchesResponses];
export type CreateGitBranchData = {
    body: {
        project?: string;
        name: string;
        startPoint?: string;
        checkout?: boolean;
    };
    path?: never;
    query?: never;
    url: '/v1/git/branches';
};
export type CreateGitBranchErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type CreateGitBranchError = CreateGitBranchErrors[keyof CreateGitBranchErrors];
export type CreateGitBranchResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            branch: string;
            checkedOut: boolean;
        };
    };
};
export type CreateGitBranchResponse = CreateGitBranchResponses[keyof CreateGitBranchResponses];
export type CheckoutGitBranchData = {
    body: {
        project?: string;
        branch: string;
    };
    path?: never;
    query?: never;
    url: '/v1/git/checkout';
};
export type CheckoutGitBranchErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type CheckoutGitBranchError = CheckoutGitBranchErrors[keyof CheckoutGitBranchErrors];
export type CheckoutGitBranchResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            branch: string;
        };
    };
};
export type CheckoutGitBranchResponse = CheckoutGitBranchResponses[keyof CheckoutGitBranchResponses];
export type GetGitDiffData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * File path to get diff for
         */
        file: string;
        /**
         * Show staged diff (default: unstaged)
         */
        staged?: 'true' | 'false';
        /**
         * Include full file content in diff
         */
        fullFile?: 'true' | 'false';
    };
    url: '/v1/git/diff';
};
export type GetGitDiffErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type GetGitDiffError = GetGitDiffErrors[keyof GetGitDiffErrors];
export type GetGitDiffResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            file: string;
            absPath: string;
            diff: string;
            content?: string;
            fullFile?: boolean;
            isNewFile: boolean;
            isBinary: boolean;
            insertions: number;
            deletions: number;
            language: string;
            staged: boolean;
        };
    };
};
export type GetGitDiffResponse = GetGitDiffResponses[keyof GetGitDiffResponses];
export type StageFilesData = {
    body: {
        project?: string;
        files: Array<string>;
    };
    path?: never;
    query?: never;
    url: '/v1/git/stage';
};
export type StageFilesErrors = {
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type StageFilesError = StageFilesErrors[keyof StageFilesErrors];
export type StageFilesResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            staged: Array<string>;
            failed?: Array<string>;
        };
    };
};
export type StageFilesResponse = StageFilesResponses[keyof StageFilesResponses];
export type UnstageFilesData = {
    body: {
        project?: string;
        files: Array<string>;
    };
    path?: never;
    query?: never;
    url: '/v1/git/unstage';
};
export type UnstageFilesErrors = {
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type UnstageFilesError = UnstageFilesErrors[keyof UnstageFilesErrors];
export type UnstageFilesResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            unstaged: Array<string>;
            failed?: Array<string>;
        };
    };
};
export type UnstageFilesResponse = UnstageFilesResponses[keyof UnstageFilesResponses];
export type RestoreFilesData = {
    body: {
        project?: string;
        files: Array<string>;
    };
    path?: never;
    query?: never;
    url: '/v1/git/restore';
};
export type RestoreFilesErrors = {
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type RestoreFilesError = RestoreFilesErrors[keyof RestoreFilesErrors];
export type RestoreFilesResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            restored: Array<string>;
            failed?: Array<string>;
        };
    };
};
export type RestoreFilesResponse = RestoreFilesResponses[keyof RestoreFilesResponses];
export type DeleteFilesData = {
    body: {
        project?: string;
        files: Array<string>;
    };
    path?: never;
    query?: never;
    url: '/v1/git/delete';
};
export type DeleteFilesErrors = {
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type DeleteFilesError = DeleteFilesErrors[keyof DeleteFilesErrors];
export type DeleteFilesResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            deleted: Array<string>;
            failed?: Array<string>;
        };
    };
};
export type DeleteFilesResponse = DeleteFilesResponses[keyof DeleteFilesResponses];
export type CommitChangesData = {
    body: {
        project?: string;
        message: string;
        sessionId?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/git/commit';
};
export type CommitChangesErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type CommitChangesError = CommitChangesErrors[keyof CommitChangesErrors];
export type CommitChangesResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            message: string;
        };
    };
};
export type CommitChangesResponse = CommitChangesResponses[keyof CommitChangesResponses];
export type GenerateCommitMessageData = {
    body?: {
        project?: string;
        /**
         * Session ID to use session provider
         */
        sessionId?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/git/generate-commit-message';
};
export type GenerateCommitMessageErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type GenerateCommitMessageError = GenerateCommitMessageErrors[keyof GenerateCommitMessageErrors];
export type GenerateCommitMessageResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            message: string;
        };
    };
};
export type GenerateCommitMessageResponse = GenerateCommitMessageResponses[keyof GenerateCommitMessageResponses];
export type PushCommitsData = {
    body?: {
        project?: string;
        sessionId?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/git/push';
};
export type PushCommitsErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
        details?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
        details?: string;
    };
};
export type PushCommitsError = PushCommitsErrors[keyof PushCommitsErrors];
export type PushCommitsResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            output: string;
        };
    };
};
export type PushCommitsResponse = PushCommitsResponses[keyof PushCommitsResponses];
export type PullChangesData = {
    body?: {
        project?: string;
        sessionId?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/git/pull';
};
export type PullChangesErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
        details?: string;
    };
    /**
     * Authentication failed
     */
    401: {
        status: 'error';
        error: string;
        code?: string;
        details?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
        details?: string;
    };
};
export type PullChangesError = PullChangesErrors[keyof PullChangesErrors];
export type PullChangesResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            output: string;
        };
    };
};
export type PullChangesResponse = PullChangesResponses[keyof PullChangesResponses];
export type PerformGitRebaseActionData = {
    body: {
        project?: string;
        action: 'continue' | 'abort' | 'skip';
    };
    path?: never;
    query?: never;
    url: '/v1/git/rebase';
};
export type PerformGitRebaseActionErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
    };
    /**
     * No rebase is currently in progress
     */
    409: {
        status: 'error';
        error: string;
        code?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type PerformGitRebaseActionError = PerformGitRebaseActionErrors[keyof PerformGitRebaseActionErrors];
export type PerformGitRebaseActionResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            action: 'continue' | 'abort' | 'skip';
            output: string;
        };
    };
};
export type PerformGitRebaseActionResponse = PerformGitRebaseActionResponses[keyof PerformGitRebaseActionResponses];
export type InitGitRepoData = {
    body?: {
        project?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/git/init';
};
export type InitGitRepoErrors = {
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type InitGitRepoError = InitGitRepoErrors[keyof InitGitRepoErrors];
export type InitGitRepoResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            initialized: boolean;
            path: string;
        };
    };
};
export type InitGitRepoResponse = InitGitRepoResponses[keyof InitGitRepoResponses];
export type RemoveGitRemoteData = {
    body: {
        project?: string;
        name: string;
    };
    path?: never;
    query?: never;
    url: '/v1/git/remotes';
};
export type RemoveGitRemoteErrors = {
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type RemoveGitRemoteError = RemoveGitRemoteErrors[keyof RemoveGitRemoteErrors];
export type RemoveGitRemoteResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            removed: string;
        };
    };
};
export type RemoveGitRemoteResponse = RemoveGitRemoteResponses[keyof RemoveGitRemoteResponses];
export type GetGitRemotesData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/git/remotes';
};
export type GetGitRemotesErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type GetGitRemotesError = GetGitRemotesErrors[keyof GetGitRemotesErrors];
export type GetGitRemotesResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            remotes: Array<{
                name: string;
                url: string;
                type: string;
            }>;
        };
    };
};
export type GetGitRemotesResponse = GetGitRemotesResponses[keyof GetGitRemotesResponses];
export type AddGitRemoteData = {
    body: {
        project?: string;
        name: string;
        url: string;
    };
    path?: never;
    query?: never;
    url: '/v1/git/remotes';
};
export type AddGitRemoteErrors = {
    /**
     * Error
     */
    400: {
        status: 'error';
        error: string;
        code?: string;
    };
    /**
     * Error
     */
    500: {
        status: 'error';
        error: string;
        code?: string;
    };
};
export type AddGitRemoteError = AddGitRemoteErrors[keyof AddGitRemoteErrors];
export type AddGitRemoteResponses = {
    /**
     * OK
     */
    200: {
        status: 'ok';
        data: {
            name: string;
            url: string;
        };
    };
};
export type AddGitRemoteResponse = AddGitRemoteResponses[keyof AddGitRemoteResponses];
export type CreateTerminalWebSocketTicketData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/terminals/{id}/ws-ticket';
};
export type CreateTerminalWebSocketTicketResponses = {
    /**
     * One-time WebSocket ticket
     */
    200: {
        ticket: string;
        expiresIn: number;
    };
};
export type CreateTerminalWebSocketTicketResponse = CreateTerminalWebSocketTicketResponses[keyof CreateTerminalWebSocketTicketResponses];
export type GetTerminalsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/terminals';
};
export type GetTerminalsResponses = {
    /**
     * List of terminals
     */
    200: {
        terminals: Array<{
            id: string;
            pid: number;
            command: string;
            args: Array<string>;
            cwd: string;
            purpose: string;
            createdBy: 'user' | 'llm';
            title: string;
            status: 'running' | 'exited';
            exitCode?: number;
            createdAt: string;
            uptime: number;
        }>;
        count: number;
    };
};
export type GetTerminalsResponse = GetTerminalsResponses[keyof GetTerminalsResponses];
export type PostTerminalsData = {
    body: {
        /**
         * Command to execute
         */
        command: string;
        /**
         * Command arguments
         */
        args?: Array<string>;
        /**
         * Description of terminal purpose
         */
        purpose: string;
        /**
         * Working directory
         */
        cwd?: string;
        /**
         * Terminal title
         */
        title?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/terminals';
};
export type PostTerminalsResponses = {
    /**
     * Terminal created
     */
    200: {
        terminalId: string;
        pid: number;
        purpose: string;
        command: string;
    };
};
export type PostTerminalsResponse = PostTerminalsResponses[keyof PostTerminalsResponses];
export type DeleteTerminalsByIdData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/terminals/{id}';
};
export type DeleteTerminalsByIdResponses = {
    /**
     * Terminal killed
     */
    200: {
        success: boolean;
    };
};
export type DeleteTerminalsByIdResponse = DeleteTerminalsByIdResponses[keyof DeleteTerminalsByIdResponses];
export type GetTerminalsByIdData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/terminals/{id}';
};
export type GetTerminalsByIdErrors = {
    /**
     * Terminal not found
     */
    404: unknown;
};
export type GetTerminalsByIdResponses = {
    /**
     * Terminal details
     */
    200: {
        terminal: {
            id: string;
            pid: number;
            command: string;
            args: Array<string>;
            cwd: string;
            purpose: string;
            createdBy: 'user' | 'llm';
            title: string;
            status: 'running' | 'exited';
            exitCode?: number;
            createdAt: string;
            uptime: number;
        };
    };
};
export type GetTerminalsByIdResponse = GetTerminalsByIdResponses[keyof GetTerminalsByIdResponses];
export type ConnectTerminalWebSocketData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/terminals/{id}/ws';
};
export type ConnectTerminalWebSocketErrors = {
    /**
     * Terminal not found
     */
    404: unknown;
};
export type GetTerminalsByIdOutputData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/terminals/{id}/output';
};
export type GetTerminalsByIdOutputResponses = {
    /**
     * SSE stream of terminal output
     */
    200: string;
};
export type GetTerminalsByIdOutputResponse = GetTerminalsByIdOutputResponses[keyof GetTerminalsByIdOutputResponses];
export type PostTerminalsByIdOutputData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/terminals/{id}/output';
};
export type PostTerminalsByIdOutputResponses = {
    /**
     * SSE stream of terminal output
     */
    200: string;
};
export type PostTerminalsByIdOutputResponse = PostTerminalsByIdOutputResponses[keyof PostTerminalsByIdOutputResponses];
export type PostTerminalsByIdInputData = {
    body: {
        /**
         * Input to send to terminal
         */
        input: string;
    };
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/terminals/{id}/input';
};
export type PostTerminalsByIdInputResponses = {
    /**
     * Input sent
     */
    200: {
        success: boolean;
    };
};
export type PostTerminalsByIdInputResponse = PostTerminalsByIdInputResponses[keyof PostTerminalsByIdInputResponses];
export type ResizeTerminalData = {
    body: {
        cols: number;
        rows: number;
    };
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/terminals/{id}/resize';
};
export type ResizeTerminalErrors = {
    /**
     * Invalid terminal size
     */
    400: unknown;
    /**
     * Terminal not found
     */
    404: unknown;
};
export type ResizeTerminalResponses = {
    /**
     * Terminal resized
     */
    200: {
        success: boolean;
    };
};
export type ResizeTerminalResponse = ResizeTerminalResponses[keyof ResizeTerminalResponses];
export type GetSessionFilesData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/files';
};
export type GetSessionFilesErrors = {
    /**
     * Session not found
     */
    404: {
        error: string;
    };
};
export type GetSessionFilesError = GetSessionFilesErrors[keyof GetSessionFilesErrors];
export type GetSessionFilesResponses = {
    /**
     * OK
     */
    200: {
        files: Array<{
            path: string;
            operations: Array<{
                path: string;
                operation: 'write' | 'patch' | 'create';
                timestamp: number;
                toolCallId: string;
                toolName: string;
                patch?: string;
                content?: string;
                artifact?: {
                    kind: string;
                    patch?: string;
                    summary?: {
                        additions: number;
                        deletions: number;
                    };
                };
            }>;
            operationCount: number;
            firstModified: number;
            lastModified: number;
        }>;
        totalFiles: number;
        totalOperations: number;
    };
};
export type GetSessionFilesResponse = GetSessionFilesResponses[keyof GetSessionFilesResponses];
export type CreateBranchData = {
    body: {
        fromMessageId: string;
        provider?: string;
        model?: string;
        agent?: string;
        title?: string;
    };
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/branch';
};
export type CreateBranchErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type CreateBranchError = CreateBranchErrors[keyof CreateBranchErrors];
export type CreateBranchResponses = {
    /**
     * Created
     */
    201: {
        id: string;
        title: string | null;
        agent: string;
        provider: string;
        model: string;
        projectPath: string;
        createdAt: number;
        lastActiveAt: number | null;
        lastViewedAt?: number | null;
        totalInputTokens: number | null;
        totalOutputTokens: number | null;
        totalCachedTokens?: number | null;
        totalCacheCreationTokens?: number | null;
        totalToolTimeMs: number | null;
        currentContextTokens?: number | null;
        toolCounts?: {
            [key: string]: number;
        };
        parentSessionId?: string | null;
        branchPointMessageId?: string | null;
        sessionType?: 'main' | 'branch' | 'handoff';
        [key: string]: unknown | string | string | null | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | {
            [key: string]: number;
        } | string | null | string | null | 'main' | 'branch' | 'handoff' | undefined;
    };
};
export type CreateBranchResponse = CreateBranchResponses[keyof CreateBranchResponses];
export type ListBranchesData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/branches';
};
export type ListBranchesResponses = {
    /**
     * OK
     */
    200: {
        branches: Array<{
            id: string;
            title: string | null;
            agent: string;
            provider: string;
            model: string;
            projectPath: string;
            createdAt: number;
            lastActiveAt: number | null;
            lastViewedAt?: number | null;
            totalInputTokens: number | null;
            totalOutputTokens: number | null;
            totalCachedTokens?: number | null;
            totalCacheCreationTokens?: number | null;
            totalToolTimeMs: number | null;
            currentContextTokens?: number | null;
            toolCounts?: {
                [key: string]: number;
            };
            parentSessionId?: string | null;
            branchPointMessageId?: string | null;
            sessionType?: 'main' | 'branch' | 'handoff';
            [key: string]: unknown | string | string | null | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | {
                [key: string]: number;
            } | string | null | string | null | 'main' | 'branch' | 'handoff' | undefined;
        }>;
    };
};
export type ListBranchesResponse = ListBranchesResponses[keyof ListBranchesResponses];
export type GetParentSessionData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/parent';
};
export type GetParentSessionResponses = {
    /**
     * OK
     */
    200: {
        parent: {
            id: string;
            title: string | null;
            agent: string;
            provider: string;
            model: string;
            projectPath: string;
            createdAt: number;
            lastActiveAt: number | null;
            lastViewedAt?: number | null;
            totalInputTokens: number | null;
            totalOutputTokens: number | null;
            totalCachedTokens?: number | null;
            totalCacheCreationTokens?: number | null;
            totalToolTimeMs: number | null;
            currentContextTokens?: number | null;
            toolCounts?: {
                [key: string]: number;
            };
            parentSessionId?: string | null;
            branchPointMessageId?: string | null;
            sessionType?: 'main' | 'branch' | 'handoff';
            [key: string]: unknown | string | string | null | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | {
                [key: string]: number;
            } | string | null | string | null | 'main' | 'branch' | 'handoff' | undefined;
        } | null;
    };
};
export type GetParentSessionResponse = GetParentSessionResponses[keyof GetParentSessionResponses];
export type ListResearchSessionsData = {
    body?: never;
    path: {
        parentId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{parentId}/research';
};
export type ListResearchSessionsErrors = {
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
};
export type ListResearchSessionsError = ListResearchSessionsErrors[keyof ListResearchSessionsErrors];
export type ListResearchSessionsResponses = {
    /**
     * OK
     */
    200: {
        sessions: Array<{
            id: string;
            title: string | null;
            agent: string;
            provider: string;
            model: string;
            projectPath: string;
            createdAt: number;
            lastActiveAt: number | null;
            lastViewedAt?: number | null;
            totalInputTokens: number | null;
            totalOutputTokens: number | null;
            totalCachedTokens?: number | null;
            totalCacheCreationTokens?: number | null;
            totalToolTimeMs: number | null;
            currentContextTokens?: number | null;
            toolCounts?: {
                [key: string]: number;
            };
            parentSessionId?: string | null;
            branchPointMessageId?: string | null;
            sessionType?: 'main' | 'branch' | 'handoff';
            [key: string]: unknown | string | string | null | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | {
                [key: string]: number;
            } | string | null | string | null | 'main' | 'branch' | 'handoff' | undefined;
        }>;
    };
};
export type ListResearchSessionsResponse = ListResearchSessionsResponses[keyof ListResearchSessionsResponses];
export type CreateResearchSessionData = {
    body?: {
        provider?: string;
        model?: string;
        title?: string;
    };
    path: {
        parentId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{parentId}/research';
};
export type CreateResearchSessionErrors = {
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
};
export type CreateResearchSessionError = CreateResearchSessionErrors[keyof CreateResearchSessionErrors];
export type CreateResearchSessionResponses = {
    /**
     * Created
     */
    201: {
        session: {
            id: string;
            title: string | null;
            agent: string;
            provider: string;
            model: string;
            projectPath: string;
            createdAt: number;
            lastActiveAt: number | null;
            lastViewedAt?: number | null;
            totalInputTokens: number | null;
            totalOutputTokens: number | null;
            totalCachedTokens?: number | null;
            totalCacheCreationTokens?: number | null;
            totalToolTimeMs: number | null;
            currentContextTokens?: number | null;
            toolCounts?: {
                [key: string]: number;
            };
            parentSessionId?: string | null;
            branchPointMessageId?: string | null;
            sessionType?: 'main' | 'branch' | 'handoff';
            [key: string]: unknown | string | string | null | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | {
                [key: string]: number;
            } | string | null | string | null | 'main' | 'branch' | 'handoff' | undefined;
        };
        parentSessionId: string;
    };
};
export type CreateResearchSessionResponse = CreateResearchSessionResponses[keyof CreateResearchSessionResponses];
export type DeleteResearchSessionData = {
    body?: never;
    path: {
        researchId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/research/{researchId}';
};
export type DeleteResearchSessionErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
};
export type DeleteResearchSessionError = DeleteResearchSessionErrors[keyof DeleteResearchSessionErrors];
export type DeleteResearchSessionResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
    };
};
export type DeleteResearchSessionResponse = DeleteResearchSessionResponses[keyof DeleteResearchSessionResponses];
export type InjectResearchContextData = {
    body: {
        researchSessionId: string;
        label?: string;
    };
    path: {
        parentId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{parentId}/inject';
};
export type InjectResearchContextErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
};
export type InjectResearchContextError = InjectResearchContextErrors[keyof InjectResearchContextErrors];
export type InjectResearchContextResponses = {
    /**
     * OK
     */
    200: {
        content: string;
        label: string;
        sessionId: string;
        parentSessionId: string;
        tokenEstimate: number;
    };
};
export type InjectResearchContextResponse = InjectResearchContextResponses[keyof InjectResearchContextResponses];
export type ExportResearchSessionData = {
    body?: {
        provider?: string;
        model?: string;
        agent?: string;
    };
    path: {
        researchId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/research/{researchId}/export';
};
export type ExportResearchSessionErrors = {
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
};
export type ExportResearchSessionError = ExportResearchSessionErrors[keyof ExportResearchSessionErrors];
export type ExportResearchSessionResponses = {
    /**
     * Created
     */
    201: {
        newSession: {
            id: string;
            title: string | null;
            agent: string;
            provider: string;
            model: string;
            projectPath: string;
            createdAt: number;
            lastActiveAt: number | null;
            lastViewedAt?: number | null;
            totalInputTokens: number | null;
            totalOutputTokens: number | null;
            totalCachedTokens?: number | null;
            totalCacheCreationTokens?: number | null;
            totalToolTimeMs: number | null;
            currentContextTokens?: number | null;
            toolCounts?: {
                [key: string]: number;
            };
            parentSessionId?: string | null;
            branchPointMessageId?: string | null;
            sessionType?: 'main' | 'branch' | 'handoff';
            [key: string]: unknown | string | string | null | number | number | null | number | null | number | null | number | null | number | null | number | null | number | null | number | null | {
                [key: string]: number;
            } | string | null | string | null | 'main' | 'branch' | 'handoff' | undefined;
        };
        injectedContext: string;
    };
};
export type ExportResearchSessionResponse = ExportResearchSessionResponses[keyof ExportResearchSessionResponses];
export type ListGoalsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/goals';
};
export type ListGoalsResponses = {
    /**
     * OK
     */
    200: {
        goals: Array<{
            id: string;
            projectPath: string;
            sessionId: string | null;
            looperSessionId: string | null;
            title: string;
            status: 'active' | 'completed' | 'abandoned';
            startedAt: number | null;
            createdAt: number;
            updatedAt: number;
            tasks: Array<{
                id: string;
                goalId: string;
                sessionId: string | null;
                position: number;
                content: string;
                status: 'pending' | 'in_progress' | 'completed' | 'blocked' | 'cancelled';
                note: string | null;
                createdAt: number;
                updatedAt: number;
            }>;
        }>;
    };
};
export type ListGoalsResponse = ListGoalsResponses[keyof ListGoalsResponses];
export type GetSessionGoalData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/goal';
};
export type GetSessionGoalResponses = {
    /**
     * OK
     */
    200: {
        goal: {
            id: string;
            projectPath: string;
            sessionId: string | null;
            looperSessionId: string | null;
            title: string;
            status: 'active' | 'completed' | 'abandoned';
            startedAt: number | null;
            createdAt: number;
            updatedAt: number;
            tasks: Array<{
                id: string;
                goalId: string;
                sessionId: string | null;
                position: number;
                content: string;
                status: 'pending' | 'in_progress' | 'completed' | 'blocked' | 'cancelled';
                note: string | null;
                createdAt: number;
                updatedAt: number;
            }>;
        } | null;
    };
};
export type GetSessionGoalResponse = GetSessionGoalResponses[keyof GetSessionGoalResponses];
export type CreateSessionGoalData = {
    body: {
        title: string;
        tasks?: Array<string>;
    };
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/goal';
};
export type CreateSessionGoalErrors = {
    /**
     * Active goal already exists
     */
    409: {
        error: string;
    };
};
export type CreateSessionGoalError = CreateSessionGoalErrors[keyof CreateSessionGoalErrors];
export type CreateSessionGoalResponses = {
    /**
     * Created
     */
    201: {
        goal: {
            id: string;
            projectPath: string;
            sessionId: string | null;
            looperSessionId: string | null;
            title: string;
            status: 'active' | 'completed' | 'abandoned';
            startedAt: number | null;
            createdAt: number;
            updatedAt: number;
            tasks: Array<{
                id: string;
                goalId: string;
                sessionId: string | null;
                position: number;
                content: string;
                status: 'pending' | 'in_progress' | 'completed' | 'blocked' | 'cancelled';
                note: string | null;
                createdAt: number;
                updatedAt: number;
            }>;
        };
    };
};
export type CreateSessionGoalResponse = CreateSessionGoalResponses[keyof CreateSessionGoalResponses];
export type UpdateGoalData = {
    body: {
        title?: string;
        status?: 'active' | 'completed' | 'abandoned';
    };
    path: {
        goalId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/goals/{goalId}';
};
export type UpdateGoalErrors = {
    /**
     * Not Found
     */
    404: {
        error: string;
    };
};
export type UpdateGoalError = UpdateGoalErrors[keyof UpdateGoalErrors];
export type UpdateGoalResponses = {
    /**
     * OK
     */
    200: {
        goal: {
            id: string;
            projectPath: string;
            sessionId: string | null;
            looperSessionId: string | null;
            title: string;
            status: 'active' | 'completed' | 'abandoned';
            startedAt: number | null;
            createdAt: number;
            updatedAt: number;
            tasks: Array<{
                id: string;
                goalId: string;
                sessionId: string | null;
                position: number;
                content: string;
                status: 'pending' | 'in_progress' | 'completed' | 'blocked' | 'cancelled';
                note: string | null;
                createdAt: number;
                updatedAt: number;
            }>;
        };
    };
};
export type UpdateGoalResponse = UpdateGoalResponses[keyof UpdateGoalResponses];
export type AddGoalTasksData = {
    body: {
        tasks: Array<string>;
    };
    path: {
        goalId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/goals/{goalId}/tasks';
};
export type AddGoalTasksErrors = {
    /**
     * Not Found
     */
    404: {
        error: string;
    };
};
export type AddGoalTasksError = AddGoalTasksErrors[keyof AddGoalTasksErrors];
export type AddGoalTasksResponses = {
    /**
     * Created
     */
    201: {
        goal: {
            id: string;
            projectPath: string;
            sessionId: string | null;
            looperSessionId: string | null;
            title: string;
            status: 'active' | 'completed' | 'abandoned';
            startedAt: number | null;
            createdAt: number;
            updatedAt: number;
            tasks: Array<{
                id: string;
                goalId: string;
                sessionId: string | null;
                position: number;
                content: string;
                status: 'pending' | 'in_progress' | 'completed' | 'blocked' | 'cancelled';
                note: string | null;
                createdAt: number;
                updatedAt: number;
            }>;
        };
    };
};
export type AddGoalTasksResponse = AddGoalTasksResponses[keyof AddGoalTasksResponses];
export type DeleteGoalTaskData = {
    body?: never;
    path: {
        goalId: string;
        taskId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/goals/{goalId}/tasks/{taskId}';
};
export type DeleteGoalTaskErrors = {
    /**
     * Not Found
     */
    404: {
        error: string;
    };
    /**
     * Task cannot be deleted
     */
    409: {
        error: string;
    };
};
export type DeleteGoalTaskError = DeleteGoalTaskErrors[keyof DeleteGoalTaskErrors];
export type DeleteGoalTaskResponses = {
    /**
     * OK
     */
    200: {
        goal: {
            id: string;
            projectPath: string;
            sessionId: string | null;
            looperSessionId: string | null;
            title: string;
            status: 'active' | 'completed' | 'abandoned';
            startedAt: number | null;
            createdAt: number;
            updatedAt: number;
            tasks: Array<{
                id: string;
                goalId: string;
                sessionId: string | null;
                position: number;
                content: string;
                status: 'pending' | 'in_progress' | 'completed' | 'blocked' | 'cancelled';
                note: string | null;
                createdAt: number;
                updatedAt: number;
            }>;
        };
    };
};
export type DeleteGoalTaskResponse = DeleteGoalTaskResponses[keyof DeleteGoalTaskResponses];
export type UpdateGoalTaskData = {
    body: {
        content?: string;
        status?: 'pending' | 'in_progress' | 'completed' | 'blocked' | 'cancelled';
        note?: string | null;
    };
    path: {
        goalId: string;
        taskId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/goals/{goalId}/tasks/{taskId}';
};
export type UpdateGoalTaskErrors = {
    /**
     * Not Found
     */
    404: {
        error: string;
    };
};
export type UpdateGoalTaskError = UpdateGoalTaskErrors[keyof UpdateGoalTaskErrors];
export type UpdateGoalTaskResponses = {
    /**
     * OK
     */
    200: {
        task: {
            id: string;
            goalId: string;
            sessionId: string | null;
            position: number;
            content: string;
            status: 'pending' | 'in_progress' | 'completed' | 'blocked' | 'cancelled';
            note: string | null;
            createdAt: number;
            updatedAt: number;
        };
    };
};
export type UpdateGoalTaskResponse = UpdateGoalTaskResponses[keyof UpdateGoalTaskResponses];
export type StartGoalData = {
    body?: never;
    path: {
        goalId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/goals/{goalId}/start';
};
export type StartGoalErrors = {
    /**
     * Not Found
     */
    404: {
        error: string;
    };
    /**
     * Goal cannot be started
     */
    409: {
        error: string;
    };
};
export type StartGoalError = StartGoalErrors[keyof StartGoalErrors];
export type StartGoalResponses = {
    /**
     * OK
     */
    200: {
        goal: {
            id: string;
            projectPath: string;
            sessionId: string | null;
            looperSessionId: string | null;
            title: string;
            status: 'active' | 'completed' | 'abandoned';
            startedAt: number | null;
            createdAt: number;
            updatedAt: number;
            tasks: Array<{
                id: string;
                goalId: string;
                sessionId: string | null;
                position: number;
                content: string;
                status: 'pending' | 'in_progress' | 'completed' | 'blocked' | 'cancelled';
                note: string | null;
                createdAt: number;
                updatedAt: number;
            }>;
        };
    };
};
export type StartGoalResponse = StartGoalResponses[keyof StartGoalResponses];
export type ListSessionSubagentsData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Filter sub-agents by status.
         */
        status?: 'running' | 'completed' | 'failed' | 'cancelled';
    };
    url: '/v1/sessions/{sessionId}/subagents';
};
export type ListSessionSubagentsResponses = {
    /**
     * OK
     */
    200: {
        subagents: Array<{
            id: string;
            parentSessionId: string;
            childSessionId: string;
            agent: string;
            task: string;
            status: 'running' | 'completed' | 'failed' | 'cancelled';
            summary: string | null;
            reported: boolean;
            createdAt: number;
            updatedAt: number;
        }>;
    };
};
export type ListSessionSubagentsResponse = ListSessionSubagentsResponses[keyof ListSessionSubagentsResponses];
export type ListSessionShellJobsData = {
    body?: never;
    path: {
        sessionId: string;
    };
    query?: {
        /**
         * Project root override.
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/shell-jobs';
};
export type ListSessionShellJobsResponses = {
    /**
     * OK
     */
    200: {
        jobs: Array<{
            id: string;
            sessionId: string;
            messageId: string;
            callId?: string;
            command: string;
            cwd: string;
            status: 'running' | 'completed' | 'failed' | 'cancelled';
            detached: boolean;
            output: string;
            exitCode: number | null;
            result?: unknown;
            reported: boolean;
            createdAt: number;
            updatedAt: number;
            completedAt: number | null;
        }>;
    };
};
export type ListSessionShellJobsResponse = ListSessionShellJobsResponses[keyof ListSessionShellJobsResponses];
export type DetachSessionShellJobData = {
    body?: never;
    path: {
        sessionId: string;
        jobId: string;
    };
    query?: {
        /**
         * Project root override.
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/shell-jobs/{jobId}/detach';
};
export type DetachSessionShellJobErrors = {
    /**
     * Not found
     */
    404: {
        error: {
            message: string;
        };
    };
};
export type DetachSessionShellJobError = DetachSessionShellJobErrors[keyof DetachSessionShellJobErrors];
export type DetachSessionShellJobResponses = {
    /**
     * OK
     */
    200: {
        job: {
            id: string;
            sessionId: string;
            messageId: string;
            callId?: string;
            command: string;
            cwd: string;
            status: 'running' | 'completed' | 'failed' | 'cancelled';
            detached: boolean;
            output: string;
            exitCode: number | null;
            result?: unknown;
            reported: boolean;
            createdAt: number;
            updatedAt: number;
            completedAt: number | null;
        };
    };
};
export type DetachSessionShellJobResponse = DetachSessionShellJobResponses[keyof DetachSessionShellJobResponses];
export type AbortSessionShellJobData = {
    body?: never;
    path: {
        sessionId: string;
        jobId: string;
    };
    query?: {
        /**
         * Project root override.
         */
        project?: string;
    };
    url: '/v1/sessions/{sessionId}/shell-jobs/{jobId}/abort';
};
export type AbortSessionShellJobErrors = {
    /**
     * Not found
     */
    404: {
        error: {
            message: string;
        };
    };
};
export type AbortSessionShellJobError = AbortSessionShellJobErrors[keyof AbortSessionShellJobErrors];
export type AbortSessionShellJobResponses = {
    /**
     * OK
     */
    200: {
        job: {
            id: string;
            sessionId: string;
            messageId: string;
            callId?: string;
            command: string;
            cwd: string;
            status: 'running' | 'completed' | 'failed' | 'cancelled';
            detached: boolean;
            output: string;
            exitCode: number | null;
            result?: unknown;
            reported: boolean;
            createdAt: number;
            updatedAt: number;
            completedAt: number | null;
        };
    };
};
export type AbortSessionShellJobResponse = AbortSessionShellJobResponses[keyof AbortSessionShellJobResponses];
export type GetOttoRouterBalanceData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/ottorouter/balance';
};
export type GetOttoRouterBalanceErrors = {
    /**
     * OAuth not configured
     */
    401: {
        error: string;
    };
    /**
     * Failed to fetch balance from OttoRouter
     */
    502: {
        error: string;
    };
};
export type GetOttoRouterBalanceError = GetOttoRouterBalanceErrors[keyof GetOttoRouterBalanceErrors];
export type GetOttoRouterBalanceResponses = {
    /**
     * OK
     */
    200: {
        walletAddress: string;
        balance: number;
        totalSpent: number;
        totalTopups: number;
        requestCount: number;
        scope?: 'wallet' | 'account';
        payg?: {
            walletBalanceUsd?: number;
            accountBalanceUsd?: number;
            rawPoolUsd?: number;
            effectiveSpendableUsd?: number;
        };
        limits?: {
            enabled?: boolean;
            dailyLimitUsd?: number | null;
            dailySpentUsd?: number;
            dailyRemainingUsd?: number | null;
            monthlyLimitUsd?: number | null;
            monthlySpentUsd?: number;
            monthlyRemainingUsd?: number | null;
            capRemainingUsd?: number | null;
        } | null;
        subscription?: {
            active?: boolean;
            tierId?: string;
            tierName?: string;
            creditsIncluded?: number;
            creditsUsed?: number;
            creditsRemaining?: number;
            periodStart?: string;
            periodEnd?: string;
        } | null;
    };
};
export type GetOttoRouterBalanceResponse = GetOttoRouterBalanceResponses[keyof GetOttoRouterBalanceResponses];
export type GetOttoRouterAuthData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/ottorouter/wallet';
};
export type GetOttoRouterAuthResponses = {
    /**
     * OK
     */
    200: {
        configured: boolean;
        expiresAt?: number;
        error?: string;
    };
};
export type GetOttoRouterAuthResponse = GetOttoRouterAuthResponses[keyof GetOttoRouterAuthResponses];
export type ListAuthorizedMachineProjectsData = {
    body: {
        deviceId: string;
        machineId: string;
        hostname: string;
        forceOwnerSession?: boolean;
    };
    path?: never;
    query?: never;
    url: '/v1/ottorouter/machine/projects';
};
export type ListAuthorizedMachineProjectsResponses = {
    /**
     * Machine projects
     */
    200: {
        status: 'ready' | 'unavailable';
        apiUrl?: string;
        ownerSession?: string;
        ownerSessionExpiresAt?: number;
        projects?: Array<{
            id: string;
            name: string;
            path: string;
            open: boolean;
            lastUsedAt: number;
            pinned?: boolean;
        }>;
        serverInfo?: {
            version: string | null;
            pid?: number;
            startedAt?: number;
            protocol?: {
                version: number;
                minVersion: number;
                maxVersion: number;
                capabilities: Array<string>;
            };
        } | null;
        message?: string;
    };
};
export type ListAuthorizedMachineProjectsResponse = ListAuthorizedMachineProjectsResponses[keyof ListAuthorizedMachineProjectsResponses];
export type ListOttoRouterDevicesData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/ottorouter/devices';
};
export type ListOttoRouterDevicesResponses = {
    /**
     * Account devices excluding this daemon
     */
    200: {
        configured: boolean;
        devices: Array<{
            deviceId: string;
            machineId: string;
            hostname?: string | null;
            name?: string | null;
            status?: string | null;
        }>;
        error?: string;
    };
};
export type ListOttoRouterDevicesResponse = ListOttoRouterDevicesResponses[keyof ListOttoRouterDevicesResponses];
export type AuthorizeOttoRouterDeviceData = {
    body: {
        device_id: string;
        machine_id: string;
        challenge: string;
    };
    path?: never;
    query?: never;
    url: '/v1/ottorouter/devices/authorize';
};
export type AuthorizeOttoRouterDeviceResponses = {
    /**
     * Short-lived owner assertion
     */
    200: {
        assertion: string;
        device_id: string;
        machine_id: string;
    };
};
export type AuthorizeOttoRouterDeviceResponse = AuthorizeOttoRouterDeviceResponses[keyof AuthorizeOttoRouterDeviceResponses];
export type GetPolarTopupEstimateData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Amount in USD
         */
        amount?: number | null;
    };
    url: '/v1/ottorouter/topup/polar/estimate';
};
export type GetPolarTopupEstimateResponses = {
    /**
     * OK
     */
    200: {
        creditAmount?: number;
        chargeAmount?: number;
        feeAmount?: number;
        feeBreakdown?: {
            basePercent?: number;
            internationalPercent?: number;
            fixedCents?: number;
        };
    };
};
export type GetPolarTopupEstimateResponse = GetPolarTopupEstimateResponses[keyof GetPolarTopupEstimateResponses];
export type CreatePolarCheckoutData = {
    body: {
        amount: number;
        successUrl: string;
    };
    path?: never;
    query?: never;
    url: '/v1/ottorouter/topup/polar';
};
export type CreatePolarCheckoutErrors = {
    /**
     * OAuth not configured
     */
    401: {
        error: string;
    };
};
export type CreatePolarCheckoutError = CreatePolarCheckoutErrors[keyof CreatePolarCheckoutErrors];
export type CreatePolarCheckoutResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: unknown;
    };
};
export type CreatePolarCheckoutResponse = CreatePolarCheckoutResponses[keyof CreatePolarCheckoutResponses];
export type GetPolarTopupStatusData = {
    body?: never;
    path?: never;
    query: {
        checkoutId: string;
    };
    url: '/v1/ottorouter/topup/polar/status';
};
export type GetPolarTopupStatusResponses = {
    /**
     * OK
     */
    200: {
        checkoutId?: string;
        confirmed?: boolean;
        amountUsd?: number | null;
        confirmedAt?: string | null;
    };
};
export type GetPolarTopupStatusResponse = GetPolarTopupStatusResponses[keyof GetPolarTopupStatusResponses];
export type GetRazorpayTopupEstimateData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Amount in USD
         */
        amount?: number | null;
    };
    url: '/v1/ottorouter/topup/razorpay/estimate';
};
export type GetRazorpayTopupEstimateResponses = {
    /**
     * OK
     */
    200: {
        creditAmountUsd?: number;
        chargeAmountInr?: number;
        feeAmountInr?: number;
        currency?: string;
        exchangeRate?: number;
    };
};
export type GetRazorpayTopupEstimateResponse = GetRazorpayTopupEstimateResponses[keyof GetRazorpayTopupEstimateResponses];
export type CreateRazorpayOrderData = {
    body: {
        amount: number;
    };
    path?: never;
    query?: never;
    url: '/v1/ottorouter/topup/razorpay';
};
export type CreateRazorpayOrderErrors = {
    /**
     * OAuth not configured
     */
    401: {
        error: string;
    };
};
export type CreateRazorpayOrderError = CreateRazorpayOrderErrors[keyof CreateRazorpayOrderErrors];
export type CreateRazorpayOrderResponses = {
    /**
     * OK
     */
    200: {
        success?: boolean;
        orderId?: string;
        amount?: number;
        currency?: string;
        creditAmountUsd?: number;
        keyId?: string;
    };
};
export type CreateRazorpayOrderResponse = CreateRazorpayOrderResponses[keyof CreateRazorpayOrderResponses];
export type VerifyRazorpayPaymentData = {
    body: {
        razorpay_order_id: string;
        razorpay_payment_id: string;
        razorpay_signature: string;
    };
    path?: never;
    query?: never;
    url: '/v1/ottorouter/topup/razorpay/verify';
};
export type VerifyRazorpayPaymentErrors = {
    /**
     * OAuth not configured
     */
    401: {
        error: string;
    };
};
export type VerifyRazorpayPaymentError = VerifyRazorpayPaymentErrors[keyof VerifyRazorpayPaymentErrors];
export type VerifyRazorpayPaymentResponses = {
    /**
     * OK
     */
    200: {
        success?: boolean;
        credited?: number;
        newBalance?: number;
    };
};
export type VerifyRazorpayPaymentResponse = VerifyRazorpayPaymentResponses[keyof VerifyRazorpayPaymentResponses];
export type SelectTopupMethodData = {
    body: {
        sessionId: string;
        method: 'crypto' | 'fiat';
    };
    path?: never;
    query?: never;
    url: '/v1/ottorouter/topup/select';
};
export type SelectTopupMethodErrors = {
    /**
     * No pending topup
     */
    404: {
        error: string;
    };
};
export type SelectTopupMethodError = SelectTopupMethodErrors[keyof SelectTopupMethodErrors];
export type SelectTopupMethodResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        method: 'crypto' | 'fiat';
    };
};
export type SelectTopupMethodResponse = SelectTopupMethodResponses[keyof SelectTopupMethodResponses];
export type CancelTopupData = {
    body: {
        sessionId: string;
        reason?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/ottorouter/topup/cancel';
};
export type CancelTopupErrors = {
    /**
     * No pending topup
     */
    404: {
        error: string;
    };
};
export type CancelTopupError = CancelTopupErrors[keyof CancelTopupErrors];
export type CancelTopupResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
    };
};
export type CancelTopupResponse = CancelTopupResponses[keyof CancelTopupResponses];
export type GetPendingTopupData = {
    body?: never;
    path?: never;
    query: {
        sessionId: string;
    };
    url: '/v1/ottorouter/topup/pending';
};
export type GetPendingTopupResponses = {
    /**
     * OK
     */
    200: {
        hasPending: boolean;
        sessionId?: string;
        messageId?: string;
        amountUsd?: number;
        currentBalance?: number;
        createdAt?: number;
    };
};
export type GetPendingTopupResponse = GetPendingTopupResponses[keyof GetPendingTopupResponses];
export type GetAuthStatusData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/auth/status';
};
export type GetAuthStatusResponses = {
    /**
     * OK
     */
    200: {
        onboardingComplete: boolean;
        ottorouter: {
            configured: boolean;
            expiresAt?: number;
        };
        providers: {
            [key: string]: {
                configured: boolean;
                type?: 'api' | 'oauth';
                label: string;
                supportsOAuth: boolean;
                supportsToken?: boolean;
                supportsGhImport?: boolean;
                custom?: boolean;
                modelCount: number;
                costRange?: {
                    min: number;
                    max: number;
                };
            };
        };
        defaults?: {
            [key: string]: unknown;
        };
    };
};
export type GetAuthStatusResponse = GetAuthStatusResponses[keyof GetAuthStatusResponses];
export type RemoveProviderData = {
    body?: never;
    path: {
        provider: string;
    };
    query?: never;
    url: '/v1/auth/{provider}';
};
export type RemoveProviderErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type RemoveProviderError = RemoveProviderErrors[keyof RemoveProviderErrors];
export type RemoveProviderResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        provider: string;
        tunnelDisabled?: boolean;
        authRemoved?: boolean;
        error?: string;
    };
};
export type RemoveProviderResponse = RemoveProviderResponses[keyof RemoveProviderResponses];
export type AddProviderApiKeyData = {
    body: {
        apiKey: string;
    };
    path: {
        provider: string;
    };
    query?: never;
    url: '/v1/auth/{provider}';
};
export type AddProviderApiKeyErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type AddProviderApiKeyError = AddProviderApiKeyErrors[keyof AddProviderApiKeyErrors];
export type AddProviderApiKeyResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        provider: string;
        tunnelDisabled?: boolean;
        authRemoved?: boolean;
        error?: string;
    };
};
export type AddProviderApiKeyResponse = AddProviderApiKeyResponses[keyof AddProviderApiKeyResponses];
export type StartOpenAiDeviceFlowData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/auth/openai/device/start';
};
export type StartOpenAiDeviceFlowErrors = {
    /**
     * Server Error
     */
    500: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type StartOpenAiDeviceFlowError = StartOpenAiDeviceFlowErrors[keyof StartOpenAiDeviceFlowErrors];
export type StartOpenAiDeviceFlowResponses = {
    /**
     * OK
     */
    200: {
        sessionId: string;
        userCode: string;
        verificationUri: string;
        interval: number;
    };
};
export type StartOpenAiDeviceFlowResponse = StartOpenAiDeviceFlowResponses[keyof StartOpenAiDeviceFlowResponses];
export type PollOpenAiDeviceFlowData = {
    body: {
        sessionId: string;
    };
    path?: never;
    query?: never;
    url: '/v1/auth/openai/device/poll';
};
export type PollOpenAiDeviceFlowErrors = {
    /**
     * Bad Request
     */
    400: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
    /**
     * Server Error
     */
    500: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type PollOpenAiDeviceFlowError = PollOpenAiDeviceFlowErrors[keyof PollOpenAiDeviceFlowErrors];
export type PollOpenAiDeviceFlowResponses = {
    /**
     * OK
     */
    200: {
        status: 'complete' | 'pending' | 'error';
        error?: string;
    };
};
export type PollOpenAiDeviceFlowResponse = PollOpenAiDeviceFlowResponses[keyof PollOpenAiDeviceFlowResponses];
export type StartXaiDeviceFlowData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/auth/xai/device/start';
};
export type StartXaiDeviceFlowErrors = {
    /**
     * Server Error
     */
    500: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type StartXaiDeviceFlowError = StartXaiDeviceFlowErrors[keyof StartXaiDeviceFlowErrors];
export type StartXaiDeviceFlowResponses = {
    /**
     * OK
     */
    200: {
        sessionId: string;
        userCode: string;
        verificationUri: string;
        interval: number;
    };
};
export type StartXaiDeviceFlowResponse = StartXaiDeviceFlowResponses[keyof StartXaiDeviceFlowResponses];
export type PollXaiDeviceFlowData = {
    body: {
        sessionId: string;
    };
    path?: never;
    query?: never;
    url: '/v1/auth/xai/device/poll';
};
export type PollXaiDeviceFlowErrors = {
    /**
     * Bad Request
     */
    400: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type PollXaiDeviceFlowError = PollXaiDeviceFlowErrors[keyof PollXaiDeviceFlowErrors];
export type PollXaiDeviceFlowResponses = {
    /**
     * OK
     */
    200: {
        status: 'complete' | 'pending' | 'error';
        error?: string;
    };
};
export type PollXaiDeviceFlowResponse = PollXaiDeviceFlowResponses[keyof PollXaiDeviceFlowResponses];
export type StartOttoRouterDeviceFlowData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/auth/ottorouter/device/start';
};
export type StartOttoRouterDeviceFlowErrors = {
    /**
     * Server Error
     */
    500: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type StartOttoRouterDeviceFlowError = StartOttoRouterDeviceFlowErrors[keyof StartOttoRouterDeviceFlowErrors];
export type StartOttoRouterDeviceFlowResponses = {
    /**
     * OK
     */
    200: {
        sessionId: string;
        userCode: string;
        verificationUri: string;
        interval: number;
    };
};
export type StartOttoRouterDeviceFlowResponse = StartOttoRouterDeviceFlowResponses[keyof StartOttoRouterDeviceFlowResponses];
export type PollOttoRouterDeviceFlowData = {
    body: {
        sessionId: string;
    };
    path?: never;
    query?: never;
    url: '/v1/auth/ottorouter/device/poll';
};
export type PollOttoRouterDeviceFlowErrors = {
    /**
     * Bad Request
     */
    400: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
    /**
     * Server Error
     */
    500: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type PollOttoRouterDeviceFlowError = PollOttoRouterDeviceFlowErrors[keyof PollOttoRouterDeviceFlowErrors];
export type PollOttoRouterDeviceFlowResponses = {
    /**
     * OK
     */
    200: {
        status: 'complete' | 'pending' | 'error';
        error?: string;
    };
};
export type PollOttoRouterDeviceFlowResponse = PollOttoRouterDeviceFlowResponses[keyof PollOttoRouterDeviceFlowResponses];
export type GetOAuthUrlData = {
    body?: {
        mode?: 'max' | 'console';
    };
    path: {
        provider: string;
    };
    query?: never;
    url: '/v1/auth/{provider}/oauth/url';
};
export type GetOAuthUrlErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type GetOAuthUrlError = GetOAuthUrlErrors[keyof GetOAuthUrlErrors];
export type GetOAuthUrlResponses = {
    /**
     * OK
     */
    200: {
        url: string;
        sessionId: string;
        provider: string;
    };
};
export type GetOAuthUrlResponse = GetOAuthUrlResponses[keyof GetOAuthUrlResponses];
export type ExchangeOAuthCodeData = {
    body: {
        code: string;
        sessionId: string;
    };
    path: {
        provider: string;
    };
    query?: never;
    url: '/v1/auth/{provider}/oauth/exchange';
};
export type ExchangeOAuthCodeErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type ExchangeOAuthCodeError = ExchangeOAuthCodeErrors[keyof ExchangeOAuthCodeErrors];
export type ExchangeOAuthCodeResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        provider: string;
    };
};
export type ExchangeOAuthCodeResponse = ExchangeOAuthCodeResponses[keyof ExchangeOAuthCodeResponses];
export type StartOAuthData = {
    body?: never;
    path: {
        provider: string;
    };
    query?: {
        mode?: 'max' | 'console';
    };
    url: '/v1/auth/{provider}/oauth/start';
};
export type StartOAuthErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type StartOAuthError = StartOAuthErrors[keyof StartOAuthErrors];
export type OauthCallbackData = {
    body?: never;
    path: {
        provider: string;
    };
    query?: {
        code?: string;
        fragment?: string;
    };
    url: '/v1/auth/{provider}/oauth/callback';
};
export type OauthCallbackResponses = {
    /**
     * HTML response
     */
    200: string;
};
export type OauthCallbackResponse = OauthCallbackResponses[keyof OauthCallbackResponses];
export type StartCopilotDeviceFlowData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/auth/copilot/device/start';
};
export type StartCopilotDeviceFlowResponses = {
    /**
     * OK
     */
    200: {
        sessionId: string;
        userCode: string;
        verificationUri: string;
        interval: number;
    };
};
export type StartCopilotDeviceFlowResponse = StartCopilotDeviceFlowResponses[keyof StartCopilotDeviceFlowResponses];
export type PollCopilotDeviceFlowData = {
    body: {
        sessionId: string;
    };
    path?: never;
    query?: never;
    url: '/v1/auth/copilot/device/poll';
};
export type PollCopilotDeviceFlowErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type PollCopilotDeviceFlowError = PollCopilotDeviceFlowErrors[keyof PollCopilotDeviceFlowErrors];
export type PollCopilotDeviceFlowResponses = {
    /**
     * OK
     */
    200: {
        status: 'complete' | 'pending' | 'error';
        error?: string;
    };
};
export type PollCopilotDeviceFlowResponse = PollCopilotDeviceFlowResponses[keyof PollCopilotDeviceFlowResponses];
export type GetCopilotAuthMethodsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/auth/copilot/methods';
};
export type GetCopilotAuthMethodsResponses = {
    /**
     * OK
     */
    200: {
        oauth: boolean;
        token: boolean;
        ghImport: {
            available: boolean;
            authenticated: boolean;
            reason?: string;
        };
    };
};
export type GetCopilotAuthMethodsResponse = GetCopilotAuthMethodsResponses[keyof GetCopilotAuthMethodsResponses];
export type SaveCopilotTokenData = {
    body: {
        token: string;
    };
    path?: never;
    query?: never;
    url: '/v1/auth/copilot/token';
};
export type SaveCopilotTokenErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type SaveCopilotTokenError = SaveCopilotTokenErrors[keyof SaveCopilotTokenErrors];
export type SaveCopilotTokenResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        provider: string;
        source: 'token' | 'gh';
        modelCount: number;
        hasGpt52Codex: boolean;
        sampleModels: Array<string>;
    };
};
export type SaveCopilotTokenResponse = SaveCopilotTokenResponses[keyof SaveCopilotTokenResponses];
export type ImportCopilotTokenFromGhData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/auth/copilot/gh/import';
};
export type ImportCopilotTokenFromGhErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type ImportCopilotTokenFromGhError = ImportCopilotTokenFromGhErrors[keyof ImportCopilotTokenFromGhErrors];
export type ImportCopilotTokenFromGhResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        provider: string;
        source: 'token' | 'gh';
        modelCount: number;
        hasGpt52Codex: boolean;
        sampleModels: Array<string>;
    };
};
export type ImportCopilotTokenFromGhResponse = ImportCopilotTokenFromGhResponses[keyof ImportCopilotTokenFromGhResponses];
export type GetCopilotDiagnosticsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/auth/copilot/diagnostics';
};
export type GetCopilotDiagnosticsResponses = {
    /**
     * OK
     */
    200: {
        tokenSources: Array<{
            source: 'env' | 'stored';
            configured: boolean;
            modelCount?: number;
            hasGpt52Codex?: boolean;
            sampleModels?: Array<string>;
            restrictedByOrgPolicy?: boolean;
            restrictedOrg?: string;
            restrictionMessage?: string;
            error?: string;
        }>;
        methods: {
            oauth: boolean;
            token: boolean;
            ghImport: {
                available: boolean;
                authenticated: boolean;
                reason?: string;
            };
        };
    };
};
export type GetCopilotDiagnosticsResponse = GetCopilotDiagnosticsResponses[keyof GetCopilotDiagnosticsResponses];
export type GetGitHubStatusData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/github/status';
};
export type GetGitHubStatusResponses = {
    /**
     * OK
     */
    200: {
        connected: boolean;
        user?: {
            login: string;
            name: string | null;
            avatarUrl: string;
        };
    };
};
export type GetGitHubStatusResponse = GetGitHubStatusResponses[keyof GetGitHubStatusResponses];
export type StartGitHubDeviceFlowData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/github/device/start';
};
export type StartGitHubDeviceFlowErrors = {
    /**
     * Server Error
     */
    500: {
        error: string;
    };
};
export type StartGitHubDeviceFlowError = StartGitHubDeviceFlowErrors[keyof StartGitHubDeviceFlowErrors];
export type StartGitHubDeviceFlowResponses = {
    /**
     * OK
     */
    200: {
        sessionId: string;
        userCode: string;
        verificationUri: string;
        interval: number;
        expiresIn: number;
    };
};
export type StartGitHubDeviceFlowResponse = StartGitHubDeviceFlowResponses[keyof StartGitHubDeviceFlowResponses];
export type PollGitHubDeviceFlowData = {
    body: {
        sessionId: string;
    };
    path?: never;
    query?: never;
    url: '/v1/github/device/poll';
};
export type PollGitHubDeviceFlowErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type PollGitHubDeviceFlowError = PollGitHubDeviceFlowErrors[keyof PollGitHubDeviceFlowErrors];
export type PollGitHubDeviceFlowResponses = {
    /**
     * OK
     */
    200: {
        status: 'complete' | 'pending' | 'error';
        user?: {
            login: string;
            name: string | null;
            avatarUrl: string;
        };
        error?: string;
    };
};
export type PollGitHubDeviceFlowResponse = PollGitHubDeviceFlowResponses[keyof PollGitHubDeviceFlowResponses];
export type DisconnectGitHubData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/github';
};
export type DisconnectGitHubResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
    };
};
export type DisconnectGitHubResponse = DisconnectGitHubResponses[keyof DisconnectGitHubResponses];
export type ListGitHubRepositoriesData = {
    body?: never;
    path?: never;
    query?: {
        page?: number;
        search?: string;
    };
    url: '/v1/github/repos';
};
export type ListGitHubRepositoriesErrors = {
    /**
     * Unauthorized
     */
    401: {
        error: string;
    };
};
export type ListGitHubRepositoriesError = ListGitHubRepositoriesErrors[keyof ListGitHubRepositoriesErrors];
export type ListGitHubRepositoriesResponses = {
    /**
     * OK
     */
    200: {
        repos: Array<{
            id: number;
            name: string;
            fullName: string;
            cloneUrl: string;
            private: boolean;
            description: string | null;
        }>;
    };
};
export type ListGitHubRepositoriesResponse = ListGitHubRepositoriesResponses[keyof ListGitHubRepositoriesResponses];
export type CloneGitHubRepositoryData = {
    body: {
        url: string;
        path: string;
    };
    path?: never;
    query?: never;
    url: '/v1/github/clone';
};
export type CloneGitHubRepositoryErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type CloneGitHubRepositoryError = CloneGitHubRepositoryErrors[keyof CloneGitHubRepositoryErrors];
export type CloneGitHubRepositoryResponses = {
    /**
     * OK
     */
    200: {
        path: string;
    };
};
export type CloneGitHubRepositoryResponse = CloneGitHubRepositoryResponses[keyof CloneGitHubRepositoryResponses];
export type StartKimiDeviceFlowData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/auth/kimi/device/start';
};
export type StartKimiDeviceFlowErrors = {
    /**
     * Server Error
     */
    500: {
        error: string;
    };
};
export type StartKimiDeviceFlowError = StartKimiDeviceFlowErrors[keyof StartKimiDeviceFlowErrors];
export type StartKimiDeviceFlowResponses = {
    /**
     * OK
     */
    200: {
        sessionId: string;
        userCode: string;
        verificationUri: string;
        interval: number;
    };
};
export type StartKimiDeviceFlowResponse = StartKimiDeviceFlowResponses[keyof StartKimiDeviceFlowResponses];
export type PollKimiDeviceFlowData = {
    body: {
        sessionId: string;
    };
    path?: never;
    query?: never;
    url: '/v1/auth/kimi/device/poll';
};
export type PollKimiDeviceFlowErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type PollKimiDeviceFlowError = PollKimiDeviceFlowErrors[keyof PollKimiDeviceFlowErrors];
export type PollKimiDeviceFlowResponses = {
    /**
     * OK
     */
    200: {
        status: 'complete' | 'pending' | 'error';
        error?: string;
    };
};
export type PollKimiDeviceFlowResponse = PollKimiDeviceFlowResponses[keyof PollKimiDeviceFlowResponses];
export type CompleteOnboardingData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/auth/onboarding/complete';
};
export type CompleteOnboardingResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
    };
};
export type CompleteOnboardingResponse = CompleteOnboardingResponses[keyof CompleteOnboardingResponses];
export type StartOAuthCallbackProxyData = {
    body: {
        authorizationUrl: string;
        callbackUrl: string;
        remoteBaseUrl: string;
        remoteFlowId: string;
        remoteToken: string;
    };
    path?: never;
    query?: never;
    url: '/v1/oauth/callback-proxies';
};
export type StartOAuthCallbackProxyErrors = {
    /**
     * Callback proxy could not start
     */
    400: {
        error: string;
    };
    /**
     * Local daemon authorization required
     */
    401: {
        error: string;
    };
    /**
     * Remote callback proxy requests are forbidden
     */
    403: {
        error: string;
    };
};
export type StartOAuthCallbackProxyError = StartOAuthCallbackProxyErrors[keyof StartOAuthCallbackProxyErrors];
export type StartOAuthCallbackProxyResponses = {
    /**
     * Callback proxy started
     */
    200: {
        proxyId: string;
        opened: boolean;
    };
};
export type StartOAuthCallbackProxyResponse = StartOAuthCallbackProxyResponses[keyof StartOAuthCallbackProxyResponses];
export type PingTunnelDaemonData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/tunnel/ping';
};
export type PingTunnelDaemonResponses = {
    /**
     * Daemon is reachable
     */
    200: {
        status: 'ok';
    };
};
export type PingTunnelDaemonResponse = PingTunnelDaemonResponses[keyof PingTunnelDaemonResponses];
export type CreateTunnelOwnerChallengeData = {
    body: {
        [key: string]: never;
    };
    path?: never;
    query?: never;
    url: '/v1/tunnel/owner/challenge';
};
export type CreateTunnelOwnerChallengeErrors = {
    /**
     * Rate limited
     */
    429: {
        error: string;
        error_description: string;
    };
};
export type CreateTunnelOwnerChallengeError = CreateTunnelOwnerChallengeErrors[keyof CreateTunnelOwnerChallengeErrors];
export type CreateTunnelOwnerChallengeResponses = {
    /**
     * Owner challenge created
     */
    200: {
        challenge: string;
        device_id: string;
        machine_id: string;
        expires_in: 120;
    };
};
export type CreateTunnelOwnerChallengeResponse = CreateTunnelOwnerChallengeResponses[keyof CreateTunnelOwnerChallengeResponses];
export type CreateTunnelOwnerSessionData = {
    body: {
        assertion: string;
    };
    path?: never;
    query?: never;
    url: '/v1/tunnel/owner/session';
};
export type CreateTunnelOwnerSessionErrors = {
    /**
     * Invalid assertion
     */
    401: {
        error: string;
        error_description: string;
    };
    /**
     * Unknown or expired challenge
     */
    404: {
        error: string;
        error_description: string;
    };
    /**
     * Challenge or assertion replayed
     */
    409: {
        error: string;
        error_description: string;
    };
    /**
     * Rate limited
     */
    429: {
        error: string;
        error_description: string;
    };
};
export type CreateTunnelOwnerSessionError = CreateTunnelOwnerSessionErrors[keyof CreateTunnelOwnerSessionErrors];
export type CreateTunnelOwnerSessionResponses = {
    /**
     * Owner session created
     */
    200: {
        access_token: string;
        token_type: 'Bearer';
        expires_in: 900;
    };
};
export type CreateTunnelOwnerSessionResponse = CreateTunnelOwnerSessionResponses[keyof CreateTunnelOwnerSessionResponses];
export type ListTunnelSharesData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/tunnel/shares';
};
export type ListTunnelSharesResponses = {
    /**
     * Active project shares
     */
    200: {
        shares: Array<{
            id: string;
            projectId: string;
            token: string;
            url: string;
            createdAt: number;
        }>;
    };
};
export type ListTunnelSharesResponse = ListTunnelSharesResponses[keyof ListTunnelSharesResponses];
export type CreateTunnelShareData = {
    body: {
        projectId: string;
    };
    path?: never;
    query?: never;
    url: '/v1/tunnel/shares';
};
export type CreateTunnelShareErrors = {
    /**
     * No active public tunnel
     */
    409: {
        ok?: false;
        error: string;
    };
};
export type CreateTunnelShareError = CreateTunnelShareErrors[keyof CreateTunnelShareErrors];
export type CreateTunnelShareResponses = {
    /**
     * Project share created
     */
    200: {
        id: string;
        projectId: string;
        token: string;
        url: string;
        createdAt: number;
    };
};
export type CreateTunnelShareResponse = CreateTunnelShareResponses[keyof CreateTunnelShareResponses];
export type RevokeTunnelShareData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/tunnel/shares/{id}';
};
export type RevokeTunnelShareErrors = {
    /**
     * Project share not found
     */
    404: {
        ok?: false;
        error: string;
    };
};
export type RevokeTunnelShareError = RevokeTunnelShareErrors[keyof RevokeTunnelShareErrors];
export type RevokeTunnelShareResponses = {
    /**
     * Project share revoked
     */
    200: {
        ok: true;
    };
};
export type RevokeTunnelShareResponse = RevokeTunnelShareResponses[keyof RevokeTunnelShareResponses];
export type GetTunnelStatusData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Tunnel mode to inspect. Defaults to quick.
         */
        mode?: 'managed' | 'quick';
        /**
         * Tunnel scope to inspect or stream. Defaults to remote-control.
         */
        scope?: 'remote-control' | 'project-share';
        /**
         * Required when scope is project-share.
         */
        projectId?: string;
    };
    url: '/v1/tunnel/status';
};
export type GetTunnelStatusResponses = {
    /**
     * OK
     */
    200: {
        mode: 'managed' | 'quick';
        scope: 'remote-control' | 'project-share';
        projectId: string | null;
        status: 'idle' | 'starting' | 'connected' | 'error';
        url: string | null;
        error: string | null;
        binaryInstalled: boolean;
        isRunning: boolean;
        hostname: string | null;
        ottorouterConnected: boolean;
    };
};
export type GetTunnelStatusResponse = GetTunnelStatusResponses[keyof GetTunnelStatusResponses];
export type StartTunnelData = {
    body?: {
        port?: number;
        mode?: 'managed' | 'quick';
        scope?: 'remote-control' | 'project-share';
        projectId?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/tunnel/start';
};
export type StartTunnelErrors = {
    /**
     * Tunnel failed to start
     */
    500: {
        ok: boolean;
        mode?: 'managed' | 'quick';
        scope?: 'remote-control' | 'project-share';
        projectId?: string | null;
        url?: string | null;
        message?: string;
        code?: string;
        error?: string;
    };
};
export type StartTunnelError = StartTunnelErrors[keyof StartTunnelErrors];
export type StartTunnelResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        mode?: 'managed' | 'quick';
        scope?: 'remote-control' | 'project-share';
        projectId?: string | null;
        url?: string | null;
        message?: string;
        code?: string;
        error?: string;
    };
};
export type StartTunnelResponse = StartTunnelResponses[keyof StartTunnelResponses];
export type RegisterTunnelData = {
    body: {
        url: string;
        scope?: 'remote-control' | 'project-share';
        projectId?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/tunnel/register';
};
export type RegisterTunnelErrors = {
    /**
     * Bad Request
     */
    400: {
        ok?: false;
        error: string;
    };
};
export type RegisterTunnelError = RegisterTunnelErrors[keyof RegisterTunnelErrors];
export type RegisterTunnelResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        mode?: 'managed' | 'quick';
        scope?: 'remote-control' | 'project-share';
        projectId?: string | null;
        url?: string | null;
        message?: string;
        code?: string;
        error?: string;
    };
};
export type RegisterTunnelResponse = RegisterTunnelResponses[keyof RegisterTunnelResponses];
export type StopTunnelData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Tunnel mode to inspect. Defaults to quick.
         */
        mode?: 'managed' | 'quick';
        /**
         * Tunnel scope to inspect or stream. Defaults to remote-control.
         */
        scope?: 'remote-control' | 'project-share';
        /**
         * Required when scope is project-share.
         */
        projectId?: string;
    };
    url: '/v1/tunnel/stop';
};
export type StopTunnelErrors = {
    /**
     * Tunnel failed to stop
     */
    500: {
        ok: boolean;
        mode?: 'managed' | 'quick';
        scope?: 'remote-control' | 'project-share';
        projectId?: string | null;
        url?: string | null;
        message?: string;
        code?: string;
        error?: string;
    };
};
export type StopTunnelError = StopTunnelErrors[keyof StopTunnelErrors];
export type StopTunnelResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        mode?: 'managed' | 'quick';
        scope?: 'remote-control' | 'project-share';
        projectId?: string | null;
        url?: string | null;
        message?: string;
        code?: string;
        error?: string;
    };
};
export type StopTunnelResponse = StopTunnelResponses[keyof StopTunnelResponses];
export type GetTunnelQrData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Tunnel mode to inspect. Defaults to quick.
         */
        mode?: 'managed' | 'quick';
        /**
         * Tunnel scope to inspect or stream. Defaults to remote-control.
         */
        scope?: 'remote-control' | 'project-share';
        /**
         * Required when scope is project-share.
         */
        projectId?: string;
    };
    url: '/v1/tunnel/qr';
};
export type GetTunnelQrErrors = {
    /**
     * Bad Request
     */
    400: {
        ok?: false;
        error: string;
    };
};
export type GetTunnelQrError = GetTunnelQrErrors[keyof GetTunnelQrErrors];
export type GetTunnelQrResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        mode?: 'managed' | 'quick';
        scope?: 'remote-control' | 'project-share';
        projectId?: string | null;
        url?: string;
        qrCode?: string;
        error?: string;
    };
};
export type GetTunnelQrResponse = GetTunnelQrResponses[keyof GetTunnelQrResponses];
export type SubscribeTunnelStreamData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Tunnel mode to inspect. Defaults to quick.
         */
        mode?: 'managed' | 'quick';
        /**
         * Tunnel scope to inspect or stream. Defaults to remote-control.
         */
        scope?: 'remote-control' | 'project-share';
        /**
         * Required when scope is project-share.
         */
        projectId?: string;
    };
    url: '/v1/tunnel/stream';
};
export type SubscribeTunnelStreamResponses = {
    /**
     * SSE stream of tunnel status updates
     */
    200: string;
};
export type SubscribeTunnelStreamResponse = SubscribeTunnelStreamResponses[keyof SubscribeTunnelStreamResponses];
export type SubscribeTunnelStreamPostData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Tunnel mode to inspect. Defaults to quick.
         */
        mode?: 'managed' | 'quick';
        /**
         * Tunnel scope to inspect or stream. Defaults to remote-control.
         */
        scope?: 'remote-control' | 'project-share';
        /**
         * Required when scope is project-share.
         */
        projectId?: string;
    };
    url: '/v1/tunnel/stream';
};
export type SubscribeTunnelStreamPostResponses = {
    /**
     * SSE stream of tunnel status updates
     */
    200: string;
};
export type SubscribeTunnelStreamPostResponse = SubscribeTunnelStreamPostResponses[keyof SubscribeTunnelStreamPostResponses];
export type ListMcpServersData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/mcp/servers';
};
export type ListMcpServersResponses = {
    /**
     * OK
     */
    200: {
        servers: Array<McpServer>;
    };
};
export type ListMcpServersResponse = ListMcpServersResponses[keyof ListMcpServersResponses];
export type AddMcpServerData = {
    body: {
        name: string;
        transport?: 'stdio' | 'http' | 'sse';
        command?: string;
        args?: Array<string>;
        env?: {
            [key: string]: string;
        };
        url?: string;
        headers?: {
            [key: string]: string;
        };
        oauth?: {
            [key: string]: unknown;
        };
        scope?: 'global' | 'project';
    };
    path?: never;
    query?: never;
    url: '/v1/mcp/servers';
};
export type AddMcpServerErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type AddMcpServerError = AddMcpServerErrors[keyof AddMcpServerErrors];
export type AddMcpServerResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        error?: string;
    };
};
export type AddMcpServerResponse = AddMcpServerResponses[keyof AddMcpServerResponses];
export type RemoveMcpServerData = {
    body?: never;
    path: {
        /**
         * MCP server name
         */
        name: string;
    };
    query?: never;
    url: '/v1/mcp/servers/{name}';
};
export type RemoveMcpServerErrors = {
    /**
     * Not Found
     */
    404: {
        error: string;
    };
};
export type RemoveMcpServerError = RemoveMcpServerErrors[keyof RemoveMcpServerErrors];
export type RemoveMcpServerResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        error?: string;
    };
};
export type RemoveMcpServerResponse = RemoveMcpServerResponses[keyof RemoveMcpServerResponses];
export type StartMcpServerData = {
    body?: never;
    path: {
        /**
         * MCP server name
         */
        name: string;
    };
    query?: never;
    url: '/v1/mcp/servers/{name}/start';
};
export type StartMcpServerErrors = {
    /**
     * Not Found
     */
    404: {
        error: string;
    };
};
export type StartMcpServerError = StartMcpServerErrors[keyof StartMcpServerErrors];
export type StartMcpServerResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        name?: string;
        connected?: boolean;
        tools?: Array<{
            name?: string;
            description?: string;
        }>;
        authRequired?: boolean;
        authType?: string;
        sessionId?: string;
        userCode?: string;
        verificationUri?: string;
        interval?: number;
        authUrl?: string;
        flowId?: string;
        callbackUrl?: string;
        expiresAt?: number;
        callbackMode?: 'daemon-loopback' | 'client-relay';
        error?: string;
    };
};
export type StartMcpServerResponse = StartMcpServerResponses[keyof StartMcpServerResponses];
export type StopMcpServerData = {
    body?: never;
    path: {
        /**
         * MCP server name
         */
        name: string;
    };
    query?: never;
    url: '/v1/mcp/servers/{name}/stop';
};
export type StopMcpServerErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type StopMcpServerError = StopMcpServerErrors[keyof StopMcpServerErrors];
export type StopMcpServerResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        error?: string;
    };
};
export type StopMcpServerResponse = StopMcpServerResponses[keyof StopMcpServerResponses];
export type TestMcpServerData = {
    body?: never;
    path: {
        /**
         * MCP server name
         */
        name: string;
    };
    query?: never;
    url: '/v1/mcp/servers/{name}/test';
};
export type TestMcpServerErrors = {
    /**
     * Not Found
     */
    404: {
        error: string;
    };
};
export type TestMcpServerError = TestMcpServerErrors[keyof TestMcpServerErrors];
export type TestMcpServerResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        name?: string;
        connected?: boolean;
        tools?: Array<{
            name?: string;
            description?: string;
        }>;
        authRequired?: boolean;
        authType?: string;
        sessionId?: string;
        userCode?: string;
        verificationUri?: string;
        interval?: number;
        authUrl?: string;
        flowId?: string;
        callbackUrl?: string;
        expiresAt?: number;
        callbackMode?: 'daemon-loopback' | 'client-relay';
        error?: string;
    };
};
export type TestMcpServerResponse = TestMcpServerResponses[keyof TestMcpServerResponses];
export type CompleteMcpAuthFlowData = {
    body: {
        code?: string;
        state?: string;
        error?: string;
        errorDescription?: string;
    };
    path: {
        flowId: string;
    };
    query?: never;
    url: '/v1/mcp/oauth/flows/{flowId}/complete';
};
export type CompleteMcpAuthFlowErrors = {
    /**
     * OAuth flow rejected
     */
    400: {
        error: string;
    };
    /**
     * Machine owner authorization required
     */
    401: {
        error: string;
    };
};
export type CompleteMcpAuthFlowError = CompleteMcpAuthFlowErrors[keyof CompleteMcpAuthFlowErrors];
export type CompleteMcpAuthFlowResponses = {
    /**
     * OAuth flow completed
     */
    200: {
        ok: boolean;
        name?: string;
        authUrl?: string;
        flowId?: string;
        callbackUrl?: string;
        expiresAt?: number;
        callbackMode?: 'daemon-loopback' | 'client-relay';
        authType?: string;
        authenticated?: boolean;
        sessionId?: string;
        userCode?: string;
        verificationUri?: string;
        interval?: number;
        message?: string;
        status?: 'complete' | 'pending' | 'error';
        connected?: boolean;
        tools?: Array<{
            name?: string;
            description?: string;
        }>;
        error?: string;
    };
};
export type CompleteMcpAuthFlowResponse = CompleteMcpAuthFlowResponses[keyof CompleteMcpAuthFlowResponses];
export type RevokeMcpAuthData = {
    body?: never;
    path: {
        /**
         * MCP server name
         */
        name: string;
    };
    query?: never;
    url: '/v1/mcp/servers/{name}/auth';
};
export type RevokeMcpAuthErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type RevokeMcpAuthError = RevokeMcpAuthErrors[keyof RevokeMcpAuthErrors];
export type RevokeMcpAuthResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        error?: string;
    };
};
export type RevokeMcpAuthResponse = RevokeMcpAuthResponses[keyof RevokeMcpAuthResponses];
export type InitiateMcpAuthData = {
    body?: never;
    path: {
        /**
         * MCP server name
         */
        name: string;
    };
    query?: never;
    url: '/v1/mcp/servers/{name}/auth';
};
export type InitiateMcpAuthErrors = {
    /**
     * Not Found
     */
    404: {
        error: string;
    };
};
export type InitiateMcpAuthError = InitiateMcpAuthErrors[keyof InitiateMcpAuthErrors];
export type InitiateMcpAuthResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        name?: string;
        authUrl?: string;
        flowId?: string;
        callbackUrl?: string;
        expiresAt?: number;
        callbackMode?: 'daemon-loopback' | 'client-relay';
        authType?: string;
        authenticated?: boolean;
        sessionId?: string;
        userCode?: string;
        verificationUri?: string;
        interval?: number;
        message?: string;
        status?: 'complete' | 'pending' | 'error';
        connected?: boolean;
        tools?: Array<{
            name?: string;
            description?: string;
        }>;
        error?: string;
    };
};
export type InitiateMcpAuthResponse = InitiateMcpAuthResponses[keyof InitiateMcpAuthResponses];
export type CompleteMcpAuthData = {
    body: {
        code?: string;
        sessionId?: string;
    };
    path: {
        /**
         * MCP server name
         */
        name: string;
    };
    query?: never;
    url: '/v1/mcp/servers/{name}/auth/callback';
};
export type CompleteMcpAuthErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
};
export type CompleteMcpAuthError = CompleteMcpAuthErrors[keyof CompleteMcpAuthErrors];
export type CompleteMcpAuthResponses = {
    /**
     * OK
     */
    200: {
        ok: boolean;
        name?: string;
        authUrl?: string;
        flowId?: string;
        callbackUrl?: string;
        expiresAt?: number;
        callbackMode?: 'daemon-loopback' | 'client-relay';
        authType?: string;
        authenticated?: boolean;
        sessionId?: string;
        userCode?: string;
        verificationUri?: string;
        interval?: number;
        message?: string;
        status?: 'complete' | 'pending' | 'error';
        connected?: boolean;
        tools?: Array<{
            name?: string;
            description?: string;
        }>;
        error?: string;
    };
};
export type CompleteMcpAuthResponse = CompleteMcpAuthResponses[keyof CompleteMcpAuthResponses];
export type GetMcpAuthStatusData = {
    body?: never;
    path: {
        /**
         * MCP server name
         */
        name: string;
    };
    query?: never;
    url: '/v1/mcp/servers/{name}/auth/status';
};
export type GetMcpAuthStatusResponses = {
    /**
     * OK
     */
    200: {
        authenticated: boolean;
        authType?: string;
    };
};
export type GetMcpAuthStatusResponse = GetMcpAuthStatusResponses[keyof GetMcpAuthStatusResponses];
export type GetProviderUsageData = {
    body?: never;
    path: {
        provider: 'anthropic' | 'openai' | 'xai' | 'kimi';
    };
    query?: never;
    url: '/v1/provider-usage/{provider}';
};
export type GetProviderUsageErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string | {
            message: string;
        };
    };
    /**
     * Not Found
     */
    404: {
        error: string | {
            message: string;
        };
    };
};
export type GetProviderUsageError = GetProviderUsageErrors[keyof GetProviderUsageErrors];
export type GetProviderUsageResponses = {
    /**
     * OK
     */
    200: {
        provider: string;
        primaryWindow?: {
            usedPercent?: number;
            windowSeconds?: number;
            resetsAt?: string | null;
            resetAfterSeconds?: number;
        } | null;
        secondaryWindow?: {
            usedPercent?: number;
            windowSeconds?: number;
            resetsAt?: string | null;
            resetAfterSeconds?: number;
        } | null;
        limitReached: boolean;
        planType?: string | null;
    };
};
export type GetProviderUsageResponse = GetProviderUsageResponses[keyof GetProviderUsageResponses];
export type RunDoctorData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/doctor';
};
export type RunDoctorErrors = {
    /**
     * Bad Request
     */
    500: {
        error: string;
    };
};
export type RunDoctorError = RunDoctorErrors[keyof RunDoctorErrors];
export type RunDoctorResponses = {
    /**
     * OK
     */
    200: {
        providers: Array<{
            id: string;
            ok: boolean;
            configured: boolean;
            sources: Array<string>;
        }>;
        defaults: {
            agent: string;
            provider: string;
            model: string;
            providerAuthorized: boolean;
        };
        agents: {
            globalPath: string | null;
            localPath: string | null;
            globalNames: Array<string>;
            localNames: Array<string>;
        };
        tools: {
            builtInNames: Array<string>;
            extensionNames: Array<string>;
            effectiveNames: Array<string>;
        };
        commands: {
            globalPath?: string | null;
            globalNames: Array<string>;
            localPath?: string | null;
            localNames: Array<string>;
        };
        issues: Array<string>;
        suggestions: Array<string>;
        globalAuthPath?: string | null;
    };
};
export type RunDoctorResponse = RunDoctorResponses[keyof RunDoctorResponses];
export type GetDebugRuntimeData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/debug/runtime';
};
export type GetDebugRuntimeResponses = {
    /**
     * OK
     */
    200: {
        pid: number;
        uptimeSeconds: number;
        memory: {
            rssMb: number;
            heapUsedMb: number;
            heapTotalMb: number;
            externalMb: number;
            arrayBuffersMb: number;
        };
        sse: {
            activeProjectStreams: number;
            droppedProjectStreams: number;
            bytesQueued: number;
            oversizedEvents: number;
            replay: {
                keys: number;
                events: number;
                bytes: number;
                replayedEvents: number;
                replayMisses: number;
            };
        };
        bus: {
            sessionKeys: number;
            sessionSubscribers: number;
            projectSubscribers: number;
            clientSubscribers: number;
            desktopSubscribers: number;
            topSessionKeys: Array<{
                key: string;
                subscribers: number;
            }>;
        };
        queue: {
            runnerStates: number;
            runningRunners: number;
            queuedMessages: number;
            messageAbortControllers: number;
        };
        projects: {
            open: number;
            items: Array<{
                id: string;
                name: string;
                lastUsedAt: number;
            }>;
        };
    };
};
export type GetDebugRuntimeResponse = GetDebugRuntimeResponses[keyof GetDebugRuntimeResponses];
export type ListSkillsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/skills';
};
export type ListSkillsErrors = {
    /**
     * Bad Request
     */
    500: {
        error: string;
    };
};
export type ListSkillsError = ListSkillsErrors[keyof ListSkillsErrors];
export type ListSkillsResponses = {
    /**
     * OK
     */
    200: {
        skills: Array<{
            name: string;
            description: string;
            scope: string;
            path: string;
        }>;
    };
};
export type ListSkillsResponse = ListSkillsResponses[keyof ListSkillsResponses];
export type GetSkillsConfigData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/skills';
};
export type GetSkillsConfigErrors = {
    /**
     * Bad Request
     */
    500: {
        error: string;
    };
};
export type GetSkillsConfigError = GetSkillsConfigErrors[keyof GetSkillsConfigErrors];
export type GetSkillsConfigResponses = {
    /**
     * OK
     */
    200: {
        enabled: boolean;
        totalCount: number;
        enabledCount: number;
        items: Array<{
            name: string;
            description: string;
            scope: string;
            path: string;
            enabled: boolean;
        }>;
    };
};
export type GetSkillsConfigResponse = GetSkillsConfigResponses[keyof GetSkillsConfigResponses];
export type UpdateSkillsConfigData = {
    body: {
        enabled?: boolean;
        items?: {
            [key: string]: {
                enabled?: boolean;
            };
        };
    };
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/config/skills';
};
export type UpdateSkillsConfigErrors = {
    /**
     * Bad Request
     */
    500: {
        error: string;
    };
};
export type UpdateSkillsConfigError = UpdateSkillsConfigErrors[keyof UpdateSkillsConfigErrors];
export type UpdateSkillsConfigResponses = {
    /**
     * OK
     */
    200: {
        enabled: boolean;
        totalCount: number;
        enabledCount: number;
        items: Array<{
            name: string;
            description: string;
            scope: string;
            path: string;
            enabled: boolean;
        }>;
        success: boolean;
    };
};
export type UpdateSkillsConfigResponse = UpdateSkillsConfigResponses[keyof UpdateSkillsConfigResponses];
export type GetSkillData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/skills/{name}';
};
export type GetSkillErrors = {
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
    /**
     * Bad Request
     */
    500: {
        error: string;
    };
};
export type GetSkillError = GetSkillErrors[keyof GetSkillErrors];
export type GetSkillResponses = {
    /**
     * OK
     */
    200: {
        name: string;
        description: string;
        license?: string | null;
        compatibility?: string | null;
        metadata?: {
            [key: string]: unknown;
        } | null;
        allowedTools?: Array<string> | null;
        path: string;
        scope: string;
        content: string;
    };
};
export type GetSkillResponse = GetSkillResponses[keyof GetSkillResponses];
export type ListSkillFilesData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/skills/{name}/files';
};
export type ListSkillFilesErrors = {
    /**
     * Bad Request
     */
    500: {
        error: string;
    };
};
export type ListSkillFilesError = ListSkillFilesErrors[keyof ListSkillFilesErrors];
export type ListSkillFilesResponses = {
    /**
     * OK
     */
    200: {
        files: Array<{
            relativePath: string;
            size: number;
        }>;
    };
};
export type ListSkillFilesResponse = ListSkillFilesResponses[keyof ListSkillFilesResponses];
export type GetSkillFileData = {
    body?: never;
    path: {
        name: string;
        filePath: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/skills/{name}/files/{filePath}';
};
export type GetSkillFileErrors = {
    /**
     * Bad Request
     */
    404: {
        error: string;
    };
    /**
     * Bad Request
     */
    500: {
        error: string;
    };
};
export type GetSkillFileError = GetSkillFileErrors[keyof GetSkillFileErrors];
export type GetSkillFileResponses = {
    /**
     * OK
     */
    200: {
        content: string;
        path: string;
    };
};
export type GetSkillFileResponse = GetSkillFileResponses[keyof GetSkillFileResponses];
export type ValidateSkillData = {
    body: {
        content: string;
        path?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/skills/validate';
};
export type ValidateSkillResponses = {
    /**
     * OK
     */
    200: {
        valid: boolean;
        name?: string;
        description?: string;
        license?: string | null;
        error?: string;
    };
};
export type ValidateSkillResponse = ValidateSkillResponses[keyof ValidateSkillResponses];
export type ValidateSkillNameData = {
    body?: never;
    path: {
        name: string;
    };
    query?: never;
    url: '/v1/skills/validate-name/{name}';
};
export type ValidateSkillNameResponses = {
    /**
     * OK
     */
    200: {
        valid: boolean;
    };
};
export type ValidateSkillNameResponse = ValidateSkillNameResponses[keyof ValidateSkillNameResponses];
export type ListRecipesData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Recipe scope filter. Defaults to all for listing project and global recipes.
         */
        scope?: 'all' | 'project' | 'global';
    };
    url: '/v1/recipes';
};
export type ListRecipesErrors = {
    /**
     * Server error
     */
    500: {
        error: string;
    };
};
export type ListRecipesError = ListRecipesErrors[keyof ListRecipesErrors];
export type ListRecipesResponses = {
    /**
     * OK
     */
    200: {
        recipes: Array<{
            name: string;
            scope: 'project' | 'global';
            agent: string;
            includeInHistory: boolean;
            description: string;
            path: string;
            content: string;
            conflict?: {
                reason: 'reserved' | 'duplicate';
                scopes?: Array<'project' | 'global'>;
            };
        }>;
    };
};
export type ListRecipesResponse = ListRecipesResponses[keyof ListRecipesResponses];
export type DeleteRecipeData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Recipe scope. Defaults to project.
         */
        scope?: 'project' | 'global';
    };
    url: '/v1/recipes/{name}';
};
export type DeleteRecipeErrors = {
    /**
     * Invalid name
     */
    400: {
        error: string;
    };
    /**
     * Server error
     */
    500: {
        error: string;
    };
};
export type DeleteRecipeError = DeleteRecipeErrors[keyof DeleteRecipeErrors];
export type DeleteRecipeResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
    };
};
export type DeleteRecipeResponse = DeleteRecipeResponses[keyof DeleteRecipeResponses];
export type GetRecipeData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Recipe scope. Defaults to project.
         */
        scope?: 'project' | 'global';
    };
    url: '/v1/recipes/{name}';
};
export type GetRecipeErrors = {
    /**
     * Invalid name
     */
    400: {
        error: string;
    };
    /**
     * Not found
     */
    404: {
        error: string;
    };
    /**
     * Server error
     */
    500: {
        error: string;
    };
};
export type GetRecipeError = GetRecipeErrors[keyof GetRecipeErrors];
export type GetRecipeResponses = {
    /**
     * OK
     */
    200: {
        name: string;
        scope: 'project' | 'global';
        agent: string;
        includeInHistory: boolean;
        description: string;
        path: string;
        content: string;
        conflict?: {
            reason: 'reserved' | 'duplicate';
            scopes?: Array<'project' | 'global'>;
        };
    };
};
export type GetRecipeResponse = GetRecipeResponses[keyof GetRecipeResponses];
export type UpsertRecipeData = {
    body: {
        content: string;
    };
    path: {
        name: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Recipe scope. Defaults to project.
         */
        scope?: 'project' | 'global';
    };
    url: '/v1/recipes/{name}';
};
export type UpsertRecipeErrors = {
    /**
     * Invalid request
     */
    400: {
        error: string;
    };
    /**
     * Reserved or duplicate recipe name
     */
    409: {
        error: string;
    };
    /**
     * Server error
     */
    500: {
        error: string;
    };
};
export type UpsertRecipeError = UpsertRecipeErrors[keyof UpsertRecipeErrors];
export type UpsertRecipeResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        recipe: {
            name: string;
            scope: 'project' | 'global';
            agent: string;
            includeInHistory: boolean;
            description: string;
            path: string;
            content: string;
            conflict?: {
                reason: 'reserved' | 'duplicate';
                scopes?: Array<'project' | 'global'>;
            };
        } | null;
    };
};
export type UpsertRecipeResponse = UpsertRecipeResponses[keyof UpsertRecipeResponses];
export type ListPluginsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/plugins';
};
export type ListPluginsErrors = {
    /**
     * Invalid request
     */
    400: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type ListPluginsError = ListPluginsErrors[keyof ListPluginsErrors];
export type ListPluginsResponses = {
    /**
     * OK
     */
    200: {
        global: {
            scope: 'global' | 'project';
            configPath: string;
            pluginsDir: string;
            config: {
                $schema?: string;
                version: 1;
                registries: Array<string>;
                plugins: {
                    [key: string]: {
                        enabled: boolean;
                        source?: string;
                        version?: string;
                        installedAt?: string;
                        updatedAt?: string;
                        pinned?: boolean;
                        installedBy?: Array<string>;
                    };
                };
            };
            plugins: Array<{
                name: string;
                scope: 'global' | 'project';
                dir: string;
                manifestPath: string;
                configEntry?: {
                    enabled: boolean;
                    source?: string;
                    version?: string;
                    installedAt?: string;
                    updatedAt?: string;
                    pinned?: boolean;
                    installedBy?: Array<string>;
                };
                enabled: boolean;
                installed: boolean;
                status: 'installed' | 'missing' | 'invalid';
                manifest?: {
                    $schema?: string;
                    name: string;
                    displayName?: string;
                    publisher?: string;
                    version: string;
                    description?: string;
                    homepage?: string;
                    repository?: string;
                    platforms?: Array<'darwin' | 'linux' | 'win32'>;
                    tags?: Array<string>;
                    skills?: Array<{
                        name: string;
                        path?: string;
                        description?: string;
                        source?: {
                            type: 'github';
                            repo: string;
                            ref?: string;
                            path: string;
                            include?: Array<string>;
                            exclude?: Array<string>;
                        } | {
                            type: 'local';
                            path: string;
                            include?: Array<string>;
                            exclude?: Array<string>;
                        } | {
                            type: 'url';
                            url: string;
                        };
                    }>;
                    recipes?: Array<{
                        name: string;
                        path: string;
                        description?: string;
                    }>;
                    agents?: Array<{
                        name: string;
                        path?: string;
                        prompt?: string;
                        description?: string;
                        provider?: string;
                        model?: string;
                        tools?: {
                            firstClass?: Array<string>;
                            loadable?: Array<string>;
                        };
                        appendTools?: {
                            firstClass?: Array<string>;
                            loadable?: Array<string>;
                        };
                    }>;
                    dependencies?: Array<string>;
                    mcpServers?: {
                        [key: string]: unknown;
                    };
                    commands?: {
                        [key: string]: {
                            label?: string;
                            description?: string;
                            command: string;
                            args?: Array<string>;
                            env?: {
                                [key: string]: string;
                            };
                            cwd?: string;
                            parameters?: {
                                [key: string]: {
                                    type: 'string' | 'number' | 'boolean' | 'enum';
                                    description?: string;
                                    required?: boolean;
                                    default?: string | number | boolean;
                                    values?: Array<string>;
                                };
                            };
                            allowExtraArgs?: boolean;
                            fallback?: {
                                label?: string;
                                description?: string;
                                command: string;
                                args?: Array<string>;
                                env?: {
                                    [key: string]: string;
                                };
                                cwd?: string;
                                parameters?: {
                                    [key: string]: {
                                        type: 'string' | 'number' | 'boolean' | 'enum';
                                        description?: string;
                                        required?: boolean;
                                        default?: string | number | boolean;
                                        values?: Array<string>;
                                    };
                                };
                                allowExtraArgs?: boolean;
                            };
                        };
                    };
                    browser?: {
                        previewUrl?: string;
                    };
                    requirements?: Array<{
                        kind: 'platform' | 'command' | 'env' | 'toolchain';
                        value: string;
                        message?: string;
                    }>;
                };
                error?: string;
            }>;
        };
        project: {
            scope: 'global' | 'project';
            configPath: string;
            pluginsDir: string;
            config: {
                $schema?: string;
                version: 1;
                registries: Array<string>;
                plugins: {
                    [key: string]: {
                        enabled: boolean;
                        source?: string;
                        version?: string;
                        installedAt?: string;
                        updatedAt?: string;
                        pinned?: boolean;
                        installedBy?: Array<string>;
                    };
                };
            };
            plugins: Array<{
                name: string;
                scope: 'global' | 'project';
                dir: string;
                manifestPath: string;
                configEntry?: {
                    enabled: boolean;
                    source?: string;
                    version?: string;
                    installedAt?: string;
                    updatedAt?: string;
                    pinned?: boolean;
                    installedBy?: Array<string>;
                };
                enabled: boolean;
                installed: boolean;
                status: 'installed' | 'missing' | 'invalid';
                manifest?: {
                    $schema?: string;
                    name: string;
                    displayName?: string;
                    publisher?: string;
                    version: string;
                    description?: string;
                    homepage?: string;
                    repository?: string;
                    platforms?: Array<'darwin' | 'linux' | 'win32'>;
                    tags?: Array<string>;
                    skills?: Array<{
                        name: string;
                        path?: string;
                        description?: string;
                        source?: {
                            type: 'github';
                            repo: string;
                            ref?: string;
                            path: string;
                            include?: Array<string>;
                            exclude?: Array<string>;
                        } | {
                            type: 'local';
                            path: string;
                            include?: Array<string>;
                            exclude?: Array<string>;
                        } | {
                            type: 'url';
                            url: string;
                        };
                    }>;
                    recipes?: Array<{
                        name: string;
                        path: string;
                        description?: string;
                    }>;
                    agents?: Array<{
                        name: string;
                        path?: string;
                        prompt?: string;
                        description?: string;
                        provider?: string;
                        model?: string;
                        tools?: {
                            firstClass?: Array<string>;
                            loadable?: Array<string>;
                        };
                        appendTools?: {
                            firstClass?: Array<string>;
                            loadable?: Array<string>;
                        };
                    }>;
                    dependencies?: Array<string>;
                    mcpServers?: {
                        [key: string]: unknown;
                    };
                    commands?: {
                        [key: string]: {
                            label?: string;
                            description?: string;
                            command: string;
                            args?: Array<string>;
                            env?: {
                                [key: string]: string;
                            };
                            cwd?: string;
                            parameters?: {
                                [key: string]: {
                                    type: 'string' | 'number' | 'boolean' | 'enum';
                                    description?: string;
                                    required?: boolean;
                                    default?: string | number | boolean;
                                    values?: Array<string>;
                                };
                            };
                            allowExtraArgs?: boolean;
                            fallback?: {
                                label?: string;
                                description?: string;
                                command: string;
                                args?: Array<string>;
                                env?: {
                                    [key: string]: string;
                                };
                                cwd?: string;
                                parameters?: {
                                    [key: string]: {
                                        type: 'string' | 'number' | 'boolean' | 'enum';
                                        description?: string;
                                        required?: boolean;
                                        default?: string | number | boolean;
                                        values?: Array<string>;
                                    };
                                };
                                allowExtraArgs?: boolean;
                            };
                        };
                    };
                    browser?: {
                        previewUrl?: string;
                    };
                    requirements?: Array<{
                        kind: 'platform' | 'command' | 'env' | 'toolchain';
                        value: string;
                        message?: string;
                    }>;
                };
                error?: string;
            }>;
        };
        plugins: Array<{
            name: string;
            scope: 'global' | 'project';
            dir: string;
            manifestPath: string;
            configEntry?: {
                enabled: boolean;
                source?: string;
                version?: string;
                installedAt?: string;
                updatedAt?: string;
                pinned?: boolean;
                installedBy?: Array<string>;
            };
            enabled: boolean;
            installed: boolean;
            status: 'installed' | 'missing' | 'invalid';
            manifest?: {
                $schema?: string;
                name: string;
                displayName?: string;
                publisher?: string;
                version: string;
                description?: string;
                homepage?: string;
                repository?: string;
                platforms?: Array<'darwin' | 'linux' | 'win32'>;
                tags?: Array<string>;
                skills?: Array<{
                    name: string;
                    path?: string;
                    description?: string;
                    source?: {
                        type: 'github';
                        repo: string;
                        ref?: string;
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'local';
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'url';
                        url: string;
                    };
                }>;
                recipes?: Array<{
                    name: string;
                    path: string;
                    description?: string;
                }>;
                agents?: Array<{
                    name: string;
                    path?: string;
                    prompt?: string;
                    description?: string;
                    provider?: string;
                    model?: string;
                    tools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                    appendTools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                }>;
                dependencies?: Array<string>;
                mcpServers?: {
                    [key: string]: unknown;
                };
                commands?: {
                    [key: string]: {
                        label?: string;
                        description?: string;
                        command: string;
                        args?: Array<string>;
                        env?: {
                            [key: string]: string;
                        };
                        cwd?: string;
                        parameters?: {
                            [key: string]: {
                                type: 'string' | 'number' | 'boolean' | 'enum';
                                description?: string;
                                required?: boolean;
                                default?: string | number | boolean;
                                values?: Array<string>;
                            };
                        };
                        allowExtraArgs?: boolean;
                        fallback?: {
                            label?: string;
                            description?: string;
                            command: string;
                            args?: Array<string>;
                            env?: {
                                [key: string]: string;
                            };
                            cwd?: string;
                            parameters?: {
                                [key: string]: {
                                    type: 'string' | 'number' | 'boolean' | 'enum';
                                    description?: string;
                                    required?: boolean;
                                    default?: string | number | boolean;
                                    values?: Array<string>;
                                };
                            };
                            allowExtraArgs?: boolean;
                        };
                    };
                };
                browser?: {
                    previewUrl?: string;
                };
                requirements?: Array<{
                    kind: 'platform' | 'command' | 'env' | 'toolchain';
                    value: string;
                    message?: string;
                }>;
            };
            error?: string;
            overriddenByProject?: boolean;
        }>;
    };
};
export type ListPluginsResponse = ListPluginsResponses[keyof ListPluginsResponses];
export type ListPluginCommandsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/plugins/commands';
};
export type ListPluginCommandsErrors = {
    /**
     * Invalid request
     */
    400: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type ListPluginCommandsError = ListPluginCommandsErrors[keyof ListPluginCommandsErrors];
export type ListPluginCommandsResponses = {
    /**
     * OK
     */
    200: {
        commands: Array<{
            plugin: string;
            command: string;
            label?: string;
            description?: string;
            parameters?: {
                [key: string]: {
                    type: 'string' | 'number' | 'boolean' | 'enum';
                    description?: string;
                    required?: boolean;
                    default?: string | number | boolean;
                    values?: Array<string>;
                };
            };
            allowExtraArgs?: boolean;
            previewUrl?: string;
            scope: 'global' | 'project';
        }>;
    };
};
export type ListPluginCommandsResponse = ListPluginCommandsResponses[keyof ListPluginCommandsResponses];
export type RunPluginCommandData = {
    body: {
        project?: string;
        argsText?: string;
        args?: {
            [key: string]: string | number | boolean;
        };
        extraArgs?: Array<string>;
    };
    path: {
        plugin: string;
        command: string;
    };
    query?: never;
    url: '/v1/plugins/{plugin}/commands/{command}/run';
};
export type RunPluginCommandErrors = {
    /**
     * Invalid request
     */
    400: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
    /**
     * Plugin command not found
     */
    404: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
    /**
     * Terminal execution unavailable
     */
    503: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type RunPluginCommandError = RunPluginCommandErrors[keyof RunPluginCommandErrors];
export type RunPluginCommandResponses = {
    /**
     * Terminal started
     */
    200: {
        command: string;
        terminalId: string;
        title: string;
        previewUrl?: string;
        execution: 'started';
    };
};
export type RunPluginCommandResponse = RunPluginCommandResponses[keyof RunPluginCommandResponses];
export type ListPluginRegistryData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Registry URL override.
         */
        url?: string;
    };
    url: '/v1/plugins/registry';
};
export type ListPluginRegistryErrors = {
    /**
     * Invalid request
     */
    400: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type ListPluginRegistryError = ListPluginRegistryErrors[keyof ListPluginRegistryErrors];
export type ListPluginRegistryResponses = {
    /**
     * OK
     */
    200: {
        registries: Array<string>;
        plugins: Array<{
            name: string;
            displayName?: string;
            publisher?: string;
            version: string;
            description?: string;
            homepage?: string;
            repository?: string;
            platforms?: Array<'darwin' | 'linux' | 'win32'>;
            tags?: Array<string>;
            skills?: Array<{
                name: string;
                path?: string;
                description?: string;
                source?: {
                    type: 'github';
                    repo: string;
                    ref?: string;
                    path: string;
                    include?: Array<string>;
                    exclude?: Array<string>;
                } | {
                    type: 'local';
                    path: string;
                    include?: Array<string>;
                    exclude?: Array<string>;
                } | {
                    type: 'url';
                    url: string;
                };
            }>;
            recipes?: Array<{
                name: string;
                path: string;
                description?: string;
            }>;
            agents?: Array<{
                name: string;
                path?: string;
                prompt?: string;
                description?: string;
                provider?: string;
                model?: string;
                tools?: {
                    firstClass?: Array<string>;
                    loadable?: Array<string>;
                };
                appendTools?: {
                    firstClass?: Array<string>;
                    loadable?: Array<string>;
                };
            }>;
            dependencies?: Array<string>;
            mcpServers?: {
                [key: string]: unknown;
            };
            commands?: {
                [key: string]: {
                    label?: string;
                    description?: string;
                    command: string;
                    args?: Array<string>;
                    env?: {
                        [key: string]: string;
                    };
                    cwd?: string;
                    parameters?: {
                        [key: string]: {
                            type: 'string' | 'number' | 'boolean' | 'enum';
                            description?: string;
                            required?: boolean;
                            default?: string | number | boolean;
                            values?: Array<string>;
                        };
                    };
                    allowExtraArgs?: boolean;
                    fallback?: {
                        label?: string;
                        description?: string;
                        command: string;
                        args?: Array<string>;
                        env?: {
                            [key: string]: string;
                        };
                        cwd?: string;
                        parameters?: {
                            [key: string]: {
                                type: 'string' | 'number' | 'boolean' | 'enum';
                                description?: string;
                                required?: boolean;
                                default?: string | number | boolean;
                                values?: Array<string>;
                            };
                        };
                        allowExtraArgs?: boolean;
                    };
                };
            };
            browser?: {
                previewUrl?: string;
            };
            requirements?: Array<{
                kind: 'platform' | 'command' | 'env' | 'toolchain';
                value: string;
                message?: string;
            }>;
            official?: boolean;
            source?: {
                type: 'github';
                repo: string;
                ref?: string;
                path: string;
            } | {
                type: 'local';
                path: string;
            };
            registryUrl?: string;
        }>;
    };
};
export type ListPluginRegistryResponse = ListPluginRegistryResponses[keyof ListPluginRegistryResponses];
export type GetPluginData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Registry URL override.
         */
        url?: string;
    };
    url: '/v1/plugins/{name}';
};
export type GetPluginErrors = {
    /**
     * Not found
     */
    404: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type GetPluginError = GetPluginErrors[keyof GetPluginErrors];
export type GetPluginResponses = {
    /**
     * OK
     */
    200: {
        plugin?: {
            name: string;
            scope: 'global' | 'project';
            dir: string;
            manifestPath: string;
            configEntry?: {
                enabled: boolean;
                source?: string;
                version?: string;
                installedAt?: string;
                updatedAt?: string;
                pinned?: boolean;
                installedBy?: Array<string>;
            };
            enabled: boolean;
            installed: boolean;
            status: 'installed' | 'missing' | 'invalid';
            manifest?: {
                $schema?: string;
                name: string;
                displayName?: string;
                publisher?: string;
                version: string;
                description?: string;
                homepage?: string;
                repository?: string;
                platforms?: Array<'darwin' | 'linux' | 'win32'>;
                tags?: Array<string>;
                skills?: Array<{
                    name: string;
                    path?: string;
                    description?: string;
                    source?: {
                        type: 'github';
                        repo: string;
                        ref?: string;
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'local';
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'url';
                        url: string;
                    };
                }>;
                recipes?: Array<{
                    name: string;
                    path: string;
                    description?: string;
                }>;
                agents?: Array<{
                    name: string;
                    path?: string;
                    prompt?: string;
                    description?: string;
                    provider?: string;
                    model?: string;
                    tools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                    appendTools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                }>;
                dependencies?: Array<string>;
                mcpServers?: {
                    [key: string]: unknown;
                };
                commands?: {
                    [key: string]: {
                        label?: string;
                        description?: string;
                        command: string;
                        args?: Array<string>;
                        env?: {
                            [key: string]: string;
                        };
                        cwd?: string;
                        parameters?: {
                            [key: string]: {
                                type: 'string' | 'number' | 'boolean' | 'enum';
                                description?: string;
                                required?: boolean;
                                default?: string | number | boolean;
                                values?: Array<string>;
                            };
                        };
                        allowExtraArgs?: boolean;
                        fallback?: {
                            label?: string;
                            description?: string;
                            command: string;
                            args?: Array<string>;
                            env?: {
                                [key: string]: string;
                            };
                            cwd?: string;
                            parameters?: {
                                [key: string]: {
                                    type: 'string' | 'number' | 'boolean' | 'enum';
                                    description?: string;
                                    required?: boolean;
                                    default?: string | number | boolean;
                                    values?: Array<string>;
                                };
                            };
                            allowExtraArgs?: boolean;
                        };
                    };
                };
                browser?: {
                    previewUrl?: string;
                };
                requirements?: Array<{
                    kind: 'platform' | 'command' | 'env' | 'toolchain';
                    value: string;
                    message?: string;
                }>;
            };
            error?: string;
            overriddenByProject?: boolean;
        };
        registry?: {
            name: string;
            displayName?: string;
            publisher?: string;
            version: string;
            description?: string;
            homepage?: string;
            repository?: string;
            platforms?: Array<'darwin' | 'linux' | 'win32'>;
            tags?: Array<string>;
            skills?: Array<{
                name: string;
                path?: string;
                description?: string;
                source?: {
                    type: 'github';
                    repo: string;
                    ref?: string;
                    path: string;
                    include?: Array<string>;
                    exclude?: Array<string>;
                } | {
                    type: 'local';
                    path: string;
                    include?: Array<string>;
                    exclude?: Array<string>;
                } | {
                    type: 'url';
                    url: string;
                };
            }>;
            recipes?: Array<{
                name: string;
                path: string;
                description?: string;
            }>;
            agents?: Array<{
                name: string;
                path?: string;
                prompt?: string;
                description?: string;
                provider?: string;
                model?: string;
                tools?: {
                    firstClass?: Array<string>;
                    loadable?: Array<string>;
                };
                appendTools?: {
                    firstClass?: Array<string>;
                    loadable?: Array<string>;
                };
            }>;
            dependencies?: Array<string>;
            mcpServers?: {
                [key: string]: unknown;
            };
            commands?: {
                [key: string]: {
                    label?: string;
                    description?: string;
                    command: string;
                    args?: Array<string>;
                    env?: {
                        [key: string]: string;
                    };
                    cwd?: string;
                    parameters?: {
                        [key: string]: {
                            type: 'string' | 'number' | 'boolean' | 'enum';
                            description?: string;
                            required?: boolean;
                            default?: string | number | boolean;
                            values?: Array<string>;
                        };
                    };
                    allowExtraArgs?: boolean;
                    fallback?: {
                        label?: string;
                        description?: string;
                        command: string;
                        args?: Array<string>;
                        env?: {
                            [key: string]: string;
                        };
                        cwd?: string;
                        parameters?: {
                            [key: string]: {
                                type: 'string' | 'number' | 'boolean' | 'enum';
                                description?: string;
                                required?: boolean;
                                default?: string | number | boolean;
                                values?: Array<string>;
                            };
                        };
                        allowExtraArgs?: boolean;
                    };
                };
            };
            browser?: {
                previewUrl?: string;
            };
            requirements?: Array<{
                kind: 'platform' | 'command' | 'env' | 'toolchain';
                value: string;
                message?: string;
            }>;
            official?: boolean;
            source?: {
                type: 'github';
                repo: string;
                ref?: string;
                path: string;
            } | {
                type: 'local';
                path: string;
            };
            registryUrl?: string;
        };
    };
};
export type GetPluginResponse = GetPluginResponses[keyof GetPluginResponses];
export type InstallPluginData = {
    body: {
        project?: string;
        url?: string;
        registries?: Array<string>;
        source: string;
        scope?: 'global' | 'project';
        enabled?: boolean;
    };
    path?: never;
    query?: never;
    url: '/v1/plugins/install';
};
export type InstallPluginErrors = {
    /**
     * Invalid request
     */
    400: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type InstallPluginError = InstallPluginErrors[keyof InstallPluginErrors];
export type InstallPluginResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        plugin?: {
            name: string;
            scope: 'global' | 'project';
            dir: string;
            manifestPath: string;
            configEntry?: {
                enabled: boolean;
                source?: string;
                version?: string;
                installedAt?: string;
                updatedAt?: string;
                pinned?: boolean;
                installedBy?: Array<string>;
            };
            enabled: boolean;
            installed: boolean;
            status: 'installed' | 'missing' | 'invalid';
            manifest?: {
                $schema?: string;
                name: string;
                displayName?: string;
                publisher?: string;
                version: string;
                description?: string;
                homepage?: string;
                repository?: string;
                platforms?: Array<'darwin' | 'linux' | 'win32'>;
                tags?: Array<string>;
                skills?: Array<{
                    name: string;
                    path?: string;
                    description?: string;
                    source?: {
                        type: 'github';
                        repo: string;
                        ref?: string;
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'local';
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'url';
                        url: string;
                    };
                }>;
                recipes?: Array<{
                    name: string;
                    path: string;
                    description?: string;
                }>;
                agents?: Array<{
                    name: string;
                    path?: string;
                    prompt?: string;
                    description?: string;
                    provider?: string;
                    model?: string;
                    tools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                    appendTools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                }>;
                dependencies?: Array<string>;
                mcpServers?: {
                    [key: string]: unknown;
                };
                commands?: {
                    [key: string]: {
                        label?: string;
                        description?: string;
                        command: string;
                        args?: Array<string>;
                        env?: {
                            [key: string]: string;
                        };
                        cwd?: string;
                        parameters?: {
                            [key: string]: {
                                type: 'string' | 'number' | 'boolean' | 'enum';
                                description?: string;
                                required?: boolean;
                                default?: string | number | boolean;
                                values?: Array<string>;
                            };
                        };
                        allowExtraArgs?: boolean;
                        fallback?: {
                            label?: string;
                            description?: string;
                            command: string;
                            args?: Array<string>;
                            env?: {
                                [key: string]: string;
                            };
                            cwd?: string;
                            parameters?: {
                                [key: string]: {
                                    type: 'string' | 'number' | 'boolean' | 'enum';
                                    description?: string;
                                    required?: boolean;
                                    default?: string | number | boolean;
                                    values?: Array<string>;
                                };
                            };
                            allowExtraArgs?: boolean;
                        };
                    };
                };
                browser?: {
                    previewUrl?: string;
                };
                requirements?: Array<{
                    kind: 'platform' | 'command' | 'env' | 'toolchain';
                    value: string;
                    message?: string;
                }>;
            };
            error?: string;
        };
    };
};
export type InstallPluginResponse = InstallPluginResponses[keyof InstallPluginResponses];
export type RemovePluginData = {
    body: {
        name: string;
        scope?: 'global' | 'project';
        project?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/plugins/remove';
};
export type RemovePluginErrors = {
    /**
     * Invalid request
     */
    400: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type RemovePluginError = RemovePluginErrors[keyof RemovePluginErrors];
export type RemovePluginResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        plugin?: {
            name: string;
            scope: 'global' | 'project';
            dir: string;
            manifestPath: string;
            configEntry?: {
                enabled: boolean;
                source?: string;
                version?: string;
                installedAt?: string;
                updatedAt?: string;
                pinned?: boolean;
                installedBy?: Array<string>;
            };
            enabled: boolean;
            installed: boolean;
            status: 'installed' | 'missing' | 'invalid';
            manifest?: {
                $schema?: string;
                name: string;
                displayName?: string;
                publisher?: string;
                version: string;
                description?: string;
                homepage?: string;
                repository?: string;
                platforms?: Array<'darwin' | 'linux' | 'win32'>;
                tags?: Array<string>;
                skills?: Array<{
                    name: string;
                    path?: string;
                    description?: string;
                    source?: {
                        type: 'github';
                        repo: string;
                        ref?: string;
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'local';
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'url';
                        url: string;
                    };
                }>;
                recipes?: Array<{
                    name: string;
                    path: string;
                    description?: string;
                }>;
                agents?: Array<{
                    name: string;
                    path?: string;
                    prompt?: string;
                    description?: string;
                    provider?: string;
                    model?: string;
                    tools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                    appendTools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                }>;
                dependencies?: Array<string>;
                mcpServers?: {
                    [key: string]: unknown;
                };
                commands?: {
                    [key: string]: {
                        label?: string;
                        description?: string;
                        command: string;
                        args?: Array<string>;
                        env?: {
                            [key: string]: string;
                        };
                        cwd?: string;
                        parameters?: {
                            [key: string]: {
                                type: 'string' | 'number' | 'boolean' | 'enum';
                                description?: string;
                                required?: boolean;
                                default?: string | number | boolean;
                                values?: Array<string>;
                            };
                        };
                        allowExtraArgs?: boolean;
                        fallback?: {
                            label?: string;
                            description?: string;
                            command: string;
                            args?: Array<string>;
                            env?: {
                                [key: string]: string;
                            };
                            cwd?: string;
                            parameters?: {
                                [key: string]: {
                                    type: 'string' | 'number' | 'boolean' | 'enum';
                                    description?: string;
                                    required?: boolean;
                                    default?: string | number | boolean;
                                    values?: Array<string>;
                                };
                            };
                            allowExtraArgs?: boolean;
                        };
                    };
                };
                browser?: {
                    previewUrl?: string;
                };
                requirements?: Array<{
                    kind: 'platform' | 'command' | 'env' | 'toolchain';
                    value: string;
                    message?: string;
                }>;
            };
            error?: string;
        };
    };
};
export type RemovePluginResponse = RemovePluginResponses[keyof RemovePluginResponses];
export type EnablePluginData = {
    body: {
        name: string;
        scope?: 'global' | 'project';
        project?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/plugins/enable';
};
export type EnablePluginErrors = {
    /**
     * Invalid request
     */
    400: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type EnablePluginError = EnablePluginErrors[keyof EnablePluginErrors];
export type EnablePluginResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        plugin?: {
            name: string;
            scope: 'global' | 'project';
            dir: string;
            manifestPath: string;
            configEntry?: {
                enabled: boolean;
                source?: string;
                version?: string;
                installedAt?: string;
                updatedAt?: string;
                pinned?: boolean;
                installedBy?: Array<string>;
            };
            enabled: boolean;
            installed: boolean;
            status: 'installed' | 'missing' | 'invalid';
            manifest?: {
                $schema?: string;
                name: string;
                displayName?: string;
                publisher?: string;
                version: string;
                description?: string;
                homepage?: string;
                repository?: string;
                platforms?: Array<'darwin' | 'linux' | 'win32'>;
                tags?: Array<string>;
                skills?: Array<{
                    name: string;
                    path?: string;
                    description?: string;
                    source?: {
                        type: 'github';
                        repo: string;
                        ref?: string;
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'local';
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'url';
                        url: string;
                    };
                }>;
                recipes?: Array<{
                    name: string;
                    path: string;
                    description?: string;
                }>;
                agents?: Array<{
                    name: string;
                    path?: string;
                    prompt?: string;
                    description?: string;
                    provider?: string;
                    model?: string;
                    tools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                    appendTools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                }>;
                dependencies?: Array<string>;
                mcpServers?: {
                    [key: string]: unknown;
                };
                commands?: {
                    [key: string]: {
                        label?: string;
                        description?: string;
                        command: string;
                        args?: Array<string>;
                        env?: {
                            [key: string]: string;
                        };
                        cwd?: string;
                        parameters?: {
                            [key: string]: {
                                type: 'string' | 'number' | 'boolean' | 'enum';
                                description?: string;
                                required?: boolean;
                                default?: string | number | boolean;
                                values?: Array<string>;
                            };
                        };
                        allowExtraArgs?: boolean;
                        fallback?: {
                            label?: string;
                            description?: string;
                            command: string;
                            args?: Array<string>;
                            env?: {
                                [key: string]: string;
                            };
                            cwd?: string;
                            parameters?: {
                                [key: string]: {
                                    type: 'string' | 'number' | 'boolean' | 'enum';
                                    description?: string;
                                    required?: boolean;
                                    default?: string | number | boolean;
                                    values?: Array<string>;
                                };
                            };
                            allowExtraArgs?: boolean;
                        };
                    };
                };
                browser?: {
                    previewUrl?: string;
                };
                requirements?: Array<{
                    kind: 'platform' | 'command' | 'env' | 'toolchain';
                    value: string;
                    message?: string;
                }>;
            };
            error?: string;
        };
    };
};
export type EnablePluginResponse = EnablePluginResponses[keyof EnablePluginResponses];
export type DisablePluginData = {
    body: {
        name: string;
        scope?: 'global' | 'project';
        project?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/plugins/disable';
};
export type DisablePluginErrors = {
    /**
     * Invalid request
     */
    400: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type DisablePluginError = DisablePluginErrors[keyof DisablePluginErrors];
export type DisablePluginResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        plugin?: {
            name: string;
            scope: 'global' | 'project';
            dir: string;
            manifestPath: string;
            configEntry?: {
                enabled: boolean;
                source?: string;
                version?: string;
                installedAt?: string;
                updatedAt?: string;
                pinned?: boolean;
                installedBy?: Array<string>;
            };
            enabled: boolean;
            installed: boolean;
            status: 'installed' | 'missing' | 'invalid';
            manifest?: {
                $schema?: string;
                name: string;
                displayName?: string;
                publisher?: string;
                version: string;
                description?: string;
                homepage?: string;
                repository?: string;
                platforms?: Array<'darwin' | 'linux' | 'win32'>;
                tags?: Array<string>;
                skills?: Array<{
                    name: string;
                    path?: string;
                    description?: string;
                    source?: {
                        type: 'github';
                        repo: string;
                        ref?: string;
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'local';
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'url';
                        url: string;
                    };
                }>;
                recipes?: Array<{
                    name: string;
                    path: string;
                    description?: string;
                }>;
                agents?: Array<{
                    name: string;
                    path?: string;
                    prompt?: string;
                    description?: string;
                    provider?: string;
                    model?: string;
                    tools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                    appendTools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                }>;
                dependencies?: Array<string>;
                mcpServers?: {
                    [key: string]: unknown;
                };
                commands?: {
                    [key: string]: {
                        label?: string;
                        description?: string;
                        command: string;
                        args?: Array<string>;
                        env?: {
                            [key: string]: string;
                        };
                        cwd?: string;
                        parameters?: {
                            [key: string]: {
                                type: 'string' | 'number' | 'boolean' | 'enum';
                                description?: string;
                                required?: boolean;
                                default?: string | number | boolean;
                                values?: Array<string>;
                            };
                        };
                        allowExtraArgs?: boolean;
                        fallback?: {
                            label?: string;
                            description?: string;
                            command: string;
                            args?: Array<string>;
                            env?: {
                                [key: string]: string;
                            };
                            cwd?: string;
                            parameters?: {
                                [key: string]: {
                                    type: 'string' | 'number' | 'boolean' | 'enum';
                                    description?: string;
                                    required?: boolean;
                                    default?: string | number | boolean;
                                    values?: Array<string>;
                                };
                            };
                            allowExtraArgs?: boolean;
                        };
                    };
                };
                browser?: {
                    previewUrl?: string;
                };
                requirements?: Array<{
                    kind: 'platform' | 'command' | 'env' | 'toolchain';
                    value: string;
                    message?: string;
                }>;
            };
            error?: string;
        };
    };
};
export type DisablePluginResponse = DisablePluginResponses[keyof DisablePluginResponses];
export type UpdatePluginData = {
    body: {
        project?: string;
        url?: string;
        registries?: Array<string>;
        name?: string;
        scope?: 'global' | 'project';
    };
    path?: never;
    query?: never;
    url: '/v1/plugins/update';
};
export type UpdatePluginErrors = {
    /**
     * Invalid request
     */
    400: {
        error: {
            message: string;
            type: string;
            code?: string;
            status?: number;
            details?: {
                [key: string]: unknown;
            };
            stack?: string;
        };
    };
};
export type UpdatePluginError = UpdatePluginErrors[keyof UpdatePluginErrors];
export type UpdatePluginResponses = {
    /**
     * OK
     */
    200: {
        success: boolean;
        plugin?: {
            name: string;
            scope: 'global' | 'project';
            dir: string;
            manifestPath: string;
            configEntry?: {
                enabled: boolean;
                source?: string;
                version?: string;
                installedAt?: string;
                updatedAt?: string;
                pinned?: boolean;
                installedBy?: Array<string>;
            };
            enabled: boolean;
            installed: boolean;
            status: 'installed' | 'missing' | 'invalid';
            manifest?: {
                $schema?: string;
                name: string;
                displayName?: string;
                publisher?: string;
                version: string;
                description?: string;
                homepage?: string;
                repository?: string;
                platforms?: Array<'darwin' | 'linux' | 'win32'>;
                tags?: Array<string>;
                skills?: Array<{
                    name: string;
                    path?: string;
                    description?: string;
                    source?: {
                        type: 'github';
                        repo: string;
                        ref?: string;
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'local';
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'url';
                        url: string;
                    };
                }>;
                recipes?: Array<{
                    name: string;
                    path: string;
                    description?: string;
                }>;
                agents?: Array<{
                    name: string;
                    path?: string;
                    prompt?: string;
                    description?: string;
                    provider?: string;
                    model?: string;
                    tools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                    appendTools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                }>;
                dependencies?: Array<string>;
                mcpServers?: {
                    [key: string]: unknown;
                };
                commands?: {
                    [key: string]: {
                        label?: string;
                        description?: string;
                        command: string;
                        args?: Array<string>;
                        env?: {
                            [key: string]: string;
                        };
                        cwd?: string;
                        parameters?: {
                            [key: string]: {
                                type: 'string' | 'number' | 'boolean' | 'enum';
                                description?: string;
                                required?: boolean;
                                default?: string | number | boolean;
                                values?: Array<string>;
                            };
                        };
                        allowExtraArgs?: boolean;
                        fallback?: {
                            label?: string;
                            description?: string;
                            command: string;
                            args?: Array<string>;
                            env?: {
                                [key: string]: string;
                            };
                            cwd?: string;
                            parameters?: {
                                [key: string]: {
                                    type: 'string' | 'number' | 'boolean' | 'enum';
                                    description?: string;
                                    required?: boolean;
                                    default?: string | number | boolean;
                                    values?: Array<string>;
                                };
                            };
                            allowExtraArgs?: boolean;
                        };
                    };
                };
                browser?: {
                    previewUrl?: string;
                };
                requirements?: Array<{
                    kind: 'platform' | 'command' | 'env' | 'toolchain';
                    value: string;
                    message?: string;
                }>;
            };
            error?: string;
        };
        plugins?: Array<{
            name: string;
            scope: 'global' | 'project';
            dir: string;
            manifestPath: string;
            configEntry?: {
                enabled: boolean;
                source?: string;
                version?: string;
                installedAt?: string;
                updatedAt?: string;
                pinned?: boolean;
                installedBy?: Array<string>;
            };
            enabled: boolean;
            installed: boolean;
            status: 'installed' | 'missing' | 'invalid';
            manifest?: {
                $schema?: string;
                name: string;
                displayName?: string;
                publisher?: string;
                version: string;
                description?: string;
                homepage?: string;
                repository?: string;
                platforms?: Array<'darwin' | 'linux' | 'win32'>;
                tags?: Array<string>;
                skills?: Array<{
                    name: string;
                    path?: string;
                    description?: string;
                    source?: {
                        type: 'github';
                        repo: string;
                        ref?: string;
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'local';
                        path: string;
                        include?: Array<string>;
                        exclude?: Array<string>;
                    } | {
                        type: 'url';
                        url: string;
                    };
                }>;
                recipes?: Array<{
                    name: string;
                    path: string;
                    description?: string;
                }>;
                agents?: Array<{
                    name: string;
                    path?: string;
                    prompt?: string;
                    description?: string;
                    provider?: string;
                    model?: string;
                    tools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                    appendTools?: {
                        firstClass?: Array<string>;
                        loadable?: Array<string>;
                    };
                }>;
                dependencies?: Array<string>;
                mcpServers?: {
                    [key: string]: unknown;
                };
                commands?: {
                    [key: string]: {
                        label?: string;
                        description?: string;
                        command: string;
                        args?: Array<string>;
                        env?: {
                            [key: string]: string;
                        };
                        cwd?: string;
                        parameters?: {
                            [key: string]: {
                                type: 'string' | 'number' | 'boolean' | 'enum';
                                description?: string;
                                required?: boolean;
                                default?: string | number | boolean;
                                values?: Array<string>;
                            };
                        };
                        allowExtraArgs?: boolean;
                        fallback?: {
                            label?: string;
                            description?: string;
                            command: string;
                            args?: Array<string>;
                            env?: {
                                [key: string]: string;
                            };
                            cwd?: string;
                            parameters?: {
                                [key: string]: {
                                    type: 'string' | 'number' | 'boolean' | 'enum';
                                    description?: string;
                                    required?: boolean;
                                    default?: string | number | boolean;
                                    values?: Array<string>;
                                };
                            };
                            allowExtraArgs?: boolean;
                        };
                    };
                };
                browser?: {
                    previewUrl?: string;
                };
                requirements?: Array<{
                    kind: 'platform' | 'command' | 'env' | 'toolchain';
                    value: string;
                    message?: string;
                }>;
            };
            error?: string;
        }>;
    };
};
export type UpdatePluginResponse = UpdatePluginResponses[keyof UpdatePluginResponses];
export type GetUsageStatsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
        /**
         * Restrict every aggregate to the last N days (local calendar days, including today). Omit for all-time.
         */
        days?: number;
    };
    url: '/v1/usage/stats';
};
export type GetUsageStatsResponses = {
    /**
     * Aggregated usage stats
     */
    200: UsageStats;
};
export type GetUsageStatsResponse = GetUsageStatsResponses[keyof GetUsageStatsResponses];
export type GetGlobalUsageStatsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Restrict every aggregate to the last N days (local calendar days, including today). Omit for all-time.
         */
        days?: number;
    };
    url: '/v1/usage/stats/global';
};
export type GetGlobalUsageStatsResponses = {
    /**
     * Aggregated usage stats across all registered projects
     */
    200: UsageStats;
};
export type GetGlobalUsageStatsResponse = GetGlobalUsageStatsResponses[keyof GetGlobalUsageStatsResponses];
export type UploadAttachmentData = {
    body: {
        /**
         * Attachment file to store
         */
        file?: Blob | File;
        sessionId?: string;
    };
    path?: never;
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/attachments';
};
export type UploadAttachmentErrors = {
    /**
     * Bad Request
     */
    400: {
        error: string;
    };
    /**
     * Attachment too large
     */
    413: {
        error: string;
    };
    /**
     * Upload failed
     */
    500: {
        error: string;
    };
};
export type UploadAttachmentError = UploadAttachmentErrors[keyof UploadAttachmentErrors];
export type UploadAttachmentResponses = {
    /**
     * Attachment stored
     */
    201: {
        id: string;
        filename: string;
        mimeType: string;
        size: number;
        sha256: string;
        kind: 'image' | 'pdf' | 'text' | 'binary';
        sessionId?: string;
        originalPath: string;
        storageRoot?: 'project-state';
        relativePath?: string;
        createdAt: string;
        originalUrl: string;
        metadataUrl: string;
        status: 'ready';
    };
};
export type UploadAttachmentResponse = UploadAttachmentResponses[keyof UploadAttachmentResponses];
export type GetAttachmentMetadataData = {
    body?: never;
    path: {
        /**
         * Attachment ID
         */
        id: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/attachments/{id}/metadata';
};
export type GetAttachmentMetadataErrors = {
    /**
     * Attachment not found
     */
    404: {
        error: string;
    };
};
export type GetAttachmentMetadataError = GetAttachmentMetadataErrors[keyof GetAttachmentMetadataErrors];
export type GetAttachmentMetadataResponses = {
    /**
     * Attachment metadata
     */
    200: {
        id: string;
        filename: string;
        mimeType: string;
        size: number;
        sha256: string;
        kind: 'image' | 'pdf' | 'text' | 'binary';
        sessionId?: string;
        originalPath: string;
        storageRoot?: 'project-state';
        relativePath?: string;
        createdAt: string;
        originalUrl: string;
        metadataUrl: string;
        status: 'ready';
    };
};
export type GetAttachmentMetadataResponse = GetAttachmentMetadataResponses[keyof GetAttachmentMetadataResponses];
export type GetAttachmentData = {
    body?: never;
    path: {
        /**
         * Attachment ID
         */
        id: string;
    };
    query?: {
        /**
         * Project root override (defaults to current working directory).
         */
        project?: string;
    };
    url: '/v1/attachments/{id}';
};
export type GetAttachmentErrors = {
    /**
     * Attachment not found
     */
    404: {
        error: string;
    };
};
export type GetAttachmentError = GetAttachmentErrors[keyof GetAttachmentErrors];
export type GetAttachmentResponses = {
    /**
     * Stored attachment file bytes
     */
    200: Blob | File;
};
export type GetAttachmentResponse = GetAttachmentResponses[keyof GetAttachmentResponses];
export type PollBrowserCommandData = {
    body?: never;
    path?: never;
    query: {
        tabId: string;
        url?: string;
        title?: string;
        kind?: 'browser' | 'simulator';
    };
    url: '/v1/browser/commands';
};
export type PollBrowserCommandResponses = {
    /**
     * The next command, or null after the poll timeout
     */
    200: {
        command: {
            id: string;
            tabId: string;
            action: string;
            args: string;
            createdAt: number;
        } | null;
    };
};
export type PollBrowserCommandResponse = PollBrowserCommandResponses[keyof PollBrowserCommandResponses];
export type SubmitBrowserCommandResultData = {
    body: {
        result: string;
    };
    path: {
        commandId: string;
    };
    query?: never;
    url: '/v1/browser/commands/{commandId}/result';
};
export type SubmitBrowserCommandResultResponses = {
    /**
     * Whether the pending command accepted the result
     */
    200: {
        accepted: boolean;
    };
};
export type SubmitBrowserCommandResultResponse = SubmitBrowserCommandResultResponses[keyof SubmitBrowserCommandResultResponses];
export type GetSimulatorStatusData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/simulator/status';
};
export type GetSimulatorStatusResponses = {
    /**
     * Current simulator stream state
     */
    200: {
        status: 'idle' | 'starting' | 'connected' | 'error';
        setupStatus: 'unsupported' | 'missing_runner' | 'ready' | 'preparing';
        setupMessage: string | null;
        runner: string | null;
        url: string | null;
        deviceName: string | null;
        udid: string | null;
        port: number;
        error: string | null;
        updatedAt: string;
    };
};
export type GetSimulatorStatusResponse = GetSimulatorStatusResponses[keyof GetSimulatorStatusResponses];
export type ListSimulatorsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/simulator/list';
};
export type ListSimulatorsResponses = {
    /**
     * Running serve-sim streams
     */
    200: {
        ok: true;
        state: {
            status: 'idle' | 'starting' | 'connected' | 'error';
            setupStatus: 'unsupported' | 'missing_runner' | 'ready' | 'preparing';
            setupMessage: string | null;
            runner: string | null;
            url: string | null;
            deviceName: string | null;
            udid: string | null;
            port: number;
            error: string | null;
            updatedAt: string;
        };
        raw: string;
    } | {
        ok: false;
        error: string;
        stdout: string;
        stderr: string;
    };
};
export type ListSimulatorsResponse = ListSimulatorsResponses[keyof ListSimulatorsResponses];
export type StartSimulatorData = {
    body?: {
        port?: number;
        device?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/simulator/start';
};
export type StartSimulatorErrors = {
    /**
     * serve-sim failed to start
     */
    500: {
        ok: boolean;
        stdout?: string;
        stderr?: string;
        error?: string | null;
        status?: 'idle' | 'starting' | 'connected' | 'error';
        setupStatus?: 'unsupported' | 'missing_runner' | 'ready' | 'preparing';
        setupMessage?: string | null;
        runner?: string | null;
        url?: string | null;
        deviceName?: string | null;
        udid?: string | null;
        port?: number;
        updatedAt?: string;
    };
};
export type StartSimulatorError = StartSimulatorErrors[keyof StartSimulatorErrors];
export type StartSimulatorResponses = {
    /**
     * serve-sim started
     */
    200: {
        ok: boolean;
        stdout?: string;
        stderr?: string;
        error?: string | null;
        status?: 'idle' | 'starting' | 'connected' | 'error';
        setupStatus?: 'unsupported' | 'missing_runner' | 'ready' | 'preparing';
        setupMessage?: string | null;
        runner?: string | null;
        url?: string | null;
        deviceName?: string | null;
        udid?: string | null;
        port?: number;
        updatedAt?: string;
    };
};
export type StartSimulatorResponse = StartSimulatorResponses[keyof StartSimulatorResponses];
export type StopSimulatorData = {
    body?: {
        device?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/simulator/stop';
};
export type StopSimulatorErrors = {
    /**
     * serve-sim failed to stop
     */
    500: {
        ok: boolean;
        stdout?: string;
        stderr?: string;
        error?: string | null;
        status?: 'idle' | 'starting' | 'connected' | 'error';
        setupStatus?: 'unsupported' | 'missing_runner' | 'ready' | 'preparing';
        setupMessage?: string | null;
        runner?: string | null;
        url?: string | null;
        deviceName?: string | null;
        udid?: string | null;
        port?: number;
        updatedAt?: string;
    };
};
export type StopSimulatorError = StopSimulatorErrors[keyof StopSimulatorErrors];
export type StopSimulatorResponses = {
    /**
     * serve-sim stopped
     */
    200: {
        ok: boolean;
        stdout?: string;
        stderr?: string;
        error?: string | null;
        status?: 'idle' | 'starting' | 'connected' | 'error';
        setupStatus?: 'unsupported' | 'missing_runner' | 'ready' | 'preparing';
        setupMessage?: string | null;
        runner?: string | null;
        url?: string | null;
        deviceName?: string | null;
        udid?: string | null;
        port?: number;
        updatedAt?: string;
    };
};
export type StopSimulatorResponse = StopSimulatorResponses[keyof StopSimulatorResponses];
export type PressSimulatorButtonData = {
    body?: {
        name?: string;
        device?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/simulator/button';
};
export type PressSimulatorButtonErrors = {
    /**
     * Button failed
     */
    500: {
        ok: boolean;
        stdout?: string;
        stderr?: string;
        error?: string;
        button: string;
    };
};
export type PressSimulatorButtonError = PressSimulatorButtonErrors[keyof PressSimulatorButtonErrors];
export type PressSimulatorButtonResponses = {
    /**
     * Button sent
     */
    200: {
        ok: boolean;
        stdout?: string;
        stderr?: string;
        error?: string;
        button: string;
    };
};
export type PressSimulatorButtonResponse = PressSimulatorButtonResponses[keyof PressSimulatorButtonResponses];
export type SendSimulatorGestureData = {
    body: {
        gesture?: unknown;
        device?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/simulator/gesture';
};
export type SendSimulatorGestureErrors = {
    /**
     * Gesture failed
     */
    500: {
        ok: boolean;
        stdout?: string;
        stderr?: string;
        error?: string;
        gesture?: unknown;
    };
};
export type SendSimulatorGestureError = SendSimulatorGestureErrors[keyof SendSimulatorGestureErrors];
export type SendSimulatorGestureResponses = {
    /**
     * Gesture sent
     */
    200: {
        ok: boolean;
        stdout?: string;
        stderr?: string;
        error?: string;
        gesture?: unknown;
    };
};
export type SendSimulatorGestureResponse = SendSimulatorGestureResponses[keyof SendSimulatorGestureResponses];
export type RotateSimulatorData = {
    body: {
        orientation: 'portrait' | 'portrait_upside_down' | 'landscape_left' | 'landscape_right';
        device?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/simulator/rotate';
};
export type RotateSimulatorErrors = {
    /**
     * Rotation failed
     */
    500: {
        ok: boolean;
        stdout?: string;
        stderr?: string;
        error?: string;
        orientation: string;
    };
};
export type RotateSimulatorError = RotateSimulatorErrors[keyof RotateSimulatorErrors];
export type RotateSimulatorResponses = {
    /**
     * Rotation sent
     */
    200: {
        ok: boolean;
        stdout?: string;
        stderr?: string;
        error?: string;
        orientation: string;
    };
};
export type RotateSimulatorResponse = RotateSimulatorResponses[keyof RotateSimulatorResponses];
export type GetSimulatorLogsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/simulator/logs';
};
export type GetSimulatorLogsErrors = {
    /**
     * No active simulator
     */
    400: {
        ok: boolean;
        logs?: string;
        url?: string;
        error?: string;
    };
};
export type GetSimulatorLogsError = GetSimulatorLogsErrors[keyof GetSimulatorLogsErrors];
export type GetSimulatorLogsResponses = {
    /**
     * Simulator logs
     */
    200: {
        ok: boolean;
        logs?: string;
        url?: string;
        error?: string;
    };
};
export type GetSimulatorLogsResponse = GetSimulatorLogsResponses[keyof GetSimulatorLogsResponses];
export type GetDictationStatusData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/dictation/status';
};
export type GetDictationStatusResponses = {
    /**
     * Dictation status
     */
    200: {
        available: boolean;
        engine: string;
        engineInstalled: boolean;
        defaultModel: string;
        format?: {
            encoding: string;
            sampleRate: number;
            channels: number;
        };
        projectKeywords: Array<string>;
        models: Array<{
            id: string;
            label: string;
            language: 'en' | 'multi';
            sizeBytes: number;
            url: string;
            sha256: string;
            recommended?: boolean;
            installed: boolean;
            installing: boolean;
            installedSizeBytes: number;
            installStatus: 'idle' | 'installing' | 'verifying' | 'installed' | 'error';
            progressBytes: number;
            totalBytes: number;
            error?: string;
            errorCode?: string;
            [key: string]: unknown | string | 'en' | 'multi' | number | boolean | 'idle' | 'installing' | 'verifying' | 'installed' | 'error' | undefined;
        }>;
    };
};
export type GetDictationStatusResponse = GetDictationStatusResponses[keyof GetDictationStatusResponses];
export type ListDictationModelsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v1/dictation/models';
};
export type ListDictationModelsResponses = {
    /**
     * Dictation models
     */
    200: {
        models: Array<{
            id: string;
            label: string;
            language: 'en' | 'multi';
            sizeBytes: number;
            url: string;
            sha256: string;
            recommended?: boolean;
            installed: boolean;
            installing: boolean;
            installedSizeBytes: number;
            installStatus: 'idle' | 'installing' | 'verifying' | 'installed' | 'error';
            progressBytes: number;
            totalBytes: number;
            error?: string;
            errorCode?: string;
            [key: string]: unknown | string | 'en' | 'multi' | number | boolean | 'idle' | 'installing' | 'verifying' | 'installed' | 'error' | undefined;
        }>;
    };
};
export type ListDictationModelsResponse = ListDictationModelsResponses[keyof ListDictationModelsResponses];
export type InstallDictationModelData = {
    body?: {
        force?: boolean;
    };
    path: {
        model: string;
    };
    query?: never;
    url: '/v1/dictation/models/{model}/install';
};
export type InstallDictationModelErrors = {
    /**
     * Model not found
     */
    404: {
        error: string;
        code?: string;
    };
    /**
     * Model download metadata is not configured
     */
    501: {
        error: string;
        code?: string;
    };
};
export type InstallDictationModelError = InstallDictationModelErrors[keyof InstallDictationModelErrors];
export type InstallDictationModelResponses = {
    /**
     * Model installed or already present
     */
    200: {
        model: {
            id: string;
            label: string;
            language: 'en' | 'multi';
            sizeBytes: number;
            url: string;
            sha256: string;
            recommended?: boolean;
            installed: boolean;
            installing: boolean;
            installedSizeBytes: number;
            installStatus: 'idle' | 'installing' | 'verifying' | 'installed' | 'error';
            progressBytes: number;
            totalBytes: number;
            error?: string;
            errorCode?: string;
            [key: string]: unknown | string | 'en' | 'multi' | number | boolean | 'idle' | 'installing' | 'verifying' | 'installed' | 'error' | undefined;
        };
    };
    /**
     * Model installation started
     */
    202: {
        model: {
            id: string;
            label: string;
            language: 'en' | 'multi';
            sizeBytes: number;
            url: string;
            sha256: string;
            recommended?: boolean;
            installed: boolean;
            installing: boolean;
            installedSizeBytes: number;
            installStatus: 'idle' | 'installing' | 'verifying' | 'installed' | 'error';
            progressBytes: number;
            totalBytes: number;
            error?: string;
            errorCode?: string;
            [key: string]: unknown | string | 'en' | 'multi' | number | boolean | 'idle' | 'installing' | 'verifying' | 'installed' | 'error' | undefined;
        };
    };
};
export type InstallDictationModelResponse = InstallDictationModelResponses[keyof InstallDictationModelResponses];
export type StreamDictationModelInstallEventsData = {
    body?: never;
    path: {
        model: string;
    };
    query?: never;
    url: '/v1/dictation/models/{model}/install/events';
};
export type StreamDictationModelInstallEventsErrors = {
    /**
     * Model not found
     */
    404: {
        error: string;
        code?: string;
    };
};
export type StreamDictationModelInstallEventsError = StreamDictationModelInstallEventsErrors[keyof StreamDictationModelInstallEventsErrors];
export type StreamDictationModelInstallEventsResponses = {
    /**
     * SSE stream of model install progress
     */
    200: string;
};
export type StreamDictationModelInstallEventsResponse = StreamDictationModelInstallEventsResponses[keyof StreamDictationModelInstallEventsResponses];
export type RemoveDictationModelData = {
    body?: never;
    path: {
        model: string;
    };
    query?: never;
    url: '/v1/dictation/models/{model}';
};
export type RemoveDictationModelErrors = {
    /**
     * Model not found
     */
    404: {
        error: string;
        code?: string;
    };
};
export type RemoveDictationModelError = RemoveDictationModelErrors[keyof RemoveDictationModelErrors];
export type RemoveDictationModelResponses = {
    /**
     * Model removed
     */
    200: {
        removed: boolean;
        model: {
            id: string;
            label: string;
            language: 'en' | 'multi';
            sizeBytes: number;
            url: string;
            sha256: string;
            recommended?: boolean;
            installed: boolean;
            installing: boolean;
            installedSizeBytes: number;
            installStatus: 'idle' | 'installing' | 'verifying' | 'installed' | 'error';
            progressBytes: number;
            totalBytes: number;
            error?: string;
            errorCode?: string;
            [key: string]: unknown | string | 'en' | 'multi' | number | boolean | 'idle' | 'installing' | 'verifying' | 'installed' | 'error' | undefined;
        };
    };
};
export type RemoveDictationModelResponse = RemoveDictationModelResponses[keyof RemoveDictationModelResponses];
export type CreateDictationSessionData = {
    body?: {
        model?: string;
        language?: string;
        prompt?: string;
    };
    path?: never;
    query?: never;
    url: '/v1/dictation/sessions';
};
export type CreateDictationSessionResponses = {
    /**
     * Dictation session created
     */
    201: {
        id: string;
        wsUrl: string;
        model: string;
        modelInstalled: boolean;
        format: {
            encoding: string;
            sampleRate: number;
            channels: number;
        };
    };
};
export type CreateDictationSessionResponse = CreateDictationSessionResponses[keyof CreateDictationSessionResponses];
export type DeleteDictationSessionData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/dictation/sessions/{id}';
};
export type DeleteDictationSessionResponses = {
    /**
     * Deleted
     */
    200: {
        deleted: boolean;
    };
};
export type DeleteDictationSessionResponse = DeleteDictationSessionResponses[keyof DeleteDictationSessionResponses];
export type GetDictationSessionData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/dictation/sessions/{id}';
};
export type GetDictationSessionErrors = {
    /**
     * Session not found
     */
    404: {
        error: string;
        code?: string;
    };
};
export type GetDictationSessionError = GetDictationSessionErrors[keyof GetDictationSessionErrors];
export type GetDictationSessionResponses = {
    /**
     * Dictation session
     */
    200: {
        session: {
            id: string;
            status: 'created' | 'recording' | 'transcribing' | 'completed' | 'cancelled' | 'error';
            model: string;
            language: string;
            format: {
                encoding: string;
                sampleRate: number;
                channels: number;
            };
            createdAt: string;
            updatedAt: string;
            receivedBytes: number;
            receivedMs: number;
            pcmPath: string;
            wavPath: string;
            text?: string;
            error?: string;
            [key: string]: unknown | string | 'created' | 'recording' | 'transcribing' | 'completed' | 'cancelled' | 'error' | {
                encoding: string;
                sampleRate: number;
                channels: number;
            } | number | undefined;
        };
    };
};
export type GetDictationSessionResponse = GetDictationSessionResponses[keyof GetDictationSessionResponses];
export type ConnectDictationSessionWebSocketData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/v1/dictation/sessions/{id}/ws';
};
export type ConnectDictationSessionWebSocketErrors = {
    /**
     * Session not found
     */
    404: unknown;
};
//# sourceMappingURL=types.gen.d.ts.map