@automagik/omni 2.260424.2 → 2.260427.1

package/dist/sdk/client.d.ts

@@ -0,0 +1,2086 @@
+/**
+ * Omni SDK Client
+ *
+ * Type-safe wrapper around the OpenAPI-generated types.
+ */
+import type { components, operations, paths } from './types.generated';
+export type Instance = components['schemas']['Instance'];
+export type Person = components['schemas']['Person'];
+export type Event = components['schemas']['Event'];
+export type AccessRule = components['schemas']['AccessRule'];
+export type Setting = components['schemas']['Setting'];
+export type Provider = components['schemas']['Provider'];
+export type HealthResponse = components['schemas']['HealthResponse'];
+export type PaginationMeta = components['schemas']['PaginationMeta'];
+export type Automation = components['schemas']['Automation'];
+export type DeadLetter = components['schemas']['DeadLetter'];
+export type WebhookSource = components['schemas']['WebhookSource'];
+export type PayloadConfig = components['schemas']['PayloadConfig'];
+export type ReplaySession = components['schemas']['ReplaySession'];
+export type LogEntry = components['schemas']['LogEntry'];
+export type EventMetrics = components['schemas']['EventMetrics'];
+export type EventAnalytics = components['schemas']['EventAnalytics'];
+export interface ChatSettings {
+    muted?: boolean;
+    muteUntil?: string;
+    pinned?: boolean;
+    archived?: boolean;
+    readOnly?: boolean;
+    slowMode?: number;
+    agentPaused?: boolean;
+    [key: string]: unknown;
+}
+export interface Chat {
+    id: string;
+    instanceId: string;
+    externalId: string;
+    chatType: string;
+    channel: string;
+    name?: string | null;
+    description?: string | null;
+    avatarUrl?: string | null;
+    /**
+     * Derived flag: true when the chat is a multi-party conversation
+     * (chatType group/community, or WhatsApp `@g.us` externalId). Computed
+     * server-side so clients can filter groups without platform-specific checks.
+     */
+    isGroup?: boolean;
+    isArchived: boolean;
+    settings?: ChatSettings | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Message {
+    id: string;
+    chatId: string;
+    externalId: string;
+    source: string;
+    messageType: string;
+    textContent?: string | null;
+    platformTimestamp: string;
+    isFromMe?: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ChatParticipant {
+    id: string;
+    chatId: string;
+    platformUserId: string;
+    displayName?: string | null;
+    avatarUrl?: string | null;
+    role?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export type Channel = 'whatsapp-baileys' | 'whatsapp-cloud' | 'discord' | 'slack' | 'telegram' | 'a2a' | 'gupshup' | 'twilio-whatsapp' | 'internal';
+export interface PaginatedResponse<T> {
+    items: T[];
+    meta: PaginationMeta & {
+        total?: number;
+    };
+}
+export interface TurnItem {
+    id: string;
+    instanceId: string;
+    chatId: string;
+    messageId: string;
+    agentId: string;
+    apiKeyId: string;
+    status: string;
+    action: string | null;
+    nudgeCount: number;
+    messagesSent: number;
+    startedAt: string;
+    lastActivityAt: string;
+    closedAt: string | null;
+    closedReason: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+export interface TurnListResponse {
+    items: TurnItem[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+export interface TurnStats {
+    openCount: number;
+    totalCount: number;
+    avgDurationMs: number;
+    timeoutRate: number;
+}
+/** Batch job type */
+export type BatchJobType = 'targeted_chat_sync' | 'time_based_batch' | 'media_redownload';
+/** Job status */
+export type BatchJobStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+/** Content types processable by batch jobs */
+export type ProcessableContentType = 'audio' | 'image' | 'video' | 'document';
+/** Batch job record */
+export interface BatchJob {
+    id: string;
+    jobType: string;
+    instanceId: string;
+    status: string;
+    requestParams: Record<string, unknown>;
+    totalItems: number;
+    processedItems: number;
+    failedItems: number;
+    currentItem?: string | null;
+    progressPercent: number;
+    totalCostUsd?: number | null;
+    totalTokens?: number | null;
+    errorMessage?: string | null;
+    errors?: Array<{
+        itemId: string;
+        error: string;
+    }>;
+    createdAt: string;
+    startedAt?: string | null;
+    completedAt?: string | null;
+}
+/** Batch job status (lightweight for polling) */
+export interface BatchJobStatusResponse {
+    id: string;
+    status: string;
+    totalItems: number;
+    processedItems: number;
+    failedItems: number;
+    skippedItems: number;
+    progressPercent: number;
+    currentItem?: string | null;
+    totalCostUsd?: number | null;
+    totalTokens?: number | null;
+    estimatedCompletion?: string | null;
+    startedAt?: string | null;
+    completedAt?: string | null;
+}
+/** Body for creating a batch job */
+export interface CreateBatchJobBody {
+    jobType: BatchJobType;
+    instanceId: string;
+    chatId?: string;
+    daysBack?: number;
+    limit?: number;
+    contentTypes?: ProcessableContentType[];
+    force?: boolean;
+    /** Minimum random delay between items in ms (default: 1000) */
+    delayMinMs?: number;
+    /** Maximum random delay between items in ms (default: 3000) */
+    delayMaxMs?: number;
+}
+/** Query parameters for listing batch jobs */
+export interface ListBatchJobsParams {
+    instanceId?: string;
+    status?: BatchJobStatus[];
+    jobType?: BatchJobType[];
+    limit?: number;
+    cursor?: string;
+}
+/** Cost estimation result */
+export interface CostEstimate {
+    totalItems: number;
+    audioCount: number;
+    imageCount: number;
+    videoCount: number;
+    documentCount: number;
+    estimatedCostCents: number;
+    estimatedCostUsd: number;
+    estimatedDurationMinutes: number;
+}
+/**
+ * Client configuration
+ */
+export interface OmniClientConfig {
+    /** Base URL of the API (e.g., 'http://localhost:8882') */
+    baseUrl: string;
+    /** API key for authentication */
+    apiKey: string;
+    /** Optional CLI version for request handshake header */
+    cliVersion?: string;
+}
+/**
+ * Query parameters for listing instances
+ */
+export interface ListInstancesParams {
+    channel?: string;
+    status?: string;
+    limit?: number;
+    cursor?: string;
+}
+/**
+ * Body for creating an instance
+ */
+export interface CreateInstanceBody {
+    name: string;
+    channel: Channel;
+    agentProviderId?: string;
+    agentId?: string;
+    twilioAccountSid?: string;
+    twilioAuthToken?: string;
+    twilioFrom?: string;
+    twilioMessagingServiceSid?: string;
+    twilioStatusCallbackUrl?: string;
+    twilioWebhookUrl?: string;
+    twilioValidateSignature?: boolean;
+}
+/**
+ * Body for sending a message
+ */
+export interface SendMessageBody {
+    instanceId: string;
+    to: string;
+    text: string;
+    replyTo?: string;
+    threadId?: string;
+}
+/**
+ * Query parameters for listing events
+ */
+export interface ListEventsParams {
+    channel?: string;
+    instanceId?: string;
+    eventType?: string;
+    since?: string;
+    until?: string;
+    search?: string;
+    limit?: number;
+    cursor?: string;
+}
+/**
+ * Query parameters for searching persons
+ */
+export interface SearchPersonsParams {
+    search: string;
+    limit?: number;
+}
+/**
+ * Query parameters for listing access rules
+ */
+export interface ListAccessRulesParams {
+    instanceId?: string;
+    type?: 'allow' | 'deny';
+}
+/**
+ * Body for creating an access rule
+ */
+export interface CreateAccessRuleBody {
+    ruleType: 'allow' | 'deny';
+    instanceId?: string;
+    phonePattern?: string;
+    platformUserId?: string;
+    priority?: number;
+    action?: 'block' | 'silent_block' | 'allow';
+    reason?: string;
+    blockMessage?: string;
+    enabled?: boolean;
+}
+/**
+ * Parameters for checking access
+ */
+export interface CheckAccessParams {
+    instanceId: string;
+    platformUserId: string;
+    channel: string;
+}
+/**
+ * Result of access check
+ */
+export interface CheckAccessResult {
+    allowed: boolean;
+    reason: string | null;
+    rule?: AccessRule | null;
+}
+/**
+ * Pairing request item returned from list endpoint
+ */
+export interface PairingRequestItem {
+    id: string;
+    instanceId: string;
+    platformUserId: string;
+    pairingCode: string;
+    expiresAt: string;
+    createdAt: string;
+}
+/**
+ * Result of pairing request action (approve/deny)
+ */
+export interface PairingActionResult {
+    action: 'approve' | 'deny';
+    ruleId?: string;
+    reason?: string;
+    message?: string;
+}
+/**
+ * Query parameters for listing settings
+ */
+export interface ListSettingsParams {
+    category?: string;
+}
+/**
+ * Query parameters for listing providers
+ */
+export interface ListProvidersParams {
+    active?: boolean;
+}
+/**
+ * Provider schema type
+ * - agno: Agno AI orchestration platform
+ * - webhook: Webhook-based agent provider
+ * - openclaw: OpenClaw Gateway (WebSocket session-based agent runtime)
+ * - ag-ui: AG-UI protocol
+ * - claude-code: Claude Code agent provider
+ * - a2a: Agent-to-Agent protocol provider
+ * - nats-genie: NATS-based Genie provider (publishes to NATS topics)
+ */
+export type ProviderSchema = 'agno' | 'webhook' | 'openclaw' | 'ag-ui' | 'claude-code' | 'a2a' | 'nats-genie';
+/**
+ * Body for creating a provider
+ */
+export interface NewAgentProvider {
+    name: string;
+    schema: ProviderSchema;
+    baseUrl: string;
+    apiKey?: string;
+    schemaConfig?: Record<string, unknown>;
+    defaultStream?: boolean;
+    defaultTimeout?: number;
+    supportsStreaming?: boolean;
+    supportsImages?: boolean;
+    supportsAudio?: boolean;
+    supportsDocuments?: boolean;
+    description?: string;
+    tags?: string[];
+}
+/**
+ * Provider health check result
+ */
+export interface ProviderHealthResult {
+    healthy: boolean;
+    latency: number;
+    error?: string;
+}
+/**
+ * Agno agent entity
+ *
+ * agno 2.5+ returns `id` at the top level. `agent_id` is kept optional for
+ * backward compatibility with pre-2.5 deployments.
+ */
+export interface AgnoAgent {
+    id: string;
+    /** @deprecated pre-agno-2.5 field; use `id` */
+    agent_id?: string;
+    name: string;
+    model?: {
+        provider?: string;
+        name?: string;
+    };
+    description?: string;
+    instructions?: string[];
+}
+/**
+ * Agno team entity
+ *
+ * agno 2.5+ returns `id` at the top level. `team_id` is kept optional for
+ * backward compatibility with pre-2.5 deployments.
+ */
+export interface AgnoTeam {
+    id: string;
+    /** @deprecated pre-agno-2.5 field; use `id` */
+    team_id?: string;
+    name: string;
+    description?: string;
+    mode?: string;
+    members?: Array<{
+        agent_id: string;
+        id?: string;
+        role?: string;
+    }>;
+}
+/**
+ * Agno workflow entity
+ *
+ * agno 2.5+ returns `id` at the top level. `workflow_id` is kept optional for
+ * backward compatibility with pre-2.5 deployments.
+ */
+export interface AgnoWorkflow {
+    id: string;
+    /** @deprecated pre-agno-2.5 field; use `id` */
+    workflow_id?: string;
+    name: string;
+    description?: string;
+}
+/**
+ * Query parameters for listing chats
+ */
+export interface ListChatsParams {
+    instanceId?: string;
+    channel?: string;
+    chatType?: string;
+    excludeChatTypes?: string;
+    search?: string;
+    includeArchived?: boolean;
+    unreadOnly?: boolean;
+    sort?: 'activity' | 'unread' | 'name';
+    limit?: number;
+    cursor?: string;
+    pendingOnly?: boolean;
+    attentionOnly?: boolean;
+    label?: string;
+    includeHidden?: boolean;
+}
+/**
+ * Body for creating a chat
+ */
+export interface CreateChatBody {
+    instanceId: string;
+    externalId: string;
+    chatType: string;
+    channel: Channel;
+    name?: string;
+    description?: string;
+    avatarUrl?: string;
+    canonicalId?: string;
+    parentChatId?: string;
+    settings?: Record<string, unknown>;
+    platformMetadata?: Record<string, unknown>;
+}
+/**
+ * Body for updating a chat
+ */
+export interface UpdateChatBody {
+    name?: string;
+    description?: string;
+    avatarUrl?: string | null;
+    canonicalId?: string | null;
+    settings?: Record<string, unknown> | null;
+    platformMetadata?: Record<string, unknown> | null;
+}
+/**
+ * Body for adding a chat participant
+ */
+export interface AddParticipantBody {
+    platformUserId: string;
+    displayName?: string;
+    avatarUrl?: string;
+    role?: string;
+    personId?: string;
+    platformIdentityId?: string;
+    platformMetadata?: Record<string, unknown>;
+}
+/**
+ * Query parameters for listing chat messages
+ */
+export interface ListChatMessagesParams {
+    limit?: number;
+    before?: string;
+    after?: string;
+    mediaOnly?: boolean;
+}
+/**
+ * Query parameters for listing logs
+ */
+export interface ListLogsParams {
+    modules?: string;
+    level?: 'debug' | 'info' | 'warn' | 'error';
+    limit?: number;
+}
+/**
+ * Query parameters for listing automations
+ */
+export interface ListAutomationsParams {
+    enabled?: boolean;
+}
+/**
+ * Body for creating an automation
+ */
+export interface CreateAutomationBody {
+    name: string;
+    description?: string;
+    triggerEventType: string;
+    triggerConditions?: Array<{
+        field: string;
+        operator: 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte' | 'contains' | 'not_contains' | 'exists' | 'not_exists' | 'regex';
+        value?: unknown;
+    }>;
+    /** Condition logic: 'and' (all must match) or 'or' (any must match). Defaults to 'and'. */
+    conditionLogic?: 'and' | 'or';
+    actions: Array<{
+        type: 'webhook' | 'send_message' | 'emit_event' | 'log' | 'call_agent';
+        config: Record<string, unknown>;
+    }>;
+    debounce?: Record<string, unknown>;
+    enabled?: boolean;
+    priority?: number;
+}
+/**
+ * Body for testing an automation
+ */
+export interface TestAutomationBody {
+    event: {
+        type: string;
+        payload: Record<string, unknown>;
+    };
+}
+/**
+ * Query parameters for listing automation logs
+ */
+export interface ListAutomationLogsParams {
+    limit?: number;
+    cursor?: string;
+    status?: 'success' | 'failed' | 'skipped';
+    eventType?: string;
+    automationId?: string;
+}
+/**
+ * Query parameters for listing dead letters
+ */
+export interface ListDeadLettersParams {
+    status?: string;
+    eventType?: string;
+    since?: string;
+    until?: string;
+    limit?: number;
+    cursor?: string;
+}
+/**
+ * Body for resolving a dead letter
+ */
+export interface ResolveDeadLetterBody {
+    note: string;
+}
+/**
+ * Query parameters for listing webhook sources
+ */
+export interface ListWebhookSourcesParams {
+    enabled?: boolean;
+}
+/**
+ * Body for creating a webhook source
+ */
+export interface CreateWebhookSourceBody {
+    name: string;
+    description?: string;
+    expectedHeaders?: Record<string, boolean>;
+    enabled?: boolean;
+}
+/**
+ * Body for triggering a custom event
+ */
+export interface TriggerEventBody {
+    eventType: string;
+    payload: Record<string, unknown>;
+    correlationId?: string;
+    instanceId?: string;
+}
+/**
+ * Body for starting a replay
+ */
+export interface StartReplayBody {
+    since: string;
+    until?: string;
+    eventTypes?: string[];
+    instanceId?: string;
+    limit?: number;
+    speedMultiplier?: number;
+    skipProcessed?: boolean;
+    dryRun?: boolean;
+}
+/**
+ * Body for updating payload config
+ */
+export interface UpdatePayloadConfigBody {
+    storeWebhookRaw?: boolean;
+    storeAgentRequest?: boolean;
+    storeAgentResponse?: boolean;
+    storeChannelSend?: boolean;
+    storeError?: boolean;
+    retentionDays?: number;
+}
+/**
+ * Body for deleting payloads
+ */
+export interface DeletePayloadsBody {
+    reason: string;
+}
+/**
+ * Body for sending media
+ */
+export interface SendMediaBody {
+    instanceId: string;
+    to: string;
+    type: 'image' | 'audio' | 'video' | 'document';
+    url?: string;
+    base64?: string;
+    filename?: string;
+    caption?: string;
+    voiceNote?: boolean;
+    threadId?: string;
+}
+/**
+ * Body for sending a reaction
+ */
+export interface SendReactionBody {
+    instanceId: string;
+    to: string;
+    messageId: string;
+    emoji: string;
+}
+/**
+ * Body for removing a reaction
+ */
+export interface RemoveReactionBody {
+    instanceId: string;
+    emoji: string;
+}
+/**
+ * Body for forwarding a message
+ */
+export interface SendForwardBody {
+    instanceId: string;
+    to: string;
+    messageId: string;
+    fromChatId: string;
+}
+/**
+ * Body for sending a sticker
+ */
+export interface SendStickerBody {
+    instanceId: string;
+    to: string;
+    url?: string;
+    base64?: string;
+}
+/**
+ * Body for sending a contact
+ */
+export interface SendContactBody {
+    instanceId: string;
+    to: string;
+    contact: {
+        name: string;
+        phone?: string;
+        email?: string;
+        organization?: string;
+    };
+}
+/**
+ * Body for sending a TTS voice note
+ */
+export interface SendTtsBody {
+    instanceId: string;
+    to: string;
+    text: string;
+    voiceId?: string;
+    modelId?: string;
+    stability?: number;
+    similarityBoost?: number;
+    presenceDelay?: number;
+}
+/**
+ * TTS voice configuration
+ */
+export interface TtsVoice {
+    voiceId: string;
+    name: string;
+    category?: string;
+    labels?: Record<string, string>;
+}
+/**
+ * TTS send response
+ */
+export interface TtsResponse {
+    messageId: string;
+    status: string;
+    audioSizeKb: number;
+    durationMs: number;
+    timestamp: number;
+}
+/**
+ * Body for sending a location
+ */
+export interface SendLocationBody {
+    instanceId: string;
+    to: string;
+    latitude: number;
+    longitude: number;
+    name?: string;
+    address?: string;
+}
+/**
+ * Body for sending a poll (Discord)
+ */
+export interface SendPollBody {
+    instanceId: string;
+    to: string;
+    question: string;
+    answers: string[];
+    durationHours?: number;
+    multiSelect?: boolean;
+    replyTo?: string;
+}
+/**
+ * Body for sending an embed (Discord)
+ */
+export interface SendEmbedBody {
+    instanceId: string;
+    to: string;
+    title?: string;
+    description?: string;
+    color?: number;
+    url?: string;
+    timestamp?: string;
+    footer?: {
+        text: string;
+        iconUrl?: string;
+    };
+    author?: {
+        name: string;
+        url?: string;
+        iconUrl?: string;
+    };
+    thumbnail?: string;
+    image?: string;
+    fields?: Array<{
+        name: string;
+        value: string;
+        inline?: boolean;
+    }>;
+    replyTo?: string;
+}
+/**
+ * Body for connecting an instance
+ */
+export interface ConnectInstanceBody {
+    token?: string;
+    forceNewQr?: boolean;
+    twilioAccountSid?: string;
+    twilioAuthToken?: string;
+    twilioFrom?: string;
+    twilioMessagingServiceSid?: string;
+    twilioStatusCallbackUrl?: string;
+    twilioWebhookUrl?: string;
+    twilioValidateSignature?: boolean;
+    /** WhatsApp-specific connection options */
+    whatsapp?: {
+        /** Sync full message history on connect (default: true) */
+        syncFullHistory?: boolean;
+    };
+}
+/**
+ * Body for starting a sync
+ */
+export interface StartSyncBody {
+    type: 'profile' | 'messages' | 'contacts' | 'groups' | 'all';
+    depth?: '7d' | '30d' | '90d' | '1y' | 'all';
+    channelId?: string;
+    downloadMedia?: boolean;
+    /** Specific chat JIDs for per-chat active sync (WhatsApp only). Omit for passive sync. */
+    chatJids?: string[];
+}
+/**
+ * Query parameters for listing syncs
+ */
+export interface ListSyncsParams {
+    status?: string;
+    limit?: number;
+}
+/**
+ * Body for requesting a pairing code
+ */
+export interface RequestPairingCodeBody {
+    phoneNumber: string;
+}
+/**
+ * Result of profile sync
+ */
+export interface SyncProfileResult {
+    type: 'profile';
+    status: string;
+    profile: {
+        name?: string | null;
+        avatarUrl?: string | null;
+        bio?: string | null;
+        platformMetadata?: Record<string, unknown> | null;
+        syncedAt?: string | null;
+    } | null;
+}
+/**
+ * Sync job created response
+ */
+export interface SyncJobCreated {
+    jobId: string;
+    instanceId: string;
+    type: string;
+    status: string;
+    config: Record<string, unknown>;
+    message: string;
+}
+/**
+ * Sync job summary (for list)
+ */
+export interface SyncJobSummary {
+    jobId: string;
+    type: string;
+    status: string;
+    progressPercent?: number | null;
+    createdAt: string;
+    completedAt?: string | null;
+}
+/**
+ * Sync job status (detailed)
+ */
+export interface SyncJobStatus {
+    jobId: string;
+    instanceId: string;
+    type: string;
+    status: string;
+    config: Record<string, unknown>;
+    progress?: Record<string, unknown> | null;
+    progressPercent?: number | null;
+    errorMessage?: string | null;
+    createdAt: string;
+    startedAt?: string | null;
+    completedAt?: string | null;
+}
+/**
+ * Auth validation response
+ */
+export interface AuthValidateResponse {
+    valid: boolean;
+    keyPrefix: string;
+    keyName: string;
+    scopes: string[];
+}
+/** API key status */
+export type ApiKeyStatus = 'active' | 'revoked' | 'expired';
+/** API key record */
+export interface ApiKeyRecord {
+    id: string;
+    name: string;
+    description?: string | null;
+    keyPrefix: string;
+    scopes: string[];
+    instanceIds?: string[] | null;
+    status: ApiKeyStatus;
+    rateLimit?: number | null;
+    expiresAt?: string | null;
+    lastUsedAt?: string | null;
+    usageCount: number;
+    revokedAt?: string | null;
+    revokedBy?: string | null;
+    revokeReason?: string | null;
+    createdAt: string;
+    createdBy?: string | null;
+    updatedAt: string;
+}
+/** Body for creating an API key */
+export interface CreateApiKeyBody {
+    name: string;
+    description?: string;
+    scopes: string[];
+    instanceIds?: string[];
+    rateLimit?: number;
+    expiresAt?: string;
+}
+/** Body for updating an API key */
+export interface UpdateApiKeyBody {
+    name?: string;
+    description?: string | null;
+    scopes?: string[];
+    instanceIds?: string[] | null;
+    rateLimit?: number | null;
+    expiresAt?: string | null;
+}
+/** Body for revoking an API key */
+export interface RevokeApiKeyBody {
+    reason?: string;
+    revokedBy?: string;
+}
+/** Query parameters for listing API keys */
+export interface ListApiKeysParams {
+    status?: ApiKeyStatus;
+    limit?: number;
+}
+/** Result of creating an API key (includes the plaintext key) */
+export interface CreateApiKeyResult extends ApiKeyRecord {
+    plainTextKey: string;
+}
+/**
+ * Body for sending presence indicator
+ */
+export interface SendPresenceBody {
+    instanceId: string;
+    to: string;
+    type: 'typing' | 'recording' | 'paused';
+    duration?: number;
+}
+/**
+ * Response from sending presence
+ */
+export interface SendPresenceResult {
+    instanceId: string;
+    chatId: string;
+    type: string;
+    duration: number;
+}
+/**
+ * Body for marking a single message as read
+ */
+export interface MarkMessageReadBody {
+    instanceId: string;
+}
+/**
+ * Body for marking multiple messages as read
+ */
+export interface BatchMarkReadBody {
+    instanceId: string;
+    chatId: string;
+    messageIds: string[];
+}
+/**
+ * Body for marking entire chat as read
+ */
+export interface MarkChatReadBody {
+    instanceId: string;
+}
+/**
+ * Response from marking messages as read
+ */
+export interface MarkReadResult {
+    messageId?: string;
+    externalMessageId?: string;
+    chatId?: string;
+    instanceId?: string;
+    messageCount?: number;
+}
+/**
+ * Query parameters for listing contacts
+ */
+export interface ListContactsParams {
+    limit?: number;
+    cursor?: string;
+    guildId?: string;
+    search?: string;
+    excludeGroups?: boolean;
+}
+/**
+ * Query parameters for listing groups
+ */
+export interface ListGroupsParams {
+    limit?: number;
+    cursor?: string;
+    search?: string;
+}
+/**
+ * User profile from channel
+ */
+export interface UserProfile {
+    platformUserId: string;
+    displayName?: string;
+    avatarUrl?: string;
+    bio?: string;
+    phone?: string;
+    platformMetadata?: Record<string, unknown>;
+}
+/**
+ * Contact from channel
+ */
+export interface Contact {
+    platformUserId: string;
+    displayName?: string;
+    phone?: string;
+    avatarUrl?: string;
+    isGroup: boolean;
+    isBusiness?: boolean;
+    platformMetadata?: Record<string, unknown>;
+}
+/**
+ * Group from channel
+ */
+export interface Group {
+    externalId: string;
+    name?: string;
+    description?: string;
+    memberCount?: number;
+    createdAt?: string;
+    avatarUrl?: string;
+    platformMetadata?: Record<string, unknown>;
+}
+/**
+ * Group member
+ */
+export interface GroupMember {
+    id: string;
+    name?: string;
+    role?: 'admin' | 'superadmin' | 'member';
+}
+/**
+ * Create an Omni API client
+ */
+export declare function createOmniClient(config: OmniClientConfig): {
+    /**
+     * Authentication
+     */
+    auth: {
+        /**
+         * Validate the current API key
+         * Note: Uses type assertion until SDK types are regenerated
+         */
+        validate(): Promise<AuthValidateResponse>;
+    };
+    /**
+     * Instance management
+     */
+    instances: {
+        /**
+         * List all instances
+         */
+        list(params?: ListInstancesParams): Promise<PaginatedResponse<Instance>>;
+        /**
+         * Get a single instance by ID
+         */
+        get(id: string): Promise<Instance>;
+        /**
+         * Create a new instance
+         */
+        create(body: CreateInstanceBody): Promise<Instance>;
+        /**
+         * Update an instance
+         */
+        update(id: string, body: Partial<Instance>): Promise<void>;
+        /**
+         * Delete an instance
+         */
+        delete(id: string): Promise<void>;
+        /**
+         * Get instance status
+         */
+        status(id: string): Promise<{
+            state: string;
+            isConnected: boolean;
+            profileName?: string | null;
+        }>;
+        /**
+         * Get QR code for WhatsApp instances
+         */
+        qr(id: string): Promise<{
+            qr: string | null;
+            expiresAt: string | null;
+            message: string;
+        }>;
+        /**
+         * Connect an instance
+         */
+        connect(id: string, body?: ConnectInstanceBody): Promise<{
+            status: string;
+            message: string;
+        }>;
+        /**
+         * Disconnect an instance
+         */
+        disconnect(id: string): Promise<void>;
+        /**
+         * Restart an instance
+         */
+        restart(id: string, forceNewQr?: boolean): Promise<{
+            status: string;
+            message: string;
+        }>;
+        /**
+         * Logout an instance (clear session)
+         */
+        logout(id: string): Promise<void>;
+        /**
+         * Request pairing code for WhatsApp
+         */
+        pair(id: string, body: RequestPairingCodeBody): Promise<{
+            code: string;
+            phoneNumber: string;
+            message: string;
+            expiresIn: number;
+        }>;
+        /**
+         * Sync instance profile immediately
+         */
+        syncProfile(id: string): Promise<SyncProfileResult>;
+        /**
+         * Start a sync job (messages, contacts, groups, or all)
+         */
+        startSync(id: string, body: StartSyncBody): Promise<SyncJobCreated>;
+        /**
+         * List sync jobs for an instance
+         */
+        listSyncs(id: string, params?: ListSyncsParams): Promise<PaginatedResponse<SyncJobSummary>>;
+        /**
+         * Get sync job status
+         */
+        getSyncStatus(id: string, jobId: string): Promise<SyncJobStatus>;
+        /**
+         * List contacts for an instance
+         */
+        listContacts(id: string, params?: ListContactsParams): Promise<{
+            items: Contact[];
+            meta: {
+                totalFetched: number;
+                hasMore: boolean;
+                cursor?: string;
+            };
+        }>;
+        /**
+         * List groups for an instance
+         */
+        listGroups(id: string, params?: ListGroupsParams): Promise<{
+            items: Group[];
+            meta: {
+                totalFetched: number;
+                hasMore: boolean;
+                cursor?: string;
+            };
+        }>;
+        /**
+         * List members of a group
+         */
+        listGroupMembers(id: string, groupJid: string): Promise<{
+            members: GroupMember[];
+        }>;
+        /**
+         * Get user profile from channel
+         */
+        getUserProfile(id: string, userId: string): Promise<UserProfile>;
+    };
+    /**
+     * Chat management
+     * Note: Uses fetch directly until SDK types are regenerated
+     */
+    chats: {
+        /**
+         * List chats
+         */
+        list(params?: ListChatsParams): Promise<PaginatedResponse<Chat>>;
+        /**
+         * Get a chat by ID
+         */
+        get(id: string): Promise<Chat>;
+        /**
+         * Create a chat
+         */
+        create(body: CreateChatBody): Promise<Chat>;
+        /**
+         * Update a chat
+         */
+        update(id: string, body: UpdateChatBody): Promise<Chat>;
+        /**
+         * Delete a chat
+         */
+        delete(id: string): Promise<void>;
+        /**
+         * Archive a chat
+         */
+        archive(id: string): Promise<Chat>;
+        /**
+         * Unarchive a chat
+         */
+        unarchive(id: string): Promise<Chat>;
+        /**
+         * Get messages for a chat
+         */
+        getMessages(id: string, params?: ListChatMessagesParams): Promise<Message[]>;
+        /**
+         * List participants of a chat
+         */
+        listParticipants(id: string): Promise<ChatParticipant[]>;
+        /**
+         * Add a participant to a chat
+         */
+        addParticipant(id: string, body: AddParticipantBody): Promise<ChatParticipant>;
+        /**
+         * Remove a participant from a chat
+         */
+        removeParticipant(id: string, platformUserId: string): Promise<void>;
+        /**
+         * Hide a chat
+         */
+        hide(id: string): Promise<Chat>;
+        /**
+         * Unhide a chat
+         */
+        unhide(id: string): Promise<Chat>;
+        /**
+         * Add a label to a chat
+         */
+        addLabel(id: string, label: string): Promise<Chat>;
+        /**
+         * Remove a label from a chat
+         */
+        removeLabel(id: string, label: string): Promise<Chat>;
+        /**
+         * Mark entire chat as read
+         */
+        markRead(id: string, body: MarkChatReadBody): Promise<MarkReadResult>;
+    };
+    /**
+     * Message sending
+     */
+    messages: {
+        /**
+         * Get a message by ID
+         */
+        get(messageId: string): Promise<Message>;
+        /**
+         * Send a text message
+         */
+        send(body: SendMessageBody): Promise<{
+            messageId: string;
+            status: string;
+        }>;
+        /**
+         * Send a media message
+         */
+        sendMedia(body: SendMediaBody): Promise<{
+            messageId: string;
+            status: string;
+        }>;
+        /**
+         * Send a reaction
+         */
+        sendReaction(body: SendReactionBody): Promise<{
+            messageId?: string;
+            success: boolean;
+        }>;
+        /**
+         * Send a sticker
+         */
+        sendSticker(body: SendStickerBody): Promise<{
+            messageId: string;
+            status: string;
+        }>;
+        /**
+         * Send a contact card
+         */
+        sendContact(body: SendContactBody): Promise<{
+            messageId: string;
+            status: string;
+        }>;
+        /**
+         * Send a location
+         */
+        sendLocation(body: SendLocationBody): Promise<{
+            messageId: string;
+            status: string;
+        }>;
+        /**
+         * Send a poll (Discord only)
+         */
+        sendPoll(body: SendPollBody): Promise<{
+            messageId: string;
+            status: string;
+        }>;
+        /**
+         * Send an embed (Discord only)
+         */
+        sendEmbed(body: SendEmbedBody): Promise<{
+            messageId: string;
+            status: string;
+        }>;
+        /**
+         * Send presence indicator (typing, recording, etc.)
+         */
+        sendPresence(body: SendPresenceBody): Promise<SendPresenceResult>;
+        /**
+         * Mark a single message as read
+         */
+        markRead(messageId: string, body: MarkMessageReadBody): Promise<MarkReadResult>;
+        /**
+         * Mark multiple messages as read in batch
+         */
+        batchMarkRead(body: BatchMarkReadBody): Promise<MarkReadResult>;
+        /**
+         * List available TTS voices
+         */
+        listVoices(): Promise<TtsVoice[]>;
+        /**
+         * Send a TTS voice note
+         */
+        sendTts(body: SendTtsBody): Promise<TtsResponse>;
+        /**
+         * Forward a message to another chat
+         */
+        sendForward(body: SendForwardBody): Promise<{
+            messageId: string;
+            status: string;
+        }>;
+        /**
+         * Remove a reaction from a message
+         */
+        removeReaction(id: string, body: RemoveReactionBody): Promise<{
+            success: boolean;
+        }>;
+    };
+    /**
+     * Event querying
+     */
+    events: {
+        /**
+         * List events with optional filters
+         */
+        list(params?: ListEventsParams): Promise<PaginatedResponse<Event>>;
+        /**
+         * Get a single event by ID
+         */
+        get(id: string): Promise<Event>;
+        /**
+         * Get event analytics
+         */
+        analytics(params?: {
+            granularity?: "hourly" | "daily";
+        }): Promise<EventAnalytics>;
+    };
+    /**
+     * Person/identity search
+     */
+    persons: {
+        /**
+         * Search for persons
+         */
+        search(params: SearchPersonsParams): Promise<Person[]>;
+        /**
+         * Get a person by ID
+         */
+        get(id: string): Promise<Person>;
+        /**
+         * Get person presence (all identities and activity summary)
+         */
+        presence(id: string): Promise<{
+            person: Person;
+            identities: Array<Record<string, unknown>>;
+            summary: Record<string, unknown>;
+            byChannel: Record<string, unknown>;
+        }>;
+        /**
+         * Update a person's fields (displayName, phone, email, metadata)
+         */
+        update(id: string, data: {
+            displayName?: string;
+            primaryPhone?: string | null;
+            primaryEmail?: string | null;
+            avatarUrl?: string | null;
+            metadata?: Record<string, unknown> | null;
+        }): Promise<Person>;
+        /**
+         * Link two platform identities to the same person
+         */
+        link(identityA: string, identityB: string): Promise<Person>;
+        /**
+         * Unlink a platform identity from its person
+         */
+        unlink(identityId: string, reason: string): Promise<{
+            person: Person;
+            identity: Record<string, unknown>;
+        }>;
+        /**
+         * Merge two persons (source into target, source is deleted)
+         */
+        merge(sourcePersonId: string, targetPersonId: string, reason?: string): Promise<{
+            person: Person;
+            mergedIdentityIds: string[];
+            deletedPersonId: string;
+        }>;
+    };
+    /**
+     * Access control rules
+     */
+    access: {
+        /**
+         * List access rules
+         */
+        listRules(params?: ListAccessRulesParams): Promise<AccessRule[]>;
+        /**
+         * Create an access rule
+         */
+        createRule(body: CreateAccessRuleBody): Promise<void>;
+        /**
+         * Delete an access rule
+         */
+        deleteRule(id: string): Promise<void>;
+        /**
+         * Check if a user has access
+         */
+        checkAccess(params: CheckAccessParams): Promise<CheckAccessResult>;
+        /**
+         * List pending pairing requests for an instance
+         */
+        listPairingRequests(instanceId: string): Promise<PairingRequestItem[]>;
+        /**
+         * Approve or deny a pairing request
+         */
+        actionPairingRequest(instanceId: string, requestId: string, body: {
+            action: "approve" | "deny";
+            reason?: string;
+        }): Promise<PairingActionResult>;
+    };
+    /**
+     * Settings management
+     */
+    settings: {
+        /**
+         * List settings
+         */
+        list(params?: ListSettingsParams): Promise<Setting[]>;
+        /**
+         * Get a single setting by key
+         */
+        get(key: string): Promise<Setting>;
+        /**
+         * Set a setting value
+         */
+        set(key: string, value: unknown, reason?: string): Promise<Setting>;
+    };
+    /**
+     * Provider management
+     */
+    providers: {
+        /**
+         * List providers
+         */
+        list(params?: ListProvidersParams): Promise<Provider[]>;
+        /**
+         * Get provider by ID
+         */
+        get(id: string): Promise<Provider>;
+        /**
+         * Create a provider
+         */
+        create(body: NewAgentProvider): Promise<Provider>;
+        /**
+         * Update a provider
+         */
+        update(id: string, body: Record<string, unknown>): Promise<Provider>;
+        /**
+         * Delete a provider
+         */
+        delete(id: string): Promise<void>;
+        /**
+         * Check provider health
+         */
+        checkHealth(id: string): Promise<ProviderHealthResult>;
+        /**
+         * List agents from Agno provider
+         */
+        listAgents(id: string): Promise<AgnoAgent[]>;
+        /**
+         * List teams from Agno provider
+         */
+        listTeams(id: string): Promise<AgnoTeam[]>;
+        /**
+         * List workflows from Agno provider
+         */
+        listWorkflows(id: string): Promise<AgnoWorkflow[]>;
+    };
+    /**
+     * Agent routing configuration
+     */
+    routes: {
+        /**
+         * List routes for an instance
+         */
+        list(instanceId: string, params?: {
+            scope?: "chat" | "user";
+            isActive?: boolean;
+        }): Promise<components["schemas"]["AgentRoute"][]>;
+        /**
+         * Get route by ID
+         */
+        get(instanceId: string, id: string): Promise<components["schemas"]["AgentRoute"]>;
+        /**
+         * Create a route
+         */
+        create(instanceId: string, body: components["schemas"]["CreateAgentRouteRequest"]): Promise<components["schemas"]["AgentRoute"]>;
+        /**
+         * Update a route
+         */
+        update(instanceId: string, id: string, body: components["schemas"]["UpdateAgentRouteRequest"]): Promise<components["schemas"]["AgentRoute"]>;
+        /**
+         * Delete a route
+         */
+        delete(instanceId: string, id: string): Promise<void>;
+        /**
+         * Get route cache metrics
+         */
+        getMetrics(): Promise<components["schemas"]["CacheMetrics"]>;
+    };
+    /**
+     * Log querying
+     */
+    logs: {
+        /**
+         * Get recent logs
+         */
+        recent(params?: ListLogsParams): Promise<{
+            items: LogEntry[];
+            meta: {
+                total: number;
+                bufferSize: number;
+                limit: number;
+            };
+        }>;
+    };
+    /**
+     * Automation management
+     */
+    automations: {
+        /**
+         * List automations
+         */
+        list(params?: ListAutomationsParams): Promise<Automation[]>;
+        /**
+         * Get an automation by ID
+         */
+        get(id: string): Promise<Automation>;
+        /**
+         * Create an automation
+         */
+        create(body: CreateAutomationBody): Promise<Automation>;
+        /**
+         * Update an automation
+         */
+        update(id: string, body: Partial<CreateAutomationBody>): Promise<Automation>;
+        /**
+         * Delete an automation
+         */
+        delete(id: string): Promise<void>;
+        /**
+         * Enable an automation
+         */
+        enable(id: string): Promise<Automation>;
+        /**
+         * Disable an automation
+         */
+        disable(id: string): Promise<Automation>;
+        /**
+         * Test an automation (dry run)
+         */
+        test(id: string, body: TestAutomationBody): Promise<{
+            matched: boolean;
+            wouldExecute?: unknown[];
+        }>;
+        /**
+         * Execute an automation (actually runs actions)
+         */
+        execute(id: string, body: TestAutomationBody): Promise<{
+            automationId: string;
+            triggered: boolean;
+            results: Array<{
+                action: string;
+                status: string;
+                result?: unknown;
+                error?: string;
+                durationMs: number;
+            }>;
+        }>;
+        /**
+         * Get logs for an automation
+         */
+        getLogs(id: string, params?: {
+            limit?: number;
+            cursor?: string;
+        }): Promise<PaginatedResponse<Record<string, unknown>>>;
+    };
+    /**
+     * Dead letter management
+     */
+    deadLetters: {
+        /**
+         * List dead letters
+         */
+        list(params?: ListDeadLettersParams): Promise<PaginatedResponse<DeadLetter>>;
+        /**
+         * Get a dead letter by ID
+         */
+        get(id: string): Promise<DeadLetter>;
+        /**
+         * Get dead letter statistics
+         */
+        stats(): Promise<{
+            pending: number;
+            retrying: number;
+            resolved: number;
+            abandoned: number;
+            total: number;
+        }>;
+        /**
+         * Retry a dead letter
+         */
+        retry(id: string): Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        /**
+         * Resolve a dead letter
+         */
+        resolve(id: string, body: ResolveDeadLetterBody): Promise<DeadLetter>;
+        /**
+         * Abandon a dead letter
+         */
+        abandon(id: string): Promise<DeadLetter>;
+    };
+    /**
+     * Event operations
+     */
+    eventOps: {
+        /**
+         * Get event metrics
+         */
+        metrics(): Promise<Record<string, unknown>>;
+        /**
+         * Start a replay session
+         */
+        startReplay(body: StartReplayBody): Promise<ReplaySession>;
+        /**
+         * List replay sessions
+         */
+        listReplays(): Promise<ReplaySession[]>;
+        /**
+         * Get a replay session by ID
+         */
+        getReplay(id: string): Promise<ReplaySession>;
+        /**
+         * Cancel a replay session
+         */
+        cancelReplay(id: string): Promise<void>;
+    };
+    /**
+     * Webhook source management
+     */
+    webhooks: {
+        /**
+         * List webhook sources
+         */
+        listSources(params?: ListWebhookSourcesParams): Promise<WebhookSource[]>;
+        /**
+         * Get a webhook source by ID
+         */
+        getSource(id: string): Promise<WebhookSource>;
+        /**
+         * Create a webhook source
+         */
+        createSource(body: CreateWebhookSourceBody): Promise<WebhookSource>;
+        /**
+         * Update a webhook source
+         */
+        updateSource(id: string, body: Partial<CreateWebhookSourceBody>): Promise<WebhookSource>;
+        /**
+         * Delete a webhook source
+         */
+        deleteSource(id: string): Promise<void>;
+        /**
+         * Trigger a custom event
+         */
+        trigger(body: TriggerEventBody): Promise<{
+            eventId: string;
+            eventType: string;
+        }>;
+    };
+    /**
+     * Payload management
+     */
+    payloads: {
+        /**
+         * List payloads for an event
+         */
+        listForEvent(eventId: string): Promise<Array<{
+            stage: string;
+            hasData: boolean;
+            createdAt: string;
+        }>>;
+        /**
+         * Get a specific stage payload
+         */
+        getStage(eventId: string, stage: "webhook_raw" | "agent_request" | "agent_response" | "channel_send" | "error"): Promise<{
+            payload?: unknown;
+        }>;
+        /**
+         * Delete payloads for an event
+         */
+        delete(eventId: string, body: DeletePayloadsBody): Promise<{
+            deleted: number;
+        }>;
+        /**
+         * List payload configs
+         */
+        listConfigs(): Promise<PayloadConfig[]>;
+        /**
+         * Update payload config for an event type
+         */
+        updateConfig(eventType: string, body: UpdatePayloadConfigBody): Promise<PayloadConfig>;
+        /**
+         * Get payload statistics
+         */
+        stats(): Promise<{
+            totalPayloads: number;
+            totalSizeBytes: number;
+            byStage: Record<string, number | undefined>;
+        }>;
+    };
+    /**
+     * Batch job management for media processing
+     */
+    batchJobs: {
+        /**
+         * Create a batch processing job
+         */
+        create(body: CreateBatchJobBody): Promise<BatchJob>;
+        /**
+         * Get a batch job by ID
+         */
+        get(id: string): Promise<BatchJob>;
+        /**
+         * Get batch job status (lightweight, for polling)
+         */
+        getStatus(id: string): Promise<BatchJobStatusResponse>;
+        /**
+         * List batch jobs
+         */
+        list(params?: ListBatchJobsParams): Promise<PaginatedResponse<BatchJob>>;
+        /**
+         * Cancel a running batch job
+         */
+        cancel(id: string): Promise<BatchJob>;
+        /**
+         * Estimate cost before creating a job
+         */
+        estimate(body: Omit<CreateBatchJobBody, "force">): Promise<CostEstimate>;
+    };
+    /**
+     * API key management
+     */
+    keys: {
+        /**
+         * Create a new API key
+         * The plainTextKey is only returned in this response.
+         */
+        create(body: CreateApiKeyBody): Promise<CreateApiKeyResult>;
+        /**
+         * List API keys
+         */
+        list(params?: ListApiKeysParams): Promise<{
+            items: ApiKeyRecord[];
+            meta: {
+                total: number;
+            };
+        }>;
+        /**
+         * Get an API key by ID
+         */
+        get(id: string): Promise<ApiKeyRecord>;
+        /**
+         * Update an API key
+         */
+        update(id: string, body: UpdateApiKeyBody): Promise<ApiKeyRecord>;
+        /**
+         * Revoke an API key
+         */
+        revoke(id: string, body?: RevokeApiKeyBody): Promise<ApiKeyRecord>;
+        /**
+         * Delete an API key permanently
+         */
+        delete(id: string): Promise<void>;
+    };
+    /**
+     * Conversation context for turn-based agents and CLI
+     */
+    context: {
+        /**
+         * Get current conversation context for this API key
+         */
+        get(): Promise<{
+            instanceId: string | null;
+            chatId: string | null;
+            messageId: string | null;
+            activeInstanceId: string | null;
+            updatedAt: string | null;
+        }>;
+        /**
+         * Set conversation context (instance, chat, message)
+         */
+        set(body: {
+            instanceId?: string;
+            chatId?: string;
+            messageId?: string;
+        }): Promise<void>;
+        /**
+         * Set active instance (admin convenience)
+         */
+        use(instanceId: string): Promise<void>;
+        /**
+         * Clear conversation context
+         */
+        clear(): Promise<void>;
+    };
+    /**
+     * Multimodal media operations: TTS, STT, image gen, video gen, vision.
+     * Provider-routed via the API provider registry.
+     */
+    media: {
+        /**
+         * Synthesize text to speech via the registered TTS provider.
+         *
+         * Provider resolution order:
+         *   1. Explicit `provider` parameter
+         *   2. Config default (`tts.provider` setting)
+         *   3. First registered provider
+         *
+         * Returns the audio as a Buffer plus metadata.
+         */
+        tts(body: {
+            text: string;
+            provider?: string;
+            voice?: string;
+            language?: string;
+            speed?: number;
+            format?: "mp3" | "ogg" | "opus" | "wav" | "pcm" | "flac" | "aac";
+            style?: string;
+        }): Promise<{
+            provider: string;
+            mimeType: string;
+            durationMs: number;
+            sizeBytes: number;
+            audio: Buffer;
+        }>;
+        /**
+         * Transcribe audio to text via the registered STT provider.
+         *
+         * Provider resolution order:
+         *   1. Explicit `provider` parameter
+         *   2. Config default (`stt.provider` setting)
+         *   3. First registered provider
+         *
+         * Pass `timestamps: true` to receive per-segment breakdown.
+         */
+        stt(body: {
+            audio: Buffer;
+            mimeType: string;
+            provider?: string;
+            language?: string;
+            timestamps?: boolean;
+            model?: string;
+        }): Promise<{
+            provider: string;
+            text: string;
+            segments?: Array<{
+                text: string;
+                startMs?: number;
+                endMs?: number;
+            }>;
+            detectedLanguage?: string;
+            processingMs: number;
+        }>;
+        /**
+         * Generate image(s) from a text prompt via the registered imagegen provider.
+         *
+         * Provider resolution order:
+         *   1. Explicit `provider` parameter
+         *   2. Config default (`imagegen.provider` setting)
+         *   3. First registered provider
+         *
+         * Returns base64-encoded images plus metadata. Callers can save to disk
+         * or forward to a chat via `client.messages.sendMedia`.
+         */
+        imagine(body: {
+            prompt: string;
+            provider?: string;
+            count?: number;
+            aspectRatio?: "1:1" | "4:3" | "3:4" | "16:9" | "9:16" | "3:2" | "2:3";
+            imageSize?: string;
+            model?: string;
+            negativePrompt?: string;
+            seed?: number;
+        }): Promise<{
+            provider: string;
+            processingMs: number;
+            images: Array<{
+                mimeType: string;
+                sizeBytes: number;
+                base64: string;
+                width?: number;
+                height?: number;
+                seed?: number;
+            }>;
+        }>;
+        /**
+         * Describe an image or video via the registered vision provider.
+         *
+         * Provider resolution order:
+         *   1. Explicit `provider` parameter
+         *   2. Config default (`vision.provider` setting)
+         *   3. First registered provider
+         *
+         * Pass a guided `prompt` for targeted descriptions (e.g. "What color is the cat?").
+         */
+        vision(body: {
+            media: Buffer;
+            mimeType: string;
+            provider?: string;
+            prompt?: string;
+            language?: string;
+            maxTokens?: number;
+        }): Promise<{
+            provider: string;
+            text: string;
+            processingMs: number;
+        }>;
+        /**
+         * Generate a video from a text prompt via the registered video-gen provider.
+         *
+         * The API blocks until generation completes, polls internally, and
+         * returns the final MP4 as base64. Generation typically takes 60–180
+         * seconds with Veo 3.1. The server enforces a 5-minute timeout.
+         *
+         * Provider resolution order:
+         *   1. Explicit `provider` parameter
+         *   2. Config default (`videogen.provider` setting)
+         *   3. First registered provider
+         */
+        film(body: {
+            prompt: string;
+            provider?: string;
+            durationSec?: number;
+            resolution?: string;
+            aspectRatio?: string;
+            seed?: number;
+            audio?: boolean;
+        }): Promise<{
+            provider: string;
+            operationId: string;
+            mimeType: string;
+            sizeBytes: number;
+            durationMs: number;
+            videoBase64: string;
+        }>;
+    };
+    /**
+     * Turn lifecycle for turn-based agent execution
+     */
+    turns: {
+        /**
+         * Close the open turn for this API key.
+         * Idempotent: closing an already-closed turn returns success with alreadyClosed: true.
+         */
+        close(body: {
+            action: "message" | "react" | "skip";
+            reason?: string;
+            turnId?: string;
+        }, extraHeaders?: Record<string, string>): Promise<{
+            turnId?: string;
+            action?: string;
+            duration?: number;
+            nudgeCount?: number;
+            messagesSent?: number;
+            closedAt?: string;
+            alreadyClosed?: boolean;
+            message?: string;
+        }>;
+        /**
+         * List turns with optional filters and pagination. Requires turns:admin scope.
+         */
+        list(params?: {
+            status?: "open" | "done" | "timeout";
+            instanceId?: string;
+            chatId?: string;
+            agentId?: string;
+            limit?: number;
+            offset?: number;
+        }): Promise<{
+            items: TurnItem[];
+            total: number;
+            limit: number;
+            offset: number;
+        }>;
+        /**
+         * Get a single turn by ID. Requires turns:admin scope.
+         */
+        get(id: string): Promise<TurnItem>;
+        /**
+         * Admin force-close a turn. Requires turns:admin scope.
+         */
+        forceClose(id: string, reason?: string): Promise<{
+            turnId: string;
+            status: string;
+            closedAt: string | null;
+        }>;
+        /**
+         * Bulk close all open turns. Requires turns:admin scope.
+         */
+        bulkClose(reason?: string): Promise<{
+            closedCount: number;
+            message: string;
+        }>;
+        /**
+         * Get aggregate turn stats. Requires turns:admin scope.
+         */
+        stats(): Promise<TurnStats>;
+    };
+    /**
+     * Agent entity CRUD
+     */
+    agents: {
+        /**
+         * List all agents
+         */
+        list(params?: {
+            provider?: "claude" | "agno" | "openai" | "gemini" | "custom" | "omni-internal";
+            isActive?: boolean;
+            limit?: number;
+            ownerId?: string;
+        }): Promise<PaginatedResponse<components["schemas"]["Agent"]>>;
+        /**
+         * Get a single agent by ID
+         */
+        get(id: string): Promise<components["schemas"]["Agent"]>;
+        /**
+         * Create a new agent
+         */
+        create(body: components["schemas"]["CreateAgentRequest"]): Promise<components["schemas"]["Agent"]>;
+        /**
+         * Update an existing agent (partial patch).
+         * Only fields present in `body` are changed; UUID and omitted fields are preserved.
+         */
+        update(id: string, body: NonNullable<operations["updateAgent"]["requestBody"]>["content"]["application/json"]): Promise<components["schemas"]["Agent"]>;
+        /**
+         * Delete an agent (soft-delete)
+         */
+        delete(id: string): Promise<void>;
+    };
+    /**
+     * Idle-chat follow-up config surface. Three scopes (agent, instance, chat);
+     * closest-defined wins at runtime. See the wish for the full resolution
+     * hierarchy.
+     */
+    followUp: {
+        getAgent(id: string): Promise<components["schemas"]["FollowUpSequenceConfig"] | null>;
+        setAgent(id: string, config: components["schemas"]["FollowUpSequenceConfig"]): Promise<components["schemas"]["FollowUpSequenceConfig"] | null>;
+        unsetAgent(id: string): Promise<void>;
+        getInstance(id: string): Promise<components["schemas"]["FollowUpSequenceConfig"] | null>;
+        setInstance(id: string, config: components["schemas"]["FollowUpSequenceConfig"]): Promise<components["schemas"]["FollowUpSequenceConfig"] | null>;
+        unsetInstance(id: string): Promise<void>;
+        getChat(id: string): Promise<components["schemas"]["FollowUpSequenceConfig"] | null>;
+        setChat(id: string, config: components["schemas"]["FollowUpSequenceConfig"]): Promise<components["schemas"]["FollowUpSequenceConfig"] | null>;
+        unsetChat(id: string): Promise<void>;
+    };
+    /**
+     * System health
+     */
+    system: {
+        /**
+         * Get health status (no auth required)
+         */
+        health(): Promise<HealthResponse>;
+    };
+    /**
+     * Raw openapi-fetch client for advanced usage
+     */
+    raw: import("openapi-fetch").Client<paths, `${string}/${string}`>;
+};
+/**
+ * Type for the Omni client
+ */
+export type OmniClient = ReturnType<typeof createOmniClient>;
+//# sourceMappingURL=client.d.ts.map