import type { ClientToolDefinition } from '@mondaydotcomorg/atp-protocol';
import type { TokenRefreshConfig } from './types.js';
import { BaseSession, type TokenCredentials } from './base-session.js';
/**
 * Server interface for in-process communication
 */
export interface InProcessServer {
    start(): Promise<void>;
    handleInit(ctx: InProcessRequestContext): Promise<unknown>;
    getDefinitions(ctx?: InProcessRequestContext): Promise<unknown>;
    getRuntimeDefinitions(ctx?: InProcessRequestContext): Promise<string>;
    getInfo(): unknown;
    handleSearch(ctx: InProcessRequestContext): Promise<unknown>;
    handleExplore(ctx: InProcessRequestContext): Promise<unknown>;
    handleExecute(ctx: InProcessRequestContext): Promise<unknown>;
    handleResume(ctx: InProcessRequestContext, executionId: string): Promise<unknown>;
}
/**
 * Request context for in-process server calls
 */
export interface InProcessRequestContext {
    method: string;
    path: string;
    query: Record<string, string>;
    headers: Record<string, string>;
    body: unknown;
    clientId?: string;
    clientToken?: string;
    userId?: string;
    user?: unknown;
    executionId?: string;
    code?: string;
    validation?: unknown;
    result?: unknown;
    error?: Error;
    logger: {
        debug: () => void;
        info: () => void;
        warn: () => void;
        error: () => void;
    };
    status: number;
    responseBody: unknown;
    throw(status: number, message: string): never;
    assert(condition: boolean, message: string): asserts condition;
    set(header: string, value: string): void;
}
/**
 * In-process session for direct server communication without HTTP.
 * Used when the client and server run in the same process.
 */
export declare class InProcessSession extends BaseSession {
    private server;
    private initialized;
    constructor(server: InProcessServer, tokenRefreshConfig?: Partial<TokenRefreshConfig>);
    /**
     * Initializes the client session with the in-process server.
     */
    init(clientInfo?: {
        name?: string;
        version?: string;
        [key: string]: unknown;
    }, tools?: ClientToolDefinition[], services?: {
        hasLLM: boolean;
        hasApproval: boolean;
        hasEmbedding: boolean;
        hasTools: boolean;
    }): Promise<TokenCredentials>;
    /**
     * Ensures the client is initialized before making requests.
     */
    ensureInitialized(): Promise<void>;
    /**
     * Creates headers for in-process requests (lowercase for consistency with Node.js)
     */
    getHeaders(): Record<string, string>;
    getBaseUrl(): string;
    /**
     * Prepares headers for a request, refreshing token if needed
     */
    prepareHeaders(_method: string, url: string, _body?: unknown): Promise<Record<string, string>>;
    getDefinitions(options?: {
        apiGroups?: string[];
    }): Promise<{
        typescript: string;
        version: string;
        apiGroups: string[];
    }>;
    getRuntimeDefinitions(options?: {
        apis?: string[];
    }): Promise<string>;
    getServerInfo(): Promise<{
        version: string;
        capabilities: Record<string, boolean>;
    }>;
    search(query: string, options?: Record<string, unknown>): Promise<{
        results: unknown[];
    }>;
    explore(path: string, options?: Record<string, unknown>): Promise<unknown>;
    execute(code: string, config?: Record<string, unknown>): Promise<unknown>;
    resume(executionId: string, callbackResult: unknown): Promise<unknown>;
    resumeWithBatchResults(executionId: string, batchResults: Array<{
        id: string;
        result: unknown;
    }>): Promise<unknown>;
    /**
     * Creates a request context for in-process server calls
     */
    private createContext;
}
//# sourceMappingURL=in-process-session.d.ts.map