export { configureApiClient } from './utils';
export type { Goal, GoalStatus, GoalTask, GoalTaskStatus, Subagent, SubagentStatus, } from './goals';
export type { CreateDictationSessionInput, CreateDictationSessionResponse, DictationModelInstallEvent, DictationModelInstallStatus, DictationModelState, DictationModelsResponse, DictationStatusResponse, InstallDictationModelInput, InstallDictationModelResponse, RemoveDictationModelResponse, } from './dictation';
declare class ApiClient {
    getSessions: () => Promise<import("../..").Session[]>;
    getSessionsPage: (params?: {
        limit?: number;
        offset?: number;
        sessionType?: "otto";
    }) => Promise<import("../..").SessionsPage>;
    createSession: (data: import("../..").CreateSessionRequest) => Promise<import("../..").Session>;
    getSession: (sessionId: string) => Promise<import("../..").Session>;
    updateSession: (sessionId: string, data: import("../..").UpdateSessionRequest) => Promise<import("../..").Session>;
    markSessionViewed: (sessionId: string) => Promise<import("../..").Session>;
    deleteSession: (sessionId: string) => Promise<{
        success: boolean;
    }>;
    createHandoff: (sessionId: string) => Promise<{
        session: import("../..").Session;
        sessionId: string;
        sourceSessionId: string;
        message: string;
    }>;
    abortSession: (sessionId: string) => Promise<{
        success: boolean;
    }>;
    abortMessage: (sessionId: string, _messageId: string) => Promise<{
        success: boolean;
        wasRunning: boolean;
        messageId: string;
    }>;
    getQueueState: (sessionId: string) => Promise<{
        currentMessageId: string | null;
        queuedMessages: Array<{
            messageId: string;
            position: number;
        }>;
        isRunning: boolean;
    }>;
    removeFromQueue: (sessionId: string, messageId: string) => Promise<{
        success: boolean;
        removed: boolean;
        wasQueued?: boolean;
        wasRunning?: boolean;
    }>;
    sendQueuedMessageNow: (sessionId: string, messageId: string) => Promise<{
        success: boolean;
        promoted: boolean;
        wasQueued?: boolean;
        wasRunning?: boolean;
        preemptedMessageId?: string | null;
    }>;
    getMessages: (sessionId: string) => Promise<import("../..").Message[]>;
    sendMessage: (sessionId: string, data: import("../..").SendMessageRequest) => Promise<import("../..").SendMessageResponse>;
    getStreamUrl: (sessionId: string) => string;
    retryMessage: (sessionId: string, messageId: string) => Promise<{
        success: boolean;
        messageId: string;
    }>;
    initGitRepo: () => Promise<{
        initialized: boolean;
        path: string;
    }>;
    getGitStatus: () => Promise<import("../..").GitStatusResponse>;
    getGitDiff: (file: string, staged?: boolean) => Promise<import("../..").GitDiffResponse>;
    getGitDiffFullFile: (file: string, staged?: boolean) => Promise<import("../..").GitDiffResponse>;
    generateCommitMessage: (sessionId?: string) => Promise<import("../..").GitGenerateCommitMessageResponse>;
    stageFiles: (files: string[]) => Promise<import("../..").GitStageResponse>;
    unstageFiles: (files: string[]) => Promise<import("../..").GitUnstageResponse>;
    restoreFiles: (files: string[]) => Promise<{
        restored: string[];
    }>;
    deleteFiles: (files: string[]) => Promise<{
        deleted: string[];
    }>;
    commitChanges: (message: string) => Promise<import("../..").GitCommitResponse>;
    getGitBranch: () => Promise<import("../..").GitBranchInfo>;
    pushCommits: () => Promise<import("../..").GitPushResponse>;
    pullChanges: () => Promise<import("../..").GitPullResponse>;
    performRebaseAction: (action: "continue" | "abort" | "skip") => Promise<import("../..").GitRebaseActionResponse>;
    getRemotes: () => Promise<import("../..").GitRemoteInfo[]>;
    addRemote: (name: string, url: string) => Promise<{
        name: string;
        url: string;
    }>;
    removeRemote: (name: string) => Promise<{
        removed: string;
    }>;
    listGitBranches: () => Promise<import("../..").GitBranchListResponse>;
    checkoutBranch: (branch: string) => Promise<{
        branch: string;
    }>;
    createGitBranch: (name: string, options?: {
        startPoint?: string;
        checkout?: boolean;
    }) => Promise<{
        branch: string;
        checkedOut: boolean;
    }>;
    getConfig: () => Promise<{
        agents: string[];
        providers: string[];
        defaults: {
            agent: string;
            provider: string;
            model: string;
            toolApproval?: "auto" | "dangerous" | "all" | "yolo";
            guidedMode?: boolean;
            reasoningText?: boolean;
            reasoningLevel?: "minimal" | "low" | "medium" | "high" | "max" | "xhigh";
            theme?: "light" | "dark";
            tuiTheme?: string;
            vimMode?: boolean;
            compactThread?: boolean;
            fontFamily?: string;
            smartEdges?: boolean;
            releaseToSend?: boolean;
            fullWidthContent?: boolean;
            autoCompactThresholdTokens?: number | null;
            coAuthorCommits?: boolean;
            ottoEnabled?: boolean;
        };
    }>;
    getAgentDetails: () => Promise<import("@ottocode/api").GetAgentDetailsResponse>;
    getAgent: (name: string) => Promise<import("@ottocode/api").GetAgentResponse>;
    getConfigTools: () => Promise<import("@ottocode/api").GetConfigToolsResponse>;
    updateAgent: (name: string, input: import("./config").UpdateAgentInput) => Promise<import("@ottocode/api").UpsertAgentResponse>;
    deleteAgent: (name: string, scope?: "local" | "global") => Promise<import("@ottocode/api").DeleteAgentResponse>;
    getModels: (providerId: string) => Promise<{
        models: Array<{
            id: string;
            label: string;
            toolCall?: boolean;
            reasoningText?: boolean;
            vision?: boolean;
            attachment?: boolean;
            free?: boolean;
            contextWindow?: number;
            maxOutputTokens?: number;
            available?: boolean;
            unavailableReason?: string;
        }>;
        default: string;
        allowAnyModel?: boolean;
        dynamicModels?: boolean;
        label?: string;
    }>;
    getAllModels: () => Promise<import("../..").AllModelsResponse>;
    discoverProviderModels: (data: {
        compatibility: "openai" | "anthropic" | "google" | "openrouter" | "ollama" | "openai-compatible";
        baseURL: string;
        apiKey?: string;
    }) => Promise<{
        baseURL?: string;
        models: import("./config").DiscoveredProviderModel[];
        unsupported?: boolean;
        message?: string;
    }>;
    updateProviderSettings: (provider: string, data: {
        enabled?: boolean;
        custom?: boolean;
        label?: string;
        compatibility?: "openai" | "anthropic" | "google" | "openrouter" | "ollama" | "openai-compatible";
        baseURL?: string | null;
        apiKey?: string | null;
        models?: string[];
        allowAnyModel?: boolean;
    }) => Promise<{
        success: boolean;
        provider: string;
    }>;
    deleteProviderSettings: (provider: string) => Promise<{
        success: boolean;
        provider: string;
    }>;
    updateDefaults: (data: {
        agent?: string;
        provider?: string;
        model?: string;
        toolApproval?: "auto" | "dangerous" | "all" | "yolo";
        guidedMode?: boolean;
        reasoningText?: boolean;
        reasoningLevel?: "minimal" | "low" | "medium" | "high" | "max" | "xhigh";
        theme?: "light" | "dark";
        tuiTheme?: string;
        vimMode?: boolean;
        compactThread?: boolean;
        fontFamily?: string;
        smartEdges?: boolean;
        releaseToSend?: boolean;
        fullWidthContent?: boolean;
        autoCompactThresholdTokens?: number | null;
        coAuthorCommits?: boolean;
        ottoEnabled?: boolean;
        scope?: "global" | "local";
    }) => Promise<{
        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?: "light" | "dark";
            tuiTheme?: string;
            vimMode?: boolean;
            compactThread?: boolean;
            fontFamily?: string;
            smartEdges?: boolean;
            releaseToSend?: boolean;
            fullWidthContent?: boolean;
            autoCompactThresholdTokens?: number | null;
            coAuthorCommits?: boolean;
            ottoEnabled?: boolean;
        };
    }>;
    listFiles: () => Promise<{
        files: string[];
        ignoredFiles?: string[];
        changedFiles: Array<{
            path: string;
            status: string;
        }>;
        truncated: boolean;
    }>;
    searchFiles: (query?: string) => Promise<{
        files: string[];
        ignoredFiles?: string[];
        changedFiles: Array<{
            path: string;
            status: string;
        }>;
        truncated: boolean;
    }>;
    getFileTree: (dirPath?: string) => Promise<{
        items: Array<{
            name: string;
            path: string;
            type: "file" | "directory";
            gitignored?: boolean;
            vendor?: boolean;
            searchable?: boolean;
        }>;
        path: string;
        truncated: boolean;
    }>;
    readFileContent: (filePath: string) => Promise<{
        content: string;
        path: string;
        extension: string;
        lineCount: number;
    }>;
    getSessionFiles: (sessionId: string) => Promise<import("../..").SessionFilesResponse>;
    createBranch: (sessionId: string, data: import("../..").CreateBranchRequest) => Promise<import("../..").BranchResult>;
    listBranches: (sessionId: string) => Promise<import("../..").ListBranchesResponse>;
    getParentSession: (sessionId: string) => Promise<import("../..").ParentSessionResponse>;
    getShareStatus: (sessionId: string) => Promise<import("../..").ShareStatus>;
    shareSession: (sessionId: string) => Promise<import("../..").ShareSessionResponse>;
    syncSession: (sessionId: string) => Promise<import("../..").SyncSessionResponse>;
    getSessionGoal: (sessionId: string) => Promise<{
        goal: import("./goals").Goal | null;
    }>;
    listGoals: () => Promise<{
        goals: import("./goals").Goal[];
    }>;
    createSessionGoal: (sessionId: string, data: {
        title: string;
        tasks?: string[];
    }) => Promise<{
        goal: import("./goals").Goal;
    }>;
    updateGoal: (goalId: string, data: {
        title?: string;
        status?: import("./goals").GoalStatus;
    }) => Promise<{
        goal: import("./goals").Goal;
    }>;
    addGoalTasks: (goalId: string, tasks: string[]) => Promise<{
        goal: import("./goals").Goal;
    }>;
    updateGoalTask: (goalId: string, taskId: string, data: {
        content?: string;
        status?: import("./goals").GoalTaskStatus;
        note?: string | null;
    }) => Promise<{
        task: import("./goals").GoalTask;
    }>;
    deleteGoalTask: (goalId: string, taskId: string) => Promise<{
        goal: import("./goals").Goal;
    }>;
    startGoal: (goalId: string) => Promise<{
        goal: import("./goals").Goal;
    }>;
    listSessionSubagents: (sessionId: string, status?: import("./goals").SubagentStatus) => Promise<{
        subagents: import("./goals").Subagent[];
    }>;
    approveToolCall: (sessionId: string, callId: string, approved: boolean) => Promise<{
        ok: boolean;
        callId: string;
        approved: boolean;
    }>;
    getPendingApprovals: (sessionId: string) => Promise<{
        ok: boolean;
        pending: Array<{
            callId: string;
            toolName: string;
            args: unknown;
            messageId: string;
            createdAt: number;
        }>;
    }>;
    submitSecureInput: (sessionId: string, promptId: string, value: string) => Promise<{
        ok: boolean;
        promptId: string;
        cancelled: boolean;
    }>;
    cancelSecureInput: (sessionId: string, promptId: string) => Promise<{
        ok: boolean;
        promptId: string;
        cancelled: boolean;
    }>;
    getPendingSecureInputs: (sessionId: string) => Promise<{
        ok: boolean;
        pending: Array<{
            promptId: string;
            messageId?: string;
            callId?: string;
            prompt: string;
            inputKind: "password";
            createdAt: number;
        }>;
    }>;
    getOttoRouterBalance: () => Promise<{
        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;
            creditsWeeklyLimit?: number | null;
            creditsFiveHourLimit?: number | null;
            usageWindows?: {
                weekly: {
                    limit: number | null;
                    used: number;
                    remaining: number | null;
                    percentUsed: number;
                };
                fiveHour: {
                    limit: number | null;
                    used: number;
                    remaining: number | null;
                    percentUsed: number;
                };
            };
            periodStart?: string;
            periodEnd?: string;
        } | null;
    } | null>;
    getOttoRouterWallet: () => Promise<{
        configured: boolean;
        publicKey?: string;
        error?: string;
    }>;
    getOttoRouterUsdcBalance: (network?: "mainnet" | "devnet") => Promise<{
        walletAddress: string;
        usdcBalance: number;
        network: "mainnet" | "devnet";
    } | null>;
    getPolarTopupEstimate: (amount: number) => Promise<{
        creditAmount: number;
        chargeAmount: number;
        feeAmount: number;
        feeBreakdown: {
            basePercent: number;
            internationalPercent: number;
            fixedCents: number;
        };
    } | null>;
    createPolarCheckout: (amount: number, successUrl: string) => Promise<{
        success: boolean;
        checkoutId: string;
        checkoutUrl: string;
        creditAmount: number;
        chargeAmount: number;
        feeAmount: number;
    }>;
    selectTopupMethod: (sessionId: string, method: "crypto" | "fiat") => Promise<{
        success: boolean;
        method: string;
    }>;
    cancelTopup: (sessionId: string, reason?: string) => Promise<{
        success: boolean;
    }>;
    getPendingTopup: (sessionId: string) => Promise<{
        hasPending: boolean;
        sessionId?: string;
        messageId?: string;
        amountUsd?: number;
        currentBalance?: number;
        createdAt?: number;
    }>;
    getPolarTopupStatus: (checkoutId: string) => Promise<{
        checkoutId: string;
        confirmed: boolean;
        amountUsd: number | null;
        confirmedAt: string | null;
    } | null>;
    getRazorpayTopupEstimate: (amount: number) => Promise<{
        creditAmountUsd: number;
        chargeAmountInr: number;
        feeAmountInr: number;
        currency: string;
        exchangeRate: number;
    } | null>;
    createRazorpayOrder: (amount: number) => Promise<{
        success: boolean;
        orderId: string;
        amount: number;
        currency: string;
        creditAmountUsd: number;
        keyId: string;
    }>;
    verifyRazorpayPayment: (params: {
        razorpay_order_id: string;
        razorpay_payment_id: string;
        razorpay_signature: string;
    }) => Promise<{
        success: boolean;
        credited: number;
        newBalance: number;
    }>;
    getAuthStatus: () => Promise<{
        onboardingComplete: boolean;
        ottorouter: {
            configured: boolean;
            publicKey?: string;
        };
        providers: Record<string, {
            configured: boolean;
            type?: "api" | "oauth" | "wallet";
            label: string;
            supportsOAuth: boolean;
            supportsToken?: boolean;
            supportsGhImport?: boolean;
            custom?: boolean;
            modelCount: number;
            costRange?: {
                min: number;
                max: number;
            };
        }>;
        defaults: {
            agent: string;
            provider: string;
            model: string;
            toolApproval?: "auto" | "dangerous" | "all" | "yolo";
        };
    }>;
    setupOttoRouterWallet: () => Promise<{
        success: boolean;
        publicKey: string;
        isNew: boolean;
    }>;
    importOttoRouterWallet: (privateKey: string) => Promise<{
        success: boolean;
        publicKey: string;
    }>;
    exportOttoRouterWallet: () => Promise<{
        success: boolean;
        publicKey: string;
        privateKey: string;
    }>;
    addProvider: (provider: string, apiKey: string) => Promise<{
        success: boolean;
        provider: string;
    }>;
    removeProvider: (provider: string) => Promise<{
        success: boolean;
        provider: string;
    }>;
    completeOnboarding: () => Promise<{
        success: boolean;
    }>;
    getOAuthStartUrl: (provider: string, mode?: string) => string;
    getOAuthUrl: (provider: string, mode?: string) => Promise<{
        url: string;
        sessionId: string;
        provider: string;
    }>;
    exchangeOAuthCode: (provider: string, code: string, sessionId: string) => Promise<{
        success: boolean;
        provider: string;
    }>;
    startOpenAIDeviceFlow: () => Promise<{
        sessionId: string;
        userCode: string;
        verificationUri: string;
        interval: number;
    }>;
    pollOpenAIDeviceFlow: (sessionId: string) => Promise<{
        status: "complete" | "pending" | "error";
        error?: string;
    }>;
    startCopilotDeviceFlow: () => Promise<{
        sessionId: string;
        userCode: string;
        verificationUri: string;
        interval: number;
    }>;
    pollCopilotDeviceFlow: (sessionId: string) => Promise<{
        status: "complete" | "pending" | "error";
        error?: string;
    }>;
    startKimiDeviceFlow: () => Promise<{
        sessionId: string;
        userCode: string;
        verificationUri: string;
        interval: number;
    }>;
    pollKimiDeviceFlow: (sessionId: string) => Promise<{
        status: "complete" | "pending" | "error";
        error?: string;
    }>;
    getCopilotAuthMethods: () => Promise<{
        oauth: boolean;
        token: boolean;
        ghImport: {
            available: boolean;
            authenticated: boolean;
            reason?: string;
        };
    }>;
    saveCopilotToken: (token: string) => Promise<{
        success: boolean;
        provider: string;
        source: "token";
        modelCount: number;
        hasGpt52Codex: boolean;
        sampleModels: string[];
    }>;
    importCopilotTokenFromGh: () => Promise<{
        success: boolean;
        provider: string;
        source: "gh";
        modelCount: number;
        hasGpt52Codex: boolean;
        sampleModels: string[];
    }>;
    getCopilotDiagnostics: () => Promise<{
        tokenSources: Array<{
            source: "env" | "stored";
            configured: boolean;
            modelCount?: number;
            hasGpt52Codex?: boolean;
            sampleModels?: string[];
            restrictedByOrgPolicy?: boolean;
            restrictedOrg?: string;
            restrictionMessage?: string;
            error?: string;
        }>;
        methods: {
            oauth: boolean;
            token: boolean;
            ghImport: {
                available: boolean;
                authenticated: boolean;
                reason?: string;
            };
        };
    }>;
    getProviderUsage: (provider: string) => Promise<import("../..").ProviderUsageResponse>;
    listSkills: () => Promise<{
        skills: import("./skills").SkillSummary[];
    }>;
    getSkill: (name: string) => Promise<import("./skills").SkillDetail>;
    getSkillFiles: (name: string) => Promise<{
        files: import("./skills").SkillFileInfo[];
    }>;
    getSkillFileContent: (name: string, filePath: string) => Promise<{
        content: string;
        path: string;
    }>;
    getSkillsConfig: () => Promise<import("./skills").SkillsConfigResponse>;
    updateSkillsConfig: (input: {
        enabled?: boolean;
        items?: Record<string, {
            enabled?: boolean;
        }>;
    }) => Promise<import("./skills").SkillsConfigResponse>;
    getUsageStats: () => Promise<import("@ottocode/api").UsageStats>;
    getGlobalUsageStats: () => Promise<import("@ottocode/api").UsageStats>;
    getDictationStatus: () => Promise<import("./dictation").DictationStatusResponse>;
    listDictationModels: () => Promise<import("./dictation").DictationModelsResponse>;
    installDictationModel: ({ model, force, }: import("./dictation").InstallDictationModelInput) => Promise<import("./dictation").InstallDictationModelResponse>;
    removeDictationModel: (model: string) => Promise<import("./dictation").RemoveDictationModelResponse>;
    createDictationSession: (input?: import("./dictation").CreateDictationSessionInput) => Promise<import("./dictation").CreateDictationSessionResponse>;
    getDictationModelInstallEventsUrl: (model: string) => string;
}
export declare const apiClient: ApiClient;
//# sourceMappingURL=index.d.ts.map