export { configureApiClient } from './utils';
declare class ApiClient {
    getSessions: () => Promise<import("../..").Session[]>;
    getSessionsPage: (params?: {
        limit?: number;
        offset?: number;
    }) => Promise<import("../..").SessionsPage>;
    createSession: (data: import("../..").CreateSessionRequest) => Promise<import("../..").Session>;
    updateSession: (sessionId: string, data: import("../..").UpdateSessionRequest) => Promise<import("../..").Session>;
    deleteSession: (sessionId: string) => Promise<{
        success: boolean;
    }>;
    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;
    }>;
    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>;
    getRemotes: () => Promise<import("../..").GitRemoteInfo[]>;
    addRemote: (name: string, url: string) => Promise<{
        name: string;
        url: string;
    }>;
    removeRemote: (name: string) => Promise<{
        removed: string;
    }>;
    getConfig: () => Promise<{
        agents: string[];
        providers: string[];
        defaults: {
            agent: string;
            provider: string;
            model: string;
            toolApproval?: "auto" | "dangerous" | "all";
            guidedMode?: boolean;
            reasoningText?: boolean;
            reasoningLevel?: "minimal" | "low" | "medium" | "high" | "max" | "xhigh";
            fullWidthContent?: boolean;
        };
    }>;
    getModels: (providerId: string) => Promise<{
        models: Array<{
            id: string;
            label: string;
            toolCall?: boolean;
            available?: boolean;
            unavailableReason?: string;
        }>;
        default: string;
    }>;
    getAllModels: () => Promise<import("../..").AllModelsResponse>;
    updateDefaults: (data: {
        agent?: string;
        provider?: string;
        model?: string;
        toolApproval?: "auto" | "dangerous" | "all";
        guidedMode?: boolean;
        reasoningText?: boolean;
        reasoningLevel?: "minimal" | "low" | "medium" | "high" | "max" | "xhigh";
        fullWidthContent?: boolean;
        scope?: "global" | "local";
    }) => Promise<{
        success: boolean;
        defaults: {
            agent: string;
            provider: string;
            model: string;
            toolApproval?: "auto" | "dangerous" | "all";
            guidedMode?: boolean;
            reasoningText?: boolean;
            reasoningLevel?: "minimal" | "low" | "medium" | "high" | "max" | "xhigh";
            fullWidthContent?: boolean;
        };
    }>;
    listFiles: () => 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;
        }>;
        path: string;
    }>;
    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>;
    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;
        }>;
    }>;
    getSetuBalance: () => 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>;
    getSetuWallet: () => Promise<{
        configured: boolean;
        publicKey?: string;
        error?: string;
    }>;
    getSetuUsdcBalance: (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;
        setu: {
            configured: boolean;
            publicKey?: string;
        };
        providers: Record<string, {
            configured: boolean;
            type?: "api" | "oauth" | "wallet";
            label: string;
            supportsOAuth: boolean;
            supportsToken?: boolean;
            supportsGhImport?: boolean;
            modelCount: number;
            costRange?: {
                min: number;
                max: number;
            };
        }>;
        defaults: {
            agent: string;
            provider: string;
            model: string;
            toolApproval?: "auto" | "dangerous" | "all";
        };
    }>;
    setupSetuWallet: () => Promise<{
        success: boolean;
        publicKey: string;
        isNew: boolean;
    }>;
    importSetuWallet: (privateKey: string) => Promise<{
        success: boolean;
        publicKey: string;
    }>;
    exportSetuWallet: () => 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;
    }>;
    startCopilotDeviceFlow: () => Promise<{
        sessionId: string;
        userCode: string;
        verificationUri: string;
        interval: number;
    }>;
    pollCopilotDeviceFlow: (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;
    }>;
}
export declare const apiClient: ApiClient;
//# sourceMappingURL=index.d.ts.map