import './pre-init.js';
import { applyStoredModelSelections } from './config/model-store.js';
import { type ImageGenerationOptions, type ImageGenerationResult } from './tools/image-generate.tool.js';
import { buildSituationBrief } from './tools/situational-awareness.tool.js';
import { loadSessionHandoff } from './tools/session-continuity.tool.js';
import { clearMemories, forget, listMemories, type LongTermMemory } from './memory/long-term.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';
export type { ConfirmationHandler, ConfirmationRequest, ProgressEvent };
export { clearSessionApprovals, applyStoredModelSelections, buildSituationBrief, loadSessionHandoff };
export type { ZilMateVoiceConfig, ZilMateVoiceSessionOptions, ZilMateVoiceSessionResult };
export type { ImageGenerationOptions, ImageGenerationResult, LongTermMemory };
export type { CreateJobInput, JobLog, JobStatus, ListJobsOptions, ZilMateJob };
export type ZilMateOptions = {
    sessionId?: string;
    onProgress?: (event: ProgressEvent) => void;
    confirm?: ConfirmationHandler;
};
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 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: typeof listMemories;
    forget: typeof forget;
    clearMemories: typeof clearMemories;
    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: () => ZilMateVoiceConfig;
    startVoiceSession: (input?: ZilMateVoiceSessionOptions) => Promise<ZilMateVoiceSessionResult>;
};
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>;
//# sourceMappingURL=server.d.ts.map