orchestrator-client 5.6.0

package/dist/index.d.cts

@@ -0,0 +1,907 @@
+interface Pagination$1 {
+    currentPage: number;
+    perPage: number;
+    totalItems: number;
+    totalPages: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+}
+
+/** Pagination metadata returned by paginated list endpoints. */
+interface Pagination {
+    currentPage: number;
+    perPage: number;
+    totalItems: number;
+    totalPages: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+}
+/** Core task summary — returned in list endpoints. */
+interface TaskSummary {
+    id: string;
+    status: string;
+    workflowId: string;
+    iteration: number;
+    maxIterations: number;
+    goalPrompt: string;
+    result: string;
+    resultLocalized: string | null;
+    approvalReason: string;
+    ticketId: string | null;
+    availableTools: string[] | null;
+    insight: string | null;
+    insightLocalized: string | null;
+    createdAt: string;
+    updatedAt: string;
+    pendingTranslationsForLocales?: string[] | null;
+}
+/** Per-task feature toggles set at creation time. */
+interface TaskOptions {
+    disableSummaries: boolean;
+    disableTranslation: boolean;
+}
+/** Full task status including fields returned by GET /task/status. */
+interface TaskDetail extends TaskSummary {
+    subtaskIds: string[];
+    workflowData: Record<string, unknown> | null;
+    options: Record<string, unknown> | null;
+}
+interface TaskListResult {
+    tasks: TaskSummary[];
+    pagination: Pagination;
+}
+interface TaskCreateResponse {
+    taskId: string;
+    status: string;
+}
+interface TaskCancelResponse {
+    taskId: string;
+    killed: boolean;
+}
+interface VSATaskCreateResponse extends TaskCreateResponse {
+}
+interface TaskDeleteResult {
+    deletedTasks: string[];
+    failedTasks: string[];
+    totalDeleted: number;
+    totalFailed: number;
+}
+
+interface AttachmentMeta {
+    id: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    width: number | null;
+    height: number | null;
+    tokenCount: number | null;
+}
+interface ToolCall {
+    id: string;
+    type: string;
+    function: Record<string, unknown>;
+}
+interface Message {
+    id: number;
+    role: string;
+    content: string;
+    createdAt: string;
+    kind: string | null;
+    name: string | null;
+    toolCalls: ToolCall[] | null;
+    toolCallId: string | null;
+    reasoning: string | null;
+    reasoningSummary: string | null;
+    toolCallSummary: string | null;
+    toolOutputSummary: string | null;
+    summarySource: string | null;
+    archived: boolean;
+    archivedReason: string | null;
+    attachments: AttachmentMeta[];
+}
+interface ConversationResult {
+    taskId: string;
+    conversation: Message[];
+}
+interface MatrixConversationResult {
+    taskId: string;
+    conversation: Message[];
+}
+interface ArchivedContent {
+    id: number;
+    content: string;
+    archived: boolean;
+    archivedReason: string | null;
+    createdAt: string;
+}
+interface MessageTranslation {
+    locale: string;
+    kind: string;
+    translatedText: string;
+    isFallback: boolean;
+    createdAt: string | null;
+}
+interface MessageTranslationsResult {
+    messageId: number;
+    translations: MessageTranslation[];
+}
+interface MessageTranslationReadyEvent {
+    taskId: string;
+    messageId: number;
+    locale: string;
+    messageIndex: number;
+    translatedContent: string | null;
+    translatedReasoning: string | null;
+    translatedReasoningSummary: string | null;
+    translatedToolCallSummary: string | null;
+    translationFailed: boolean;
+    eventType: string;
+}
+
+interface ErrorEvent {
+    id: string;
+    createdAt: string;
+    severity: string;
+    source: string;
+    taskId: string | null;
+    workflowId: string | null;
+    errorCode: string | null;
+    exceptionType: string | null;
+    message: string;
+    holderId: string | null;
+    requestId: string | null;
+}
+interface ErrorEventDetail extends ErrorEvent {
+    traceback: string | null;
+    context: Record<string, unknown> | null;
+}
+interface ErrorStatsResult {
+    total: number;
+    bySeverity: Record<string, number>;
+    bySource: Record<string, number>;
+    byWorkflowId: Record<string, number>;
+    byExceptionType: Record<string, number>;
+    topTaskIds: Record<string, unknown>[];
+    topHolderIds: Record<string, unknown>[];
+}
+interface ErrorCountResult {
+    count: number;
+}
+interface ErrorPurgeResult {
+    deleted: number;
+}
+
+interface HealthStatus {
+    status: string;
+    message: string;
+    version: string;
+}
+interface ComponentHealth {
+    connected: boolean | null;
+    running: boolean | null;
+    latencyMs: number | null;
+}
+interface HealthDetail extends HealthStatus {
+    components: Record<string, ComponentHealth>;
+}
+interface ReadinessCheck {
+    ok: boolean;
+    detail: string | null;
+}
+interface ReadinessResult {
+    ready: boolean;
+    reason: string | null;
+    isStartupComplete: boolean;
+    isShuttingDown: boolean;
+    checks: Record<string, ReadinessCheck>;
+}
+interface LockStatus {
+    name: string;
+    isLeader: boolean;
+    isRunning: boolean;
+    ttlSeconds: number;
+    token: string | null;
+}
+interface LeaderStatus {
+    holderId: string;
+    locks: LockStatus[];
+}
+interface MetricSnapshot {
+    uptimeSeconds: number | null;
+    activeTasks: number | null;
+    openTasks: number | null;
+    llmGeneratedTokens: number | null;
+    llmAvgResponseTimeSec: number | null;
+    llmRequestsPerMinute: number | null;
+    avgTaskSolutionTimeSec: number | null;
+}
+
+interface SystemStatusSettings {
+    agentModelId: string | null;
+    orchestratorModelId: string | null;
+    compactorModelId: string | null;
+    journalModelId: string | null;
+    summaryModelId: string | null;
+    translateModelId: string | null;
+    maxConcurrentTasksPerReplica: number | null;
+    subagentsEnabled: boolean | null;
+    localizationTargets: Record<string, string>[] | null;
+}
+interface SystemStatus {
+    isConfigured: boolean;
+    missingFields: string[];
+    settings: SystemStatusSettings;
+    version: number;
+}
+interface LLMBackendInfo {
+    host: string;
+    models: string[];
+}
+interface MCPServerInfo {
+    baseUrl: string;
+    name: string;
+    description: string;
+    tools: string[];
+}
+interface TaskHandlerReplica {
+    holderId: string;
+    maxConcurrentTasksPerReplica: number;
+    currentlyRunningTasks: number;
+    runningTaskIds: string[];
+    leaseTtlSeconds: number;
+    startedAt: string;
+    lastHeartbeatAt: string;
+}
+interface TaskHandlerCluster {
+    maxConcurrentTasksPerReplica: number;
+    currentlyRunningTasks: number;
+    runningTaskIds: string[];
+    replicasAlive: number;
+    queuedTasks: number;
+    activeTasks: number;
+    totalTasks: number;
+}
+interface TaskHandlerStatus {
+    cluster: TaskHandlerCluster;
+    replicas: TaskHandlerReplica[];
+}
+interface TaskHandlerStatusLocal {
+    running: boolean;
+    maxConcurrentTasks: number;
+    currentlyRunningTasks: number;
+    runningTaskIds: string[];
+    holderId: string;
+    totalTasks: number;
+    queuedTasks: number;
+    activeTasks: number;
+}
+interface SummaryWorkerStatus {
+    running: boolean;
+    uptimeSeconds: number;
+    maxConcurrentSummaries: number;
+    processedCount: number;
+    queuedCount: number;
+    pendingCount: number;
+    queueSize: number;
+    errorCount: number;
+    modelId: string;
+    translateModelId: string;
+    isLeader: boolean;
+}
+interface TokenWorkerStatus {
+    running: boolean;
+    uptimeSeconds: number;
+    processedCount: number;
+    queueSize: number;
+    errorCount: number;
+    encoding: string;
+}
+interface SlotInfo {
+    id: string;
+    ip: string;
+    status: string;
+    taskId: string | null;
+    lastActivity: string | null;
+    idleSeconds: number | null;
+}
+interface SlotsStatus {
+    enabled: boolean;
+    totalSlots: number;
+    availableSlots: number;
+    slotTools: string[];
+    acquireTimeoutSeconds: number;
+    slots: SlotInfo[];
+}
+interface ConfigurationStatus {
+    agentModel: string | null;
+    orchestratorModel: string | null;
+    summaryModel: string | null;
+    translateModel: string | null;
+    localizationTargets: Record<string, string>[];
+    llmbackends: LLMBackendInfo[];
+    mcpservers: MCPServerInfo[];
+    builtinTools: string[];
+}
+
+interface ToolInfo {
+    name: string;
+    description: string;
+    server: string;
+}
+interface ToolsListResult {
+    tools: ToolInfo[];
+    totalTools: number;
+    servers: string[];
+}
+
+interface CompactionEvent {
+    id: number;
+    taskId: string;
+    triggeredAt: string;
+    triggerReason: string;
+    preTokenCount: number;
+    postTokenCount: number;
+    clearedToolCount: number;
+    messagesArchived: number;
+    boundaryMessageId: number | null;
+    consecutiveFailuresAtStart: number;
+    durationMs: number;
+    workflowId: string;
+    compactorModelId: string;
+}
+interface TaskJournal {
+    taskId: string;
+    exists: boolean;
+    content: string | null;
+    updatedAt: string | null;
+    version: number | null;
+    sectionsOverBudget: Record<string, number> | null;
+}
+interface AttachmentUploadResponse {
+    id: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    width: number | null;
+    height: number | null;
+    tokenCount: number | null;
+}
+
+interface AuthConfig {
+    keycloakEnabled: boolean;
+    keycloakUrl: string | null;
+    keycloakRealm: string | null;
+    keycloakClientId: string | null;
+}
+interface WebSocketClientInfo {
+    clientId: string;
+    subscription: Record<string, unknown>;
+    connected: boolean;
+}
+interface WebSocketStatus {
+    connectedClients: number;
+    clients: WebSocketClientInfo[];
+}
+
+interface SuccessResponse {
+    message: string;
+}
+interface MioContext {
+    taskId: string;
+    currentTokens: number;
+    contextLimit: number;
+    usagePercentage: number;
+    archivedCount: number;
+    activeCount: number;
+}
+interface WorkflowStates {
+    validStates: Record<string, string[]>;
+    processableStates: Record<string, string[]>;
+    waitingStates: Record<string, string[]>;
+    stoppedStates: Record<string, string[]>;
+    intermediateStates: Record<string, string[]>;
+}
+
+/**
+ * OrchestratorAsync — async REST API wrapper for the DAMIT AIOps Orchestrator.
+ *
+ * Provides a complete mapping of the orchestrator's HTTP endpoints using
+ * native fetch with automatic retry (exponential backoff), typed responses,
+ * and configurable auth via bearer token or callback.
+ *
+ * Usage:
+ *
+ *   const client = new OrchestratorAsync({ baseUrl: "http://localhost:8080" });
+ *   const tasks = await client.listTasks({ workflowId: "proactive" });
+ *   for (const t of tasks.tasks) {
+ *     console.log(t.id, t.status);
+ *   }
+ *   await client.close();
+ */
+
+interface OrchestratorClientOptions {
+    /** Base URL of the orchestrator (e.g. "http://localhost:8080"). */
+    baseUrl?: string;
+    /** Optional static bearer token. */
+    apiKey?: string;
+    /** Async function that returns a bearer token (called on each request). */
+    getToken?: () => string | Promise<string>;
+    /** Request timeout in milliseconds (default: 30000). */
+    timeoutMs?: number;
+    /** Max retry attempts on transient failures (default: 3). */
+    maxRetries?: number;
+    /**
+     * Custom fetch implementation override.
+     *
+     * Use this to inject a fetch that ignores SSL errors (self-signed certs):
+     *
+     *   new Orchestrator({
+     *     fetch: await createInsecureFetch(),
+     *   })
+     *
+     * When not provided, `globalThis.fetch` is used.
+     */
+    fetch?: typeof globalThis.fetch;
+    /**
+     * Allow self-signed / invalid SSL certificates.
+     *
+     * When true and no custom `fetch` is provided, creates an internal fetch
+     * that uses Node.js `https.Agent` with `rejectUnauthorized: false`.
+     * Only works in Node.js; ignored in browsers.
+     */
+    insecure?: boolean;
+}
+declare class OrchestratorAsync {
+    protected _baseUrl: string;
+    protected _apiKey: string | undefined;
+    protected _getToken: (() => string | Promise<string>) | undefined;
+    protected _timeoutMs: number;
+    protected _maxRetries: number;
+    protected _fetch: typeof globalThis.fetch;
+    protected _abortController: AbortController | null;
+    constructor(opts?: OrchestratorClientOptions);
+    protected _insecure: boolean;
+    close(): Promise<void>;
+    protected _makeUrl(path: string): string;
+    protected _resolveHeaders(): Promise<Record<string, string>>;
+    protected _request(method: string, path: string, opts?: {
+        jsonBody?: unknown;
+        params?: Record<string, string | number | boolean | undefined>;
+        headers?: Record<string, string>;
+        rawResponse?: boolean;
+        signal?: AbortSignal;
+    }): Promise<Response | unknown>;
+    protected _get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    protected _post<T>(path: string, body?: unknown): Promise<T>;
+    protected _put<T>(path: string, body?: unknown): Promise<T>;
+    protected _delete<T>(path: string): Promise<T>;
+    listTasks(params?: {
+        workflowId?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+        sortBy?: string;
+        sortOrder?: string;
+    }): Promise<TaskListResult>;
+    createTask(params: {
+        workflowId: string;
+        goalPrompt: string;
+        maxIterations?: number;
+        options?: Record<string, boolean>;
+        ticketId?: string;
+        title?: string;
+        modelId?: string;
+    }): Promise<TaskCreateResponse>;
+    getTaskStatus(taskId: string): Promise<TaskDetail>;
+    getTaskConversation(taskId: string): Promise<ConversationResult>;
+    getArchivedMessageContent(taskId: string, messageId: number): Promise<Record<string, unknown>>;
+    getTaskCompactions(taskId: string): Promise<CompactionEvent[]>;
+    getTaskJournal(taskId: string): Promise<TaskJournal>;
+    cancelTask(taskId: string): Promise<SuccessResponse>;
+    deleteTask(taskId: string): Promise<TaskDeleteResult>;
+    deleteTasks(taskIds: string[]): Promise<TaskDeleteResult>;
+    uploadAttachment(taskId: string, file: File | Blob, filename?: string): Promise<AttachmentUploadResponse>;
+    downloadAttachment(taskId: string, attachmentId: string): Promise<Blob>;
+    sendInteractiveMessage(taskId: string, content: string): Promise<SuccessResponse>;
+    markInteractiveComplete(taskId: string): Promise<SuccessResponse>;
+    markInteractiveFailed(taskId: string): Promise<SuccessResponse>;
+    approveInteractiveAction(taskId: string): Promise<SuccessResponse>;
+    sendProactiveGuide(taskId: string, guide: string): Promise<SuccessResponse>;
+    respondProactiveHelp(taskId: string, response: string): Promise<SuccessResponse>;
+    approveProactiveAction(taskId: string): Promise<SuccessResponse>;
+    sendTicketGuide(taskId: string, guide: string): Promise<SuccessResponse>;
+    respondTicketHelp(taskId: string, response: string): Promise<SuccessResponse>;
+    approveTicketAction(taskId: string): Promise<SuccessResponse>;
+    wakeTicket(taskId: string): Promise<SuccessResponse>;
+    sendMatrixMessage(taskId: string, content: string): Promise<SuccessResponse>;
+    markMatrixComplete(taskId: string): Promise<SuccessResponse>;
+    markMatrixFailed(taskId: string): Promise<SuccessResponse>;
+    approveMatrixAction(taskId: string): Promise<SuccessResponse>;
+    getMatrixConversation(taskId: string): Promise<MatrixConversationResult>;
+    createVSATask(params: {
+        goalPrompt: string;
+        title?: string;
+        modelId?: string;
+    }): Promise<VSATaskCreateResponse>;
+    sendVSAMessage(taskId: string, content: string): Promise<SuccessResponse>;
+    renameVSATask(taskId: string, title: string): Promise<SuccessResponse>;
+    regenerateVSATitle(taskId: string): Promise<SuccessResponse>;
+    markVSAComplete(taskId: string): Promise<SuccessResponse>;
+    markVSAFailed(taskId: string): Promise<SuccessResponse>;
+    stopVSA(taskId: string): Promise<SuccessResponse>;
+    deleteVSA(taskId: string): Promise<SuccessResponse>;
+    listVSATasks(params?: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<TaskListResult>;
+    searchVSATasks(query: string): Promise<TaskListResult>;
+    deleteVSATasksBulk(taskIds: string[]): Promise<SuccessResponse>;
+    sendMioMessage(taskId: string, content: string): Promise<SuccessResponse>;
+    approveMioAction(taskId: string): Promise<SuccessResponse>;
+    wakeMio(taskId: string): Promise<SuccessResponse>;
+    sendMioUserAway(taskId: string): Promise<SuccessResponse>;
+    markMioComplete(taskId: string): Promise<SuccessResponse>;
+    markMioFailed(taskId: string): Promise<SuccessResponse>;
+    archiveMio(taskId: string): Promise<SuccessResponse>;
+    getMioContext(taskId: string): Promise<MioContext>;
+    listTools(): Promise<ToolsListResult>;
+    getWorkflowStates(): Promise<WorkflowStates>;
+    updateTaskModels(taskId: string, models: {
+        agent?: string;
+        orchestrator?: string;
+    }): Promise<SuccessResponse>;
+    updateTaskIteration(taskId: string, iteration: number): Promise<SuccessResponse>;
+    updateTaskWorkflowData(taskId: string, workflowData: Record<string, unknown>): Promise<SuccessResponse>;
+    deleteMessage(taskId: string, messageId: number): Promise<SuccessResponse>;
+    deleteMessages(taskId: string, messageIds: number[]): Promise<SuccessResponse>;
+    updateMessage(taskId: string, messageId: number, update: {
+        content?: string;
+        reasoning?: string;
+    }): Promise<SuccessResponse>;
+    resetMatrixToPhase(taskId: string, phase: number): Promise<SuccessResponse>;
+    getMessageTranslations(taskId: string, messageId: number, locale?: string): Promise<MessageTranslationsResult>;
+    listErrors(params?: {
+        since?: string;
+        severity?: string;
+        source?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ErrorEventDetail[]>;
+    getErrorDetail(errorId: string): Promise<ErrorEventDetail>;
+    getErrorStats(since?: string): Promise<ErrorStatsResult>;
+    countErrors(since?: string): Promise<ErrorCountResult>;
+    purgeErrors(): Promise<ErrorPurgeResult>;
+    health(): Promise<HealthStatus>;
+    healthDetailed(): Promise<HealthDetail>;
+    ready(): Promise<ReadinessResult>;
+    healthLeader(): Promise<LeaderStatus>;
+    getMetrics(types?: string): Promise<MetricSnapshot>;
+    getSystemStatus(): Promise<SystemStatus>;
+    updateSettings(settings: Record<string, unknown>): Promise<SystemStatus>;
+    getConfigurationStatus(): Promise<ConfigurationStatus>;
+    setAgentModel(model: string): Promise<SuccessResponse>;
+    setOrchestratorModel(model: string): Promise<SuccessResponse>;
+    getLLMBackendStatus(): Promise<Record<string, unknown>>;
+    addLLMBackend(host: string, apiKey: string): Promise<SuccessResponse>;
+    removeLLMBackend(host: string): Promise<SuccessResponse>;
+    getMCPServerStatus(): Promise<Record<string, unknown>>;
+    addMCPServer(host: string, apiKey: string): Promise<SuccessResponse>;
+    removeMCPServer(host: string): Promise<SuccessResponse>;
+    getTaskHandlerStatus(): Promise<TaskHandlerStatus>;
+    getTaskHandlerStatusLocal(): Promise<TaskHandlerStatusLocal>;
+    setConcurrentTasksPerReplica(maxTasks: number): Promise<SuccessResponse>;
+    getSummaryWorkerStatus(): Promise<SummaryWorkerStatus>;
+    setCompactorModel(modelName: string): Promise<SuccessResponse>;
+    setTranslateModel(modelName: string): Promise<SuccessResponse>;
+    getTokenWorkerStatus(): Promise<TokenWorkerStatus>;
+    getSlotsStatus(): Promise<SlotsStatus>;
+    getAuthConfig(): Promise<AuthConfig>;
+    getWebSocketStatus(): Promise<WebSocketStatus>;
+    streamTaskStatus(taskId: string): AsyncGenerator<Record<string, unknown>>;
+}
+
+/**
+ * Synchronous wrapper around OrchestratorAsync.
+ *
+ * Manages its own resolution so every method returns synchronously.
+ * Cannot be used from within an active async context.
+ */
+declare class Orchestrator {
+    private _async;
+    constructor(opts?: OrchestratorClientOptions);
+    /** Close the underlying resources. */
+    close(): void;
+    listTasks(params?: Parameters<OrchestratorAsync["listTasks"]>[0]): TaskListResult;
+    createTask(params: Parameters<OrchestratorAsync["createTask"]>[0]): TaskCreateResponse;
+    getTaskStatus(taskId: string): TaskDetail;
+    getTaskConversation(taskId: string): ConversationResult;
+    getArchivedMessageContent(taskId: string, messageId: number): Record<string, unknown>;
+    getTaskCompactions(taskId: string): CompactionEvent[];
+    getTaskJournal(taskId: string): TaskJournal;
+    cancelTask(taskId: string): SuccessResponse;
+    deleteTask(taskId: string): TaskDeleteResult;
+    deleteTasks(taskIds: string[]): TaskDeleteResult;
+    uploadAttachment(taskId: string, file: File | Blob, filename?: string): AttachmentUploadResponse;
+    downloadAttachment(taskId: string, attachmentId: string): Blob;
+    sendInteractiveMessage(taskId: string, content: string): SuccessResponse;
+    markInteractiveComplete(taskId: string): SuccessResponse;
+    markInteractiveFailed(taskId: string): SuccessResponse;
+    approveInteractiveAction(taskId: string): SuccessResponse;
+    sendProactiveGuide(taskId: string, guide: string): SuccessResponse;
+    respondProactiveHelp(taskId: string, response: string): SuccessResponse;
+    approveProactiveAction(taskId: string): SuccessResponse;
+    sendTicketGuide(taskId: string, guide: string): SuccessResponse;
+    respondTicketHelp(taskId: string, response: string): SuccessResponse;
+    approveTicketAction(taskId: string): SuccessResponse;
+    wakeTicket(taskId: string): SuccessResponse;
+    sendMatrixMessage(taskId: string, content: string): SuccessResponse;
+    markMatrixComplete(taskId: string): SuccessResponse;
+    markMatrixFailed(taskId: string): SuccessResponse;
+    approveMatrixAction(taskId: string): SuccessResponse;
+    getMatrixConversation(taskId: string): MatrixConversationResult;
+    createVSATask(params: Parameters<OrchestratorAsync["createVSATask"]>[0]): VSATaskCreateResponse;
+    sendVSAMessage(taskId: string, content: string): SuccessResponse;
+    renameVSATask(taskId: string, title: string): SuccessResponse;
+    regenerateVSATitle(taskId: string): SuccessResponse;
+    markVSAComplete(taskId: string): SuccessResponse;
+    markVSAFailed(taskId: string): SuccessResponse;
+    stopVSA(taskId: string): SuccessResponse;
+    deleteVSA(taskId: string): SuccessResponse;
+    listVSATasks(params?: Parameters<OrchestratorAsync["listVSATasks"]>[0]): TaskListResult;
+    searchVSATasks(query: string): TaskListResult;
+    deleteVSATasksBulk(taskIds: string[]): SuccessResponse;
+    sendMioMessage(taskId: string, content: string): SuccessResponse;
+    approveMioAction(taskId: string): SuccessResponse;
+    wakeMio(taskId: string): SuccessResponse;
+    sendMioUserAway(taskId: string): SuccessResponse;
+    markMioComplete(taskId: string): SuccessResponse;
+    markMioFailed(taskId: string): SuccessResponse;
+    archiveMio(taskId: string): SuccessResponse;
+    getMioContext(taskId: string): MioContext;
+    listTools(): ToolsListResult;
+    getWorkflowStates(): WorkflowStates;
+    updateTaskModels(taskId: string, models: {
+        agent?: string;
+        orchestrator?: string;
+    }): SuccessResponse;
+    updateTaskIteration(taskId: string, iteration: number): SuccessResponse;
+    updateTaskWorkflowData(taskId: string, workflowData: Record<string, unknown>): SuccessResponse;
+    deleteMessage(taskId: string, messageId: number): SuccessResponse;
+    deleteMessages(taskId: string, messageIds: number[]): SuccessResponse;
+    updateMessage(taskId: string, messageId: number, update: {
+        content?: string;
+        reasoning?: string;
+    }): SuccessResponse;
+    resetMatrixToPhase(taskId: string, phase: number): SuccessResponse;
+    getMessageTranslations(taskId: string, messageId: number, locale?: string): MessageTranslationsResult;
+    listErrors(params?: Parameters<OrchestratorAsync["listErrors"]>[0]): ErrorEventDetail[];
+    getErrorDetail(errorId: string): ErrorEventDetail;
+    getErrorStats(since?: string): ErrorStatsResult;
+    countErrors(since?: string): ErrorCountResult;
+    purgeErrors(): ErrorPurgeResult;
+    health(): HealthStatus;
+    healthDetailed(): HealthDetail;
+    ready(): ReadinessResult;
+    healthLeader(): LeaderStatus;
+    getMetrics(types?: string): MetricSnapshot;
+    getSystemStatus(): SystemStatus;
+    updateSettings(settings: Record<string, unknown>): SystemStatus;
+    getConfigurationStatus(): ConfigurationStatus;
+    setAgentModel(model: string): SuccessResponse;
+    setOrchestratorModel(model: string): SuccessResponse;
+    getLLMBackendStatus(): Record<string, unknown>;
+    addLLMBackend(host: string, apiKey: string): SuccessResponse;
+    removeLLMBackend(host: string): SuccessResponse;
+    getMCPServerStatus(): Record<string, unknown>;
+    addMCPServer(host: string, apiKey: string): SuccessResponse;
+    removeMCPServer(host: string): SuccessResponse;
+    getTaskHandlerStatus(): TaskHandlerStatus;
+    getTaskHandlerStatusLocal(): TaskHandlerStatusLocal;
+    setConcurrentTasksPerReplica(maxTasks: number): SuccessResponse;
+    getSummaryWorkerStatus(): SummaryWorkerStatus;
+    setCompactorModel(modelName: string): SuccessResponse;
+    setTranslateModel(modelName: string): SuccessResponse;
+    getTokenWorkerStatus(): TokenWorkerStatus;
+    getSlotsStatus(): SlotsStatus;
+    getAuthConfig(): AuthConfig;
+    getWebSocketStatus(): WebSocketStatus;
+    streamTaskStatus(_taskId: string): Record<string, unknown>[];
+}
+
+/**
+ * Environment-based configuration for the orchestrator client.
+ *
+ * All settings are read from environment variables with sensible defaults,
+ * so upstream applications can configure the client without passing args.
+ */
+interface OrchestratorConfig {
+    /** Base URL of the orchestrator (e.g. "http://localhost:8080"). */
+    baseUrl: string;
+    /** Optional static bearer token sent as `Authorization: Bearer <key>`. */
+    apiKey?: string;
+    /** Default timeout in milliseconds for HTTP requests. */
+    timeoutMs: number;
+    /** Maximum retry attempts on transient failures. */
+    maxRetries: number;
+}
+/**
+ * Build configuration from environment variables.
+ *
+ * - `ORCHESTRATOR_URL` — base URL (default: "http://localhost:8080")
+ * - `ORCHESTRATOR_API_KEY` — optional bearer token
+ * - `ORCHESTRATOR_TIMEOUT_MS` — timeout in ms (default: 30000)
+ * - `ORCHESTRATOR_MAX_RETRIES` — max retries (default: 3)
+ */
+declare function loadConfig(overrides?: Partial<OrchestratorConfig>): OrchestratorConfig;
+
+/**
+ * Create a fetch implementation that ignores SSL certificate errors.
+ *
+ * Useful for connecting to orchestrator instances with self-signed or
+ * internally-issued certificates during development or in isolated networks.
+ *
+ * Usage:
+ *
+ *   import { Orchestrator, createInsecureFetch } from "orchestrator-client";
+ *
+ *   const client = new Orchestrator({
+ *     baseUrl: "https://orchestrator.internal:8443",
+ *     fetch: await createInsecureFetch(),
+ *   });
+ *
+ * Note: Only works in Node.js (uses `https.Agent` underneath).
+ * In browser environments, the global `fetch` is returned as-is.
+ */
+declare function createInsecureFetch(): Promise<typeof globalThis.fetch>;
+
+/**
+ * RealtimeClient — Socket.IO wrapper for orchestrator realtime events.
+ *
+ * Connects to the orchestrator's Socket.IO endpoint (same host:port as the
+ * REST API) and provides a typed subscription layer using the server's
+ * room-based event system.
+ *
+ * Usage:
+ *
+ *   const rt = new RealtimeClient("http://localhost:8080");
+ *   await rt.connect();
+ *   await rt.subscribeTask("task-abc123");
+ *
+ *   rt.on("task_status_changed", (event) => {
+ *     console.log(event.new_status);
+ *   });
+ */
+declare const EVENT_TASK_CREATED = "task_created";
+declare const EVENT_TASK_STATUS_CHANGED = "task_status_changed";
+declare const EVENT_TASK_ITERATION_CHANGED = "task_iteration_changed";
+declare const EVENT_TASK_DELETED = "task_deleted";
+declare const EVENT_TASK_RESULT_UPDATED = "task_result_updated";
+declare const EVENT_TASK_INSIGHT_UPDATED = "task_insight_updated";
+declare const EVENT_MESSAGE_ADDED = "message_added";
+declare const EVENT_MESSAGE_STREAMING = "message_streaming";
+declare const EVENT_MESSAGE_SUMMARY_GENERATED = "message_summary_generated";
+declare const EVENT_MESSAGE_TRANSLATION_READY = "message_translation_ready";
+declare const EVENT_ERROR_EVENT_RECORDED = "error_event_recorded";
+type EventHandler = (...args: unknown[]) => void;
+interface RealtimeClientOptions {
+    /** Socket.IO connection options. */
+    socketOptions?: Record<string, unknown>;
+    /** Optional bearer token or async token getter. */
+    getToken?: (() => string | Promise<string>) | string;
+    /** Whether to auto-connect on construction (default: false). */
+    autoConnect?: boolean;
+}
+/**
+ * Socket.IO-based realtime client for receiving orchestrator events.
+ *
+ * Requires the consumer to provide their own `socket.io-client` instance
+ * to avoid version conflicts.
+ */
+declare class RealtimeClient {
+    private _baseUrl;
+    private _socketOptions;
+    private _getToken?;
+    private _socket;
+    private _handlers;
+    private _connected;
+    constructor(baseUrl: string, opts: RealtimeClientOptions);
+    get connected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /**
+     * Subscribe to realtime events for a specific task.
+     */
+    subscribeTask(taskId: string): Promise<void>;
+    /**
+     * Unsubscribe from realtime events for a specific task.
+     */
+    unsubscribeTask(taskId: string): Promise<void>;
+    /**
+     * Register a handler for a specific event type.
+     */
+    on(event: string, handler: EventHandler): void;
+    /**
+     * Remove a registered handler.
+     */
+    off(event: string, handler: EventHandler): void;
+    /**
+     * Wait for the connection to close (for long-running listeners).
+     */
+    wait(): Promise<void>;
+}
+
+/**
+ * Typed exception hierarchy for orchestrator API interactions.
+ *
+ * Every error carries `statusCode` and `errorCode` extracted from the
+ * server's uniform error envelope, making it easy for callers to handle
+ * specific error conditions programmatically.
+ */
+/**
+ * Base error for all orchestrator-related errors.
+ */
+declare class OrchestratorError extends Error {
+    readonly statusCode: number | null;
+    readonly errorCode: string | null;
+    readonly details: Record<string, unknown>;
+    constructor(message: string, opts?: {
+        statusCode?: number | null;
+        errorCode?: string | null;
+        details?: Record<string, unknown>;
+    });
+}
+/**
+ * Orchestrator is unreachable (network / DNS / timeout).
+ */
+declare class OrchestratorConnectionError extends OrchestratorError {
+    constructor(message: string);
+}
+/**
+ * Authentication or authorization failure (401/403).
+ */
+declare class OrchestratorAuthError extends OrchestratorError {
+    constructor(message: string, statusCode?: number);
+}
+/**
+ * Requested resource does not exist (404).
+ */
+declare class OrchestratorNotFoundError extends OrchestratorError {
+    readonly resourceType: string;
+    readonly resourceId: string;
+    constructor(resourceType: string, resourceId: string, message?: string);
+}
+/**
+ * Non-2xx response from the orchestrator API.
+ *
+ * Covers 400 Bad Request, 500 Internal Server Error, and any other
+ * unexpected status that isn't auth or not-found specific.
+ */
+declare class OrchestratorAPIError extends OrchestratorError {
+    constructor(message: string, statusCode: number, errorCode?: string | null, details?: Record<string, unknown>);
+}
+/**
+ * Invalid or missing client configuration (bad env vars, etc.).
+ */
+declare class OrchestratorConfigError extends OrchestratorError {
+    constructor(message: string);
+}
+
+/**
+ * orchestrator-client — TypeScript/JavaScript client for the DAMIT AIOps Orchestrator.
+ *
+ * Provides a complete wrapper for the orchestrator's REST API and
+ * Socket.IO realtime events, with typed responses, automatic retry,
+ * and configurable auth.
+ *
+ * Main components:
+ *
+ * - {@link Orchestrator} — synchronous REST client (primary interface)
+ * - {@link OrchestratorAsync} — async REST client (for async contexts)
+ * - {@link RealtimeClient} — Socket.IO event subscription layer
+ * - Typed exception hierarchy ({@link OrchestratorError} and subclasses)
+ * - Typed response interfaces for all response shapes
+ */
+declare const VERSION = "5.6.0";
+
+export { type ArchivedContent, type AttachmentMeta, type AttachmentUploadResponse, type AuthConfig, type CompactionEvent, type ComponentHealth, type ConfigurationStatus, type ConversationResult, EVENT_ERROR_EVENT_RECORDED, EVENT_MESSAGE_ADDED, EVENT_MESSAGE_STREAMING, EVENT_MESSAGE_SUMMARY_GENERATED, EVENT_MESSAGE_TRANSLATION_READY, EVENT_TASK_CREATED, EVENT_TASK_DELETED, EVENT_TASK_INSIGHT_UPDATED, EVENT_TASK_ITERATION_CHANGED, EVENT_TASK_RESULT_UPDATED, EVENT_TASK_STATUS_CHANGED, type ErrorCountResult, type ErrorEvent, type ErrorEventDetail, type ErrorPurgeResult, type ErrorStatsResult, type EventHandler, type HealthDetail, type HealthStatus, type LLMBackendInfo, type LeaderStatus, type LockStatus, type MCPServerInfo, type MatrixConversationResult, type Message, type MessageTranslation, type MessageTranslationReadyEvent, type MessageTranslationsResult, type MetricSnapshot, type MioContext, Orchestrator, OrchestratorAPIError, OrchestratorAsync, OrchestratorAuthError, type OrchestratorClientOptions, type OrchestratorConfig, OrchestratorConfigError, OrchestratorConnectionError, OrchestratorError, OrchestratorNotFoundError, type Pagination$1 as Pagination, type ReadinessCheck, type ReadinessResult, RealtimeClient, type RealtimeClientOptions, type SlotInfo, type SlotsStatus, type SuccessResponse, type SummaryWorkerStatus, type SystemStatus, type SystemStatusSettings, type TaskCancelResponse, type TaskCreateResponse, type TaskDeleteResult, type TaskDetail, type TaskHandlerCluster, type TaskHandlerReplica, type TaskHandlerStatus, type TaskHandlerStatusLocal, type TaskJournal, type TaskListResult, type TaskOptions, type TaskSummary, type TokenWorkerStatus, type ToolCall, type ToolInfo, type ToolsListResult, VERSION, type VSATaskCreateResponse, type WebSocketClientInfo, type WebSocketStatus, type WorkflowStates, createInsecureFetch, loadConfig };