import './pre-init.js';
import { applyStoredModelSelections } from './config/model-store.js';
import type { ConfirmationHandler, ConfirmationRequest } from './runtime/confirm.js';
import { clearSessionApprovals } from './runtime/confirm.js';
import type { ProgressEvent } from './runtime/progress.js';
import type { CreateJobInput, JobLog, JobStatus, ListJobsOptions, ZilMateJob } from './jobs/types.js';
import type { ZilMateVoiceConfig, ZilMateVoiceSessionOptions, ZilMateVoiceSessionResult } from './voice/types.js';
import type { ImageGenerationOptions, ImageGenerationResult } from './tools/image-generate.tool.js';
import type { LongTermMemory } from './memory/long-term.js';
export type { ConfirmationHandler, ConfirmationRequest, ProgressEvent };
export { clearSessionApprovals, applyStoredModelSelections };
export type { ZilMateVoiceConfig, ZilMateVoiceSessionOptions, ZilMateVoiceSessionResult };
export type { ImageGenerationOptions, ImageGenerationResult };
export type { LongTermMemory };
export type { CreateJobInput, JobLog, JobStatus, ListJobsOptions, ZilMateJob };
export type ZilMateAuditEvent = {
    requestId: string;
    sessionId: string;
    action: string;
    phase: 'start' | 'success' | 'error';
    status: 'ok' | 'error';
    timestamp: string;
    detail?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
};
export type ZilMateAuditHandler = (event: ZilMateAuditEvent) => void;
export type ZilMateOptions = {
    sessionId?: string;
    onProgress?: (event: ProgressEvent) => void;
    confirm?: ConfirmationHandler;
    onAudit?: ZilMateAuditHandler;
};
export type ZilMateTextInput = {
    message: string;
};
export type ZilMatePromptInput = {
    prompt: string;
};
export type ZilMateQuestionInput = {
    question: string;
};
export type ZilMateResearchInput = {
    query: string;
};
export type ZilMateMemoryInput = {
    text: string;
    tags?: string[];
};
export type ZilMateRecallInput = {
    query?: string;
    limit?: number;
};
export type ZilMateTextResult = {
    text: string;
};
export type ZilMateSubagentName = 'quickHelp' | 'chat' | 'post' | 'image' | 'research' | 'automationPlanner' | 'personalAssistant' | 'developerHelper' | 'security' | 'coding' | 'goalManager' | 'finance' | 'digitalCorporation' | (string & {});
export type ZilMateSubagentInput = {
    subagent: ZilMateSubagentName;
    prompt: string;
};
export declare function resolveSubagentRoute(subagent: ZilMateSubagentName): 'specialist' | 'swarm' | 'manager';
export declare function createZilMate(options?: ZilMateOptions): {
    chat: (input: ZilMateTextInput) => Promise<ZilMateTextResult>;
    manager: (input: ZilMateTextInput | ZilMatePromptInput) => Promise<ZilMateTextResult>;
    help: (input: ZilMateQuestionInput | ZilMateTextInput) => Promise<ZilMateTextResult>;
    guide: (input: ZilMateTextInput) => Promise<ZilMateTextResult>;
    post: (input: ZilMatePromptInput) => Promise<ZilMateTextResult>;
    research: (input: ZilMateResearchInput | ZilMateTextInput) => Promise<ZilMateTextResult>;
    coding: (input: ZilMatePromptInput) => Promise<ZilMateTextResult>;
    imageAgent: (input: ZilMatePromptInput) => Promise<ZilMateTextResult>;
    goalManager: (input: ZilMatePromptInput) => Promise<ZilMateTextResult>;
    situation: (input?: {
        sessionId?: string;
    }) => Promise<{
        sessionId: string;
        cwd: string;
        package: string;
        platform: string;
        workspace: string;
        models: {
            manager: string;
            coding: string;
            image: string;
            overrides: Partial<Record<import("./config/model-store.js").ModelRole, string>>;
        };
        capabilities: {
            gateway: boolean;
            composio: boolean;
            redis: boolean;
            qstash: boolean;
            jobs: boolean;
            voice: boolean;
        };
        git: string;
        recentJobs: {
            id: string;
            status: JobStatus;
            task: string;
        }[];
        memoryCount: number;
        owner: string;
        activeProjects: string[];
        knowledgeNodes: number;
    }>;
    handoff: (input?: {
        sessionId?: string;
    }) => Promise<{
        sessionId: string;
        summary: string;
        nextActions: string[];
        openThreads: string[];
        updatedAt: string;
    } | null>;
    image: (input: ZilMatePromptInput & ImageGenerationOptions) => Promise<ImageGenerationResult>;
    remember: (input: ZilMateMemoryInput) => Promise<LongTermMemory>;
    recall: (input?: ZilMateRecallInput) => Promise<LongTermMemory[]>;
    listMemories: () => Promise<LongTermMemory[]>;
    forget: (input: string | string[]) => Promise<boolean>;
    clearMemories: () => Promise<void>;
    createJob: (input: CreateJobInput) => Promise<ZilMateJob>;
    listJobs: (input?: ListJobsOptions) => Promise<ZilMateJob[]>;
    getJob: (id: string) => Promise<ZilMateJob | null>;
    getJobLogs: (id: string) => Promise<JobLog[]>;
    runJob: (id: string) => Promise<ZilMateJob>;
    runDueJobs: () => Promise<number>;
    handleJobWebhook: (input: {
        jobId: string;
        secret?: string;
    }, expectedSecret?: string) => Promise<ZilMateJob>;
    cancelJob: (id: string) => Promise<ZilMateJob | null>;
    getVoiceConfig: () => Promise<ZilMateVoiceConfig>;
    startVoiceSession: (input?: ZilMateVoiceSessionOptions) => Promise<ZilMateVoiceSessionResult>;
    callSubagent: (input: ZilMateSubagentInput) => Promise<ZilMateTextResult>;
};
export declare function chat(input: ZilMateTextInput, options?: ZilMateOptions): Promise<ZilMateTextResult>;
export declare function help(input: ZilMateQuestionInput | ZilMateTextInput, options?: ZilMateOptions): Promise<ZilMateTextResult>;
export declare function post(input: ZilMatePromptInput, options?: ZilMateOptions): Promise<ZilMateTextResult>;
export declare function research(input: ZilMateResearchInput | ZilMateTextInput, options?: ZilMateOptions): Promise<ZilMateTextResult>;
export declare function image(input: ZilMatePromptInput & ImageGenerationOptions): Promise<ImageGenerationResult>;
export declare function callSubagent(input: ZilMateSubagentInput, options?: ZilMateOptions): Promise<ZilMateTextResult>;
//# sourceMappingURL=server.d.ts.map