@lifesi/genesis 0.0.0-stage → 0.1.1

package/dist/genesis.d.ts

@@ -0,0 +1,830 @@
+import { GenesisClient, type GenesisOptions } from './client.js';
+import type { OperationInput as In } from './types.js';
+import type { components } from './generated/schema.js';
+import { type HivesUploadOptions } from './hives-upload.js';
+type S = components['schemas'];
+export type ChatMessage = {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+} & Record<string, unknown>;
+/**
+ * The Genesis SDK: one client, every service.
+ *   const genesis = new Genesis();                // GENESIS_API_KEY or `genesis login`
+ *   await genesis.hives.projects.list();
+ *   await genesis.foundry.chat({ model: 'x', messages: [{ role: 'user', content: 'hi' }] });
+ */
+export declare class Genesis extends GenesisClient {
+    constructor(opts?: GenesisOptions);
+    /** Generic escape hatch: genesis.call('hives_list_projects', {...}) */
+    call: <K extends import("./index.js").OperationId>(operationId: K, input?: In<K>, init?: {
+        signal?: AbortSignal;
+        headers?: Record<string, string>;
+    }) => Promise<import("./types.js").OperationOutput<K>>;
+    readonly dials: {
+        overview: {
+            summary: (scope: import("./dials.js").DialsScope) => Promise<{
+                ok: boolean;
+                scope: components["schemas"]["Dials.Scope"];
+                calls: {
+                    total: number;
+                    queued: number;
+                    active: number;
+                    completed: number;
+                    failed: number;
+                };
+                dispatch: {
+                    total: number;
+                    pending: number;
+                    claimed: number;
+                    dispatched: number;
+                    failed: number;
+                };
+                people: {
+                    deployed: number;
+                };
+                agents: {
+                    deployed: number;
+                };
+                routes: {
+                    deployed: number;
+                };
+                numbers: {
+                    deployed: number;
+                };
+                voice: {
+                    deployed: number;
+                };
+                messages: {
+                    total: number;
+                    queued: number;
+                    delivered: number;
+                    failed: number;
+                };
+                usage: {
+                    total: number;
+                    quantity: number;
+                    lastMetric: string | null;
+                    lastResourceId: string | null;
+                };
+            }>;
+            operatingSurface: (scope: import("./dials.js").DialsScope) => Promise<{
+                ok: boolean;
+                scope: components["schemas"]["Dials.Scope"];
+                summary: components["schemas"]["Dials.ConsoleSummary"];
+                surfaces: components["schemas"]["Dials.OperatingSurfaceCard"][];
+            } & {
+                [key: string]: unknown;
+            }>;
+        };
+        numbers: {
+            reconciliations: (scope: import("./dials.js").DialsScope) => Promise<{
+                ok: boolean;
+                reconciliations: components["schemas"]["Dials.InventoryReconciliation"][];
+            }>;
+            drift: (scope: import("./dials.js").DialsScope) => Promise<{
+                ok: boolean;
+                drift: components["schemas"]["Dials.InventoryDrift"][];
+            }>;
+            updateCallerName: (body: In<"dials_updateNumberCallerName">["body"]) => Promise<{
+                ok: boolean;
+                number: components["schemas"]["Dials.Number"];
+                auditId: string;
+                next: string;
+            }>;
+            reconcile: (body: In<"dials_reconcileNumberInventory">["body"]) => Promise<{
+                ok: boolean;
+                reconciliations: components["schemas"]["Dials.InventoryReconciliation"][];
+                drift: components["schemas"]["Dials.InventoryDrift"][];
+                orphanCount: number;
+                auditId: string;
+                next: string;
+            }>;
+            list: (scope: import("./dials.js").DialsScope) => Promise<{
+                ok: boolean;
+                numbers: components["schemas"]["Dials.Number"][];
+            }>;
+            search: (scope: import("./dials.js").DialsScope, query?: Omit<In<"dials_searchNumbers">, keyof import("./dials.js").DialsScope>) => Promise<{
+                ok: boolean;
+                numbers: components["schemas"]["Dials.AvailableNumber"][];
+            }>;
+            provision: (body: In<"dials_provisionNumber">["body"]) => Promise<{
+                [key: string]: unknown;
+            }>;
+            assign: (body: In<"dials_assignNumber">["body"]) => Promise<{
+                [key: string]: unknown;
+            }>;
+            release: (body: In<"dials_releaseNumber">["body"]) => Promise<{
+                [key: string]: unknown;
+            }>;
+            registerEmergencyAddress: (body: import("./dials.js").DialsEmergencyAddress) => Promise<{
+                ok: boolean;
+                number: components["schemas"]["Dials.Number"];
+                address: components["schemas"]["Dials.EmergencyAddress"];
+                auditId: string;
+                next: string;
+            }>;
+        };
+        calls: {
+            list: (scope: import("./dials.js").DialsScope) => Promise<{
+                ok: boolean;
+                calls: components["schemas"]["Dials.Call"][];
+            }>;
+            validate: (body: import("./dials.js").DialsOutboundCall) => Promise<{
+                [key: string]: unknown;
+            }>;
+            create: (body: import("./dials.js").DialsOutboundCall) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+    };
+    readonly henry: {
+        config: () => Promise<{
+            credential_configured: boolean;
+            models: {
+                id: string;
+            }[];
+        }>;
+        credential: (api_key: string) => Promise<{
+            credential_configured: boolean;
+            models: {
+                id: string;
+            }[];
+        }>;
+        runs: {
+            list: (page_token?: string) => Promise<{
+                runs: components["schemas"]["Henry.Run"][];
+                next_page_token?: string | null;
+            }>;
+            create: (body: NonNullable<In<"henry_createRun">["body"]>) => Promise<{
+                id: string;
+                task: string;
+                model: string;
+                status: "ready" | "running" | "acting" | "paused" | "awaiting_approval" | "completed" | "cancelled" | "failed" | "waiting_input";
+                created_at: string;
+                updated_at: string;
+                activity: {
+                    id: string;
+                    at: string;
+                    type: string;
+                    detail: string;
+                }[];
+                approvals: {
+                    id: string;
+                    action: string;
+                    url: string;
+                    status: string;
+                    requested_at: string;
+                }[];
+                phases: {
+                    id?: string;
+                    code?: number;
+                    receipt?: Record<string, never>;
+                    usage?: Record<string, never> | null;
+                }[];
+                messages: ({
+                    role: string;
+                    content?: string | null;
+                } & {
+                    [key: string]: unknown;
+                })[];
+            }>;
+            get: (run_id: string) => Promise<{
+                id: string;
+                task: string;
+                model: string;
+                status: "ready" | "running" | "acting" | "paused" | "awaiting_approval" | "completed" | "cancelled" | "failed" | "waiting_input";
+                created_at: string;
+                updated_at: string;
+                activity: {
+                    id: string;
+                    at: string;
+                    type: string;
+                    detail: string;
+                }[];
+                approvals: {
+                    id: string;
+                    action: string;
+                    url: string;
+                    status: string;
+                    requested_at: string;
+                }[];
+                phases: {
+                    id?: string;
+                    code?: number;
+                    receipt?: Record<string, never>;
+                    usage?: Record<string, never> | null;
+                }[];
+                messages: ({
+                    role: string;
+                    content?: string | null;
+                } & {
+                    [key: string]: unknown;
+                })[];
+            }>;
+            command: (run_id: string, action: "pause" | "resume" | "cancel" | "input", text?: string) => Promise<{
+                id: string;
+                task: string;
+                model: string;
+                status: "ready" | "running" | "acting" | "paused" | "awaiting_approval" | "completed" | "cancelled" | "failed" | "waiting_input";
+                created_at: string;
+                updated_at: string;
+                activity: {
+                    id: string;
+                    at: string;
+                    type: string;
+                    detail: string;
+                }[];
+                approvals: {
+                    id: string;
+                    action: string;
+                    url: string;
+                    status: string;
+                    requested_at: string;
+                }[];
+                phases: {
+                    id?: string;
+                    code?: number;
+                    receipt?: Record<string, never>;
+                    usage?: Record<string, never> | null;
+                }[];
+                messages: ({
+                    role: string;
+                    content?: string | null;
+                } & {
+                    [key: string]: unknown;
+                })[];
+            }>;
+            approval: (run_id: string, approval_id: string, decision: "approve" | "reject") => Promise<{
+                id: string;
+                task: string;
+                model: string;
+                status: "ready" | "running" | "acting" | "paused" | "awaiting_approval" | "completed" | "cancelled" | "failed" | "waiting_input";
+                created_at: string;
+                updated_at: string;
+                activity: {
+                    id: string;
+                    at: string;
+                    type: string;
+                    detail: string;
+                }[];
+                approvals: {
+                    id: string;
+                    action: string;
+                    url: string;
+                    status: string;
+                    requested_at: string;
+                }[];
+                phases: {
+                    id?: string;
+                    code?: number;
+                    receipt?: Record<string, never>;
+                    usage?: Record<string, never> | null;
+                }[];
+                messages: ({
+                    role: string;
+                    content?: string | null;
+                } & {
+                    [key: string]: unknown;
+                })[];
+            }>;
+        };
+    };
+    readonly fleets: {
+        connection: {
+            get: () => Promise<{
+                connected: boolean;
+                model: string;
+                updated_at?: number;
+            }>;
+            set: (api_key: string) => Promise<{
+                connected: boolean;
+                model: string;
+                updated_at?: number;
+            }>;
+            delete: () => Promise<{
+                connected: boolean;
+                model: string;
+                updated_at?: number;
+            }>;
+        };
+        tasks: {
+            list: (query?: In<"fleets_listTasks">) => Promise<{
+                tasks: components["schemas"]["Fleets.Summary"][];
+                next_before: string | null;
+            }>;
+            submit: (body: {
+                input: string;
+                timeout_seconds?: number;
+                idempotency_key?: string;
+            }) => Promise<{
+                task_id: string;
+                status: components["schemas"]["Fleets.Status"];
+                submitted_at: string;
+                started_at?: string | null;
+                completed_at?: string | null;
+            }>;
+            get: (task_id: string) => Promise<{
+                task_id: string;
+                status: components["schemas"]["Fleets.Status"];
+                submitted_at: string;
+                started_at?: string | null;
+                completed_at?: string | null;
+            }>;
+            cancel: (task_id: string) => Promise<{
+                task_id: string;
+                status: components["schemas"]["Fleets.Status"];
+            }>;
+            receipt: (task_id: string) => Promise<{
+                task_id: string;
+                status: components["schemas"]["Fleets.Status"];
+                submitted_at: string;
+                started_at?: string | null;
+                completed_at?: string | null;
+            } & {
+                tenant: string;
+                principal: string;
+                idempotency_key: string | null;
+                request_fingerprint: string;
+                timeout_seconds: number;
+                exit_code: number | null;
+                exit_signal: number | null;
+                cleanup_result: {
+                    process_group_gone?: boolean;
+                    workdir_removed?: boolean;
+                    sigkill_sent?: boolean;
+                } | null;
+                henry_receipt?: {
+                    [key: string]: unknown;
+                };
+            }>;
+        };
+    };
+    readonly runner: Readonly<{
+        catalog: (opts?: import("./runner.js").RunnerRequestOptions) => Promise<{
+            workspaces: {
+                key: components["schemas"]["Runner.SafeOpaqueRef"];
+                label: string;
+            }[];
+            routes: {
+                routeId: components["schemas"]["Runner.SafeOpaqueRef"];
+                kind: "external-harness" | "internal-model";
+                name: string;
+                via: string;
+                state: "synthetic" | "bound" | "unbound";
+                default: boolean;
+            }[];
+        }>;
+        jobs: Readonly<{
+            list: (opts?: import("./runner.js").RunnerRequestOptions) => Promise<{
+                jobs: components["schemas"]["Runner.Snapshot"][];
+            }>;
+            start: (input: import("./runner.js").RunnerStartInput, opts?: import("./runner.js").RunnerRequestOptions) => Promise<{
+                jobId: components["schemas"]["Runner.SafeOpaqueRef"];
+                snapshot: components["schemas"]["Runner.Snapshot"];
+            }>;
+            get: (jobId: string, opts?: import("./runner.js").RunnerRequestOptions) => Promise<{
+                snapshot: components["schemas"]["Runner.Snapshot"];
+            }>;
+            events: (jobId: string, afterSeq?: number, opts?: import("./runner.js").RunnerRequestOptions) => Promise<{
+                events: components["schemas"]["Runner.Event"][];
+                nextAfterSeq: number;
+                hasMore: boolean;
+            }>;
+            result: (jobId: string, opts?: import("./runner.js").RunnerRequestOptions) => Promise<{
+                result: components["schemas"]["Runner.ProviderResult"];
+            }>;
+            cancel: (jobId: string, opts?: import("./runner.js").RunnerRequestOptions) => Promise<{
+                snapshot: components["schemas"]["Runner.Snapshot"];
+            }>;
+        }>;
+    }>;
+    readonly beacons: {
+        devices: {
+            list: () => Promise<{
+                data?: components["schemas"]["Beacons.BridgeDevice"][];
+            }>;
+            update: (id: string, body: In<"beacons_updateBridgeDevice">["body"]) => Promise<{
+                id: string;
+                org_id: string;
+                name: string;
+                nicknames: string[];
+                created_at: string;
+                status: string;
+            }>;
+            revoke: (id: string) => Promise<import("./types.js").OperationOutput<"beacons_revokeBridgeDevice"> | undefined>;
+        };
+    };
+    readonly foundry: {
+        models: {
+            list: () => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+        /** OpenAI-compatible chat completion (non-streaming). */
+        chat: (body: {
+            model: string;
+            messages: ChatMessage[];
+        } & Record<string, unknown>) => Promise<{
+            id: string;
+            model?: string;
+            choices: {
+                [key: string]: unknown;
+            }[];
+            usage?: components["schemas"]["Foundry.Usage"];
+            foundry?: components["schemas"]["Foundry.RequestMetadata"];
+        } & {
+            [key: string]: unknown;
+        }>;
+        /** Streaming chat: yields content deltas parsed from the SSE stream. */
+        chatStream: (body: {
+            model: string;
+            messages: ChatMessage[];
+        } & Record<string, unknown>) => AsyncGenerator<string, any, any>;
+        embeddings: (body: In<"foundry_createEmbedding">["body"]) => Promise<{
+            object?: string;
+            model?: string;
+            data: {
+                [key: string]: unknown;
+            }[];
+            usage?: components["schemas"]["Foundry.Usage"];
+        } & {
+            [key: string]: unknown;
+        }>;
+        registry: {
+            models: (q?: In<"foundry_listRegistryModels">) => Promise<{
+                [key: string]: unknown;
+            }>;
+            model: (canonical_model_id: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+    };
+    readonly hives: {
+        projects: {
+            list: (q?: In<"hives_list_projects">) => Promise<{
+                data: (Record<string, never> & {
+                    active_instances: number;
+                    current_version?: number | null;
+                    requests_24h: number;
+                    total_deployments: number;
+                })[];
+                pagination: components["schemas"]["Hives.PaginationMeta"];
+            }>;
+            get: (project_id: string) => Promise<Record<string, never> & {
+                active_instances: number;
+                current_version?: number | null;
+                requests_24h: number;
+                total_deployments: number;
+            }>;
+            create: (body: In<"hives_create_project">["body"]) => Promise<Record<string, never> & {
+                active_instances: number;
+                current_version?: number | null;
+                requests_24h: number;
+                total_deployments: number;
+            }>;
+            update: (project_id: string, body: In<"hives_update_project">["body"]) => Promise<Record<string, never> & {
+                active_instances: number;
+                current_version?: number | null;
+                requests_24h: number;
+                total_deployments: number;
+            }>;
+            activity: (project_id: string, q?: Omit<In<"hives_get_project_activity">, "project_id">) => Promise<{
+                data: components["schemas"]["Hives.ActivityEntry"][];
+                pagination: components["schemas"]["Hives.PaginationMeta"];
+            }>;
+            delete: (project_id: string) => Promise<{
+                id: string;
+                message: string;
+                success: boolean;
+            }>;
+        };
+        secrets: {
+            list: (project_id: string, q?: Omit<In<"hives_list_secrets">, "project_id">) => Promise<{
+                data: {
+                    created_at: string;
+                    description?: string | null;
+                    name: string;
+                    updated_at: string;
+                    version: number;
+                }[];
+                pagination: components["schemas"]["Hives.PaginationMeta"];
+            }>;
+            get: (project_id: string, secret_id: string) => Promise<{
+                id: string;
+                created_at: string;
+                description?: string | null;
+                name: string;
+                updated_at: string;
+                version: number;
+            }>;
+            create: (project_id: string, body: In<"hives_create_secret">["body"]) => Promise<{
+                id: string;
+                created_at: string;
+                description?: string | null;
+                name: string;
+                updated_at: string;
+                version: number;
+            }>;
+            update: (project_id: string, secret_id: string, body: In<"hives_update_secret">["body"]) => Promise<{
+                id: string;
+                created_at: string;
+                description?: string | null;
+                name: string;
+                updated_at: string;
+                version: number;
+            }>;
+            delete: (project_id: string, secret_id: string) => Promise<{
+                id: string;
+                message: string;
+                success: boolean;
+            }>;
+            /** Explicit sensitive operation. Do not log or retain the returned plaintext. */
+            reveal: (project_id: string, secret_id: string) => Promise<{
+                value: string;
+            }>;
+            bulkUpsert: (project_id: string, body: In<"hives_bulk_upsert_secrets">["body"]) => Promise<{
+                success: boolean;
+                secrets: components["schemas"]["Hives.SecretResponse"][];
+            }>;
+        };
+        deployments: {
+            list: (project_id: string, q?: Omit<In<"hives_list_deployments">, "project_id">) => Promise<{
+                data: (Record<string, never> & {
+                    logs_url?: string | null;
+                    url?: string | null;
+                })[];
+                pagination: components["schemas"]["Hives.PaginationMeta"];
+            }>;
+            get: (project_id: string, deployment_id: string) => Promise<{
+                id: string;
+                project_id: string;
+                tenant_id: string;
+                module_id: string;
+                module_hash?: string | null;
+                version: number;
+                status: string;
+                git_sha?: string | null;
+                git_branch?: string | null;
+                created_by: string;
+                created_at: string;
+                promoted_at?: string | null;
+                logs_url?: string | null;
+                url?: string | null;
+            }>;
+            upload: (project_id: string, file: Blob, options?: HivesUploadOptions) => Promise<{
+                id: string;
+                project_id: string;
+                tenant_id: string;
+                module_id: string;
+                module_hash?: string | null;
+                version: number;
+                status: string;
+                git_sha?: string | null;
+                git_branch?: string | null;
+                created_by: string;
+                created_at: string;
+                promoted_at?: string | null;
+                logs_url?: string | null;
+                url?: string | null;
+            }>;
+            create: (project_id: string, body: In<"hives_create_deployment">["body"]) => Promise<{
+                id: string;
+                project_id: string;
+                tenant_id: string;
+                module_id: string;
+                module_hash?: string | null;
+                version: number;
+                status: string;
+                git_sha?: string | null;
+                git_branch?: string | null;
+                created_by: string;
+                created_at: string;
+                promoted_at?: string | null;
+                logs_url?: string | null;
+                url?: string | null;
+            }>;
+            promote: (project_id: string, deployment_id: string) => Promise<{
+                id: string;
+                project_id: string;
+                tenant_id: string;
+                module_id: string;
+                module_hash?: string | null;
+                version: number;
+                status: string;
+                git_sha?: string | null;
+                git_branch?: string | null;
+                created_by: string;
+                created_at: string;
+                promoted_at?: string | null;
+                logs_url?: string | null;
+                url?: string | null;
+            }>;
+            rollback: (project_id: string, deployment_id: string, body?: In<"hives_rollback_deployment">["body"]) => Promise<{
+                id: string;
+                project_id: string;
+                tenant_id: string;
+                module_id: string;
+                module_hash?: string | null;
+                version: number;
+                status: string;
+                git_sha?: string | null;
+                git_branch?: string | null;
+                created_by: string;
+                created_at: string;
+                promoted_at?: string | null;
+                logs_url?: string | null;
+                url?: string | null;
+            }>;
+            cancel: (project_id: string, deployment_id: string) => Promise<{
+                id: string;
+                project_id: string;
+                tenant_id: string;
+                module_id: string;
+                module_hash?: string | null;
+                version: number;
+                status: string;
+                git_sha?: string | null;
+                git_branch?: string | null;
+                created_by: string;
+                created_at: string;
+                promoted_at?: string | null;
+                logs_url?: string | null;
+                url?: string | null;
+            }>;
+            delete: (project_id: string, deployment_id: string) => Promise<{
+                id: string;
+                message: string;
+                success: boolean;
+            }>;
+            logs: (project_id: string, deployment_id: string, q?: Omit<In<"hives_query_deployment_logs">, "project_id" | "deployment_id">) => Promise<{
+                logs: components["schemas"]["Hives.LogEntry"][];
+                pagination: components["schemas"]["Hives.PaginationMeta"];
+                time_range: components["schemas"]["Hives.TimeRange"];
+            }>;
+            invoke: (project_id: string, deployment_id: string, body?: In<"hives_invoke_deployment">["body"], init?: {
+                signal?: AbortSignal;
+            }) => Promise<Response>;
+        };
+        functions: {
+            list: (project_id: string, q?: Omit<In<"hives_list_functions">, "project_id">) => Promise<{
+                data: components["schemas"]["Hives.FunctionResponse"][];
+                pagination: components["schemas"]["Hives.PaginationMeta"];
+            }>;
+            get: (project_id: string, function_id: string) => Promise<{
+                id: string;
+                tenant_id: string;
+                project_id: string;
+                name: string;
+                description?: string | null;
+                handler: string;
+                route?: string | null;
+                memory_mb: number;
+                timeout_ms: number;
+                status: string;
+                invocations: number;
+                avg_duration_ms: number;
+                created_at: string;
+                updated_at: string;
+            }>;
+            create: (project_id: string, body: In<"hives_create_function">["body"]) => Promise<{
+                id: string;
+                tenant_id: string;
+                project_id: string;
+                name: string;
+                description?: string | null;
+                handler: string;
+                route?: string | null;
+                memory_mb: number;
+                timeout_ms: number;
+                status: string;
+                invocations: number;
+                avg_duration_ms: number;
+                created_at: string;
+                updated_at: string;
+            }>;
+            update: (project_id: string, function_id: string, body: In<"hives_update_function">["body"]) => Promise<{
+                id: string;
+                tenant_id: string;
+                project_id: string;
+                name: string;
+                description?: string | null;
+                handler: string;
+                route?: string | null;
+                memory_mb: number;
+                timeout_ms: number;
+                status: string;
+                invocations: number;
+                avg_duration_ms: number;
+                created_at: string;
+                updated_at: string;
+            }>;
+            delete: (project_id: string, function_id: string) => Promise<{
+                id: string;
+                message: string;
+                success: boolean;
+            }>;
+            /** Completed raw guest response; parse text/JSON/bytes explicitly. Never follows redirects. */
+            invoke: (project_id: string, function_id: string, body?: In<"hives_invoke_function">["body"], init?: {
+                signal?: AbortSignal;
+            }) => Promise<Response>;
+        };
+        regions: {
+            list: () => Promise<{
+                regions: components["schemas"]["Hives.Region"][];
+            }>;
+        };
+    };
+    readonly relays: {
+        zones: {
+            list: (q?: In<"relays_listZones">) => Promise<{
+                zones?: components["schemas"]["Relays.Zone"][];
+                meta?: components["schemas"]["Relays.Meta"];
+            }>;
+            get: (zone: string) => Promise<{
+                id?: number;
+                name?: string;
+                type?: "NATIVE" | "MASTER" | "SLAVE";
+                record_count?: number;
+                dnssec_enabled?: boolean;
+                status?: string;
+                serial?: number;
+                nameservers?: string[];
+                soa?: {
+                    [key: string]: unknown;
+                };
+                created_at?: string;
+                updated_at?: string;
+            }>;
+            create: (body: S["Relays.CreateZone"]) => Promise<{
+                id?: number;
+                name?: string;
+                type?: "NATIVE" | "MASTER" | "SLAVE";
+                record_count?: number;
+                dnssec_enabled?: boolean;
+                status?: string;
+                serial?: number;
+                nameservers?: string[];
+                soa?: {
+                    [key: string]: unknown;
+                };
+                created_at?: string;
+                updated_at?: string;
+            }>;
+            delete: (zone: string) => Promise<{
+                success?: boolean;
+                message?: string;
+            }>;
+        };
+        records: {
+            list: (zone: string, q?: Omit<In<"relays_listRecords">, "zone">) => Promise<{
+                zone?: string;
+                records?: components["schemas"]["Relays.Record"][];
+                meta?: components["schemas"]["Relays.Meta"];
+            }>;
+            create: (zone: string, body: S["Relays.RecordInput"]) => Promise<{
+                [key: string]: unknown;
+            }>;
+            update: (zone: string, recordId: number, body: S["Relays.RecordPatch"]) => Promise<{
+                name: string;
+                type: string;
+                content: string;
+                ttl?: number;
+                priority?: number;
+                disabled?: boolean;
+                comment?: string;
+                tags?: string[];
+            } & {
+                id?: number;
+                zone?: string;
+                created_at?: string;
+                updated_at?: string;
+            }>;
+            delete: (zone: string, recordId: number) => Promise<{
+                success?: boolean;
+                message?: string;
+            }>;
+        };
+    };
+    /** LifeID org API keys (WorkOS). custody 'blinds' = key goes straight to Blinds, never shown. */
+    readonly keys: {
+        list: (org_id: string) => Promise<{
+            object: "list";
+            data: components["schemas"]["Iam.ApiKeyMetadata"][];
+        }>;
+        create: (org_id: string, body: S["Iam.CreateApiKeyRequest"]) => Promise<{
+            id: string;
+            name: string;
+            obfuscated_value: string;
+            value?: string | null;
+            blinds_credential_ref?: string | null;
+            scopes: string[];
+            expires_at?: string | null;
+            created_at: string;
+        }>;
+        revoke: (key_id: string) => Promise<void>;
+    };
+    /** Who is this credential? (LifeID verify: org, principal, scopes, kind) */
+    whoami(): Promise<S['Iam.VerifiedPrincipal']>;
+    private streamChat;
+}
+export {};