/**
 * @fileoverview Core API client (isomorphic HTTP + SSE wrappers)
 * Simplicity first: minimal surface needed for CLI/MCP/Dashboard.
 */
import type { CrashReport, LogRecord } from "@ai-kod/common";
import type { SSEMessage } from "./lib/sse.js";
export interface ApiClientOptions {
    baseUrl: string;
    token?: string;
    fetchImpl?: typeof fetch;
}
export interface StreamOptions {
    eventTypes?: string[];
    priority?: string;
    taskId?: string;
    cursor?: string;
    initial?: number;
    blockMs?: number;
    signal?: AbortSignal;
}
export interface LogsReadOptions {
    sources?: string[];
    from?: string;
    to?: string;
    level?: string[];
    taskId?: string;
    stepId?: string;
    process?: string;
    limit?: number;
}
export interface LogsTailOptions {
    sources?: string[];
    from?: string;
    to?: string;
    level?: string[];
    taskId?: string;
    stepId?: string;
    process?: string;
    initial?: number;
    timeoutMs?: number;
    heartbeatMs?: number;
    signal?: AbortSignal;
}
export interface ActiveTailSessionInfo {
    sessionId: string;
    connectionId: string;
    sources: string[];
    startedAt: string;
    lastHeartbeatAt: string;
    entriesEmitted: number;
    clientIp?: string | null;
    userAgent?: string;
}
export interface LogsStreamsMetadata {
    eventStreamLength: number | null;
    tailLimit: number;
    activeTailSessions?: {
        count: number;
        example: ActiveTailSessionInfo[];
    };
}
export interface LogsStreamsResponse {
    success: boolean;
    sources: string[];
    metadata?: LogsStreamsMetadata;
    timestamp?: string;
}
export interface LogsReadResponse {
    success: true;
    entries: LogRecord[];
    pagination: {
        limit: number;
        fetched: number;
    };
    timestamp: string;
}
export interface LogsTailHeartbeat {
    type: "heartbeat";
    connectionId: string;
    sessionId: string;
    lastActivityAt: string;
    entriesEmitted: number;
    timestamp: string;
}
export interface LogsTailConnection {
    type: "connection";
    connectionId: string;
    timestamp: string;
}
export interface LogsTailEnd {
    type: "end";
    reason: string;
    timestamp: string;
}
export interface LogsTailEntry<T = LogRecord> {
    type: "entry";
    entry: T;
}
export interface LogsTailUnknown {
    type: "unknown";
    raw: SSEMessage;
}
export type ParsedLogsTailMessage<T = LogRecord> = LogsTailConnection | LogsTailHeartbeat | LogsTailEnd | LogsTailEntry<T> | LogsTailUnknown;
export interface LogsTailStream extends AsyncIterable<ParsedLogsTailMessage<LogRecord>> {
    close(): void;
}
export interface TasksListOptions {
    testOnly?: boolean;
    testSuite?: string;
    testSessionId?: string;
}
export interface TaskGlobalResponse {
    success: boolean;
    data: {
        taskId: string;
        global: Record<string, unknown>;
        updated_at: string;
    };
    correlationId?: string;
}
export interface TaskCrashReportListItem {
    reportId: string;
    filename: string;
    absolutePath: string;
    createdAt: string;
    size: number;
    scope: "task" | "step";
    stepId?: string;
}
export interface TaskCrashReportsResponse {
    success: boolean;
    data: {
        taskId: string;
        reports: TaskCrashReportListItem[];
    };
    correlationId?: string;
}
export interface TaskCrashReportResponse {
    success: boolean;
    data: {
        taskId: string;
        scope: "task" | "step";
        stepId?: string;
        report: CrashReport;
    };
    correlationId?: string;
}
export interface WorkflowsListOptions {
    folder?: string;
}
export interface WorkflowInputSchemaResponse {
    success: boolean;
    data: {
        workflow_id: string;
        schema_available: boolean;
        schema_id?: string;
        schema_kind?: string;
        schema_version?: number;
        json_schema: Record<string, unknown>;
        template: Record<string, unknown>;
        required: string[];
        definitions: Array<Record<string, unknown>>;
        files: {
            schema: string;
            template: string;
        };
    };
}
export type WorkflowItemKind = "bundle" | "package" | "prompt" | "mcp" | "skills";
export type WorkflowInstallMode = "copy" | "link";
export type WorkflowItemSource = {
    type: "git";
    provider: string;
    repository: string;
    ref: string;
    commit: string;
    protocol?: "https" | "ssh";
} | {
    type: "path";
    path: string;
} | {
    type: "bundle";
    bundleName: string;
    bundlePath: string;
};
export interface WorkflowItemMetadata {
    id: string;
    kind: WorkflowItemKind;
    name: string;
    version: string;
    path: string;
    relativePath: string;
    installedAt: string;
    updatedAt: string;
    source: WorkflowItemSource;
    installMode: WorkflowInstallMode;
    integrity: string;
    providedBy?: {
        kind: "bundle";
        name: string;
    };
    required?: boolean;
    labels?: string[];
    bundle?: {
        id: string;
        version: string;
        namespace?: string;
        manifestPath: string;
        defaultWorkflowId?: string | null;
        defaultWorkflowFile?: string | null;
    };
}
export interface WorkflowInstallPayload {
    kind: WorkflowItemKind;
    repo: string;
    ref?: string;
    name?: string;
    provider?: string;
    subPath?: string;
    protocol?: "https" | "ssh";
    depth?: number;
    force?: boolean;
}
export interface WorkflowUninstallPayload {
    kind: WorkflowItemKind;
    name: string;
}
export interface WorkflowListOptions {
    kind?: WorkflowItemKind;
}
export interface WorkflowListResponse {
    items: WorkflowItemMetadata[];
}
export interface McpStatusResponse {
    item: WorkflowItemMetadata;
    manifest: unknown;
    manifestPath: string;
    requiredTools: string[];
}
export declare function createClient(options: ApiClientOptions): {
    /** Health endpoint */
    health: {
        get: () => Promise<any>;
    };
    workflow: {
        install: (payload: WorkflowInstallPayload) => Promise<WorkflowItemMetadata>;
        uninstall: (payload: WorkflowUninstallPayload) => Promise<{
            removed: boolean;
        }>;
        list: (options?: WorkflowListOptions) => Promise<WorkflowListResponse>;
        workflows: () => Promise<WorkflowListResponse>;
        packages: () => Promise<WorkflowListResponse>;
        mcpStatus: (name: string) => Promise<McpStatusResponse>;
    };
    /** V7 events */
    events: {
        /**
         * Connect to SSE event stream (JSONL per event).
         * Returns an async iterator of SSEMessage, and exposes close() via controller.
         */
        stream: (opts?: StreamOptions) => AsyncIterable<SSEMessage> & {
            close(): void;
        };
        /** Stats */
        stats: () => Promise<any>;
    };
    /** Fire WORKFLOW_STARTING via V7 events facade */
    workflows: {
        run: (workflowId: string, payload: {
            inputs?: Record<string, unknown>;
            prompt?: unknown;
            runMode?: "default" | "step_by_step";
            testMetadata?: Record<string, unknown>;
            engineProfile?: string | null;
            engineOptions?: Record<string, unknown>;
            engineOverride?: {
                engine?: string;
                profile?: string | null;
                options?: Record<string, unknown>;
            } | null;
        }) => Promise<any>;
        runStarting: (payload: {
            taskId: string;
            workflowId: string;
            inputs?: Record<string, unknown>;
        }) => Promise<any>;
        list: (opts?: WorkflowsListOptions) => Promise<any>;
        get: (workflowId: string) => Promise<any>;
        getLayout: (workflowId: string) => Promise<any>;
        relayout: (workflowId: string, payload?: {
            direction?: "DOWN" | "RIGHT";
        }) => Promise<any>;
        getInputSchema: (workflowId: string) => Promise<WorkflowInputSchemaResponse>;
    };
    /** Tasks facade (MVP) */
    tasks: {
        list: (opts?: TasksListOptions) => Promise<any>;
        get: (taskId: string) => Promise<any>;
        global: (taskId: string) => Promise<TaskGlobalResponse>;
        listCrashReports: (taskId: string) => Promise<TaskCrashReportsResponse>;
        getCrashReport: (taskId: string, reportId: string) => Promise<TaskCrashReportResponse>;
        listSteps: (taskId: string) => Promise<any>;
        getStepFiles: (taskId: string, stepId: string) => Promise<any>;
        pause: (taskId: string) => Promise<any>;
        resume: (taskId: string) => Promise<any>;
        stop: (taskId: string) => Promise<any>;
    };
    steps: {
        getExecution: (taskId: string, stepId: string) => Promise<any>;
        rerun: (taskId: string, stepId: string) => Promise<any>;
        run: (taskId: string, stepId: string, mode?: "default" | "step_by_step") => Promise<any>;
        streamLogs: (taskId: string, stepId: string, opts?: {
            signal?: AbortSignal;
        }) => AsyncIterable<SSEMessage> & {
            close(): void;
        };
    };
    workers: {
        list: () => Promise<any>;
        get: (workerId: string) => Promise<any>;
    };
    logs: {
        /** Describe available streams (MVP: events stream only) */
        streams: () => Promise<LogsStreamsResponse>;
        /** Read recent log entries with optional filters */
        read: (opts?: LogsReadOptions) => Promise<LogsReadResponse>;
        /** Tail logs via SSE with optional filters */
        tail: (opts?: LogsTailOptions) => LogsTailStream;
    };
    system: {
        stats: () => Promise<any>;
        versions: () => Promise<any>;
    };
};
export type { SSEMessage } from "./lib/sse.js";
export declare function parseLogsTailMessage<T = LogRecord>(message: SSEMessage): ParsedLogsTailMessage<T> | undefined;