import type { ToolRouterCreateSessionConfig } from '@composio/core';
import { CredentialResolver } from '../auth/credentials.js';
import type { ConnectorActionMetadata, ConnectorConnection, ConnectorInstallationPolicy } from './types.js';
export declare function resolveComposioApiKey(resolver?: CredentialResolver): Promise<string | null>;
export declare function assertComposioApiKeyConfigured(resolver?: CredentialResolver): Promise<string>;
export type ComposioToolkitCatalogItem = {
    slug: string;
    name: string;
    logoUrl?: string;
    isNoAuth: boolean;
    connected: boolean;
    providerConnectionId?: string;
};
export type ComposioAuthorizeResult = {
    toolkit: string;
    connectionId: string;
    connectUrl?: string;
    status: string;
};
type SessionToolkitResponse = {
    items: Array<{
        slug: string;
        name: string;
        logo?: string;
        isNoAuth: boolean;
        connection?: {
            isActive: boolean;
            connectedAccount?: {
                status: string;
                id: string;
            };
        };
    }>;
    cursor?: string;
};
export type ComposioSessionLike = {
    sessionId: string;
    toolkits(options?: {
        toolkits?: string[];
        isConnected?: boolean;
        limit?: number;
        cursor?: string;
    }): Promise<SessionToolkitResponse>;
    authorize(toolkit: string, options?: {
        callbackUrl?: string;
        alias?: string;
    }): Promise<{
        id: string;
        status: string;
        redirectUrl?: string | null;
    }>;
    search(params: {
        query: string;
        toolkits?: string[];
    }): Promise<unknown>;
    execute(toolSlug: string, args?: Record<string, unknown>, options?: {
        account?: string;
    }): Promise<unknown>;
};
export type ComposioSessionsClient = {
    sessions: {
        create(userId: string, config?: ToolRouterCreateSessionConfig): Promise<ComposioSessionLike>;
    };
    connectedAccounts: {
        list(query?: {
            userIds?: string[];
            toolkitSlugs?: string[];
        }): Promise<unknown>;
        delete(id: string): Promise<unknown>;
        refresh(id: string): Promise<unknown>;
    };
};
export type ComposioSessionContext = {
    principalId: string;
    installationScope?: string;
    providerPrincipalId?: string;
    toolkits?: string[];
    connectedAccounts?: Record<string, string[]>;
    callbackUrl?: string;
};
type ClientFactory = () => Promise<ComposioSessionsClient>;
/** Convert local identities to stable opaque Composio user IDs without disclosing user data. */
export declare function createComposioPrincipalId(principalId: string, installationScope?: string): string;
export declare class ComposioSessionsAdapter {
    private readonly createClient;
    constructor(options?: {
        resolver?: CredentialResolver;
        clientFactory?: ClientFactory;
    });
    createSession(context: ComposioSessionContext): Promise<ComposioSessionLike>;
    listToolkitCatalog(context: Omit<ComposioSessionContext, 'toolkits'>): Promise<ComposioToolkitCatalogItem[]>;
    authorize(context: ComposioSessionContext & {
        toolkit: string;
        installationId?: string;
        alias?: string;
    }): Promise<ComposioAuthorizeResult>;
    syncConnections(context: Pick<ComposioSessionContext, 'principalId' | 'installationScope'>): Promise<ConnectorConnection[]>;
    revokeConnection(connection: ConnectorConnection): Promise<void>;
    refreshConnection(connection: ConnectorConnection): Promise<ConnectorConnection>;
    executeWithPolicy(input: {
        context: ComposioSessionContext;
        installation: ConnectorInstallationPolicy;
        connection?: ConnectorConnection;
        action: ConnectorActionMetadata;
        args?: Record<string, unknown>;
        agentId?: string;
        sessionKey?: string;
        confirmed?: boolean;
    }): Promise<{
        decision: 'allowed';
        result: unknown;
    } | {
        decision: 'denied' | 'confirmation_required';
        reason: string;
    }>;
}
export {};