@onesi/genesis 0.0.1-stage → 0.1.13

package/dist/genesis.d.ts

@@ -0,0 +1,2926 @@
+import { type GenesisContextSelection } from './context.js';
+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';
+import { type HivesInvokeOptions } from './hives-functions.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 context: {
+        select: (selection: GenesisContextSelection, options?: {
+            signal?: AbortSignal;
+        }) => Promise<import("./context.js").GenesisContextSession>;
+    };
+    readonly minds: {
+        agent: {
+            memory: {
+                insert: (mind: string, event: import("./minds-agent.js").MindsAgentEventInput, options?: import("./minds-agent.js").MindsAgentOptions) => Promise<{
+                    id: string;
+                }>;
+                get: (mind: string, storage_id: string, options?: import("./minds-agent.js").MindsAgentOptions) => Promise<{
+                    item: components["schemas"]["Minds.EpisodicEvent"] | null;
+                }>;
+                search: (mind: string, text: string, limit?: number, options?: import("./minds-agent.js").MindsAgentOptions) => Promise<({
+                    id: string;
+                    content: string;
+                    timestamp: string;
+                    event_type: "Conversation" | "Command" | "Query" | "Document" | "Error" | "Success" | "Learning" | "Decision" | "Action" | "Context" | "Knowledge";
+                    summary?: string | null;
+                    tags: string[];
+                } & {
+                    [key: string]: unknown;
+                })[]>;
+            };
+        };
+        list: (query?: In<"minds_listMinds">, options?: import("./minds.js").MindsRequestOptions) => Promise<{
+            schema_version: "minds.controller.v1";
+            items: components["schemas"]["Minds.Mind"][];
+            next_cursor: string | null;
+            context_sha256: string;
+        }>;
+        get: (mind_id: string, options?: import("./minds.js").MindsRequestOptions) => Promise<{
+            schema_version: "minds.controller.v1";
+            mind_id: string;
+            organization_id: string;
+            project_id: string;
+            name: string;
+            region: string;
+            plan: "free" | "pro";
+            capacity: components["schemas"]["Minds.Capacity"];
+            observed_capacity: components["schemas"]["Minds.Capacity"] | null;
+            services: string[];
+            volume_id: string;
+            base_url: string;
+            desired_state: "running" | "stopped" | "deleted";
+            observed_state: "pending" | "running" | "stopped" | "deleted" | "failed" | "uncertain";
+            desired_generation: number;
+            observed_generation: number;
+            status: "ready" | "provisioning" | "stopped" | "deleted" | "failed" | "uncertain";
+            capacity_applied: boolean;
+            operation_id: string | null;
+            error_code: string | null;
+            created_at: string;
+            updated_at: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        usage: (window: In<"minds_getUsage">, options?: import("./minds.js").MindsRequestOptions) => Promise<{
+            schema_version: "minds.controller.v1";
+            organization_id: string;
+            project_id: string;
+            from: string;
+            to: string;
+            measured_at: string;
+            basis: "host_confirmed_intervals";
+            minds: components["schemas"]["Minds.UsageMind"][];
+        }>;
+        create: (name: string, options: import("./minds.js").MindsCreateOptions) => Promise<{
+            schema_version: "minds.controller.v1";
+            mind_id: string;
+            organization_id: string;
+            project_id: string;
+            name: string;
+            region: string;
+            plan: "free" | "pro";
+            capacity: components["schemas"]["Minds.Capacity"];
+            observed_capacity: components["schemas"]["Minds.Capacity"] | null;
+            services: string[];
+            volume_id: string;
+            base_url: string;
+            desired_state: "running" | "stopped" | "deleted";
+            observed_state: "pending" | "running" | "stopped" | "deleted" | "failed" | "uncertain";
+            desired_generation: number;
+            observed_generation: number;
+            status: "ready" | "provisioning" | "stopped" | "deleted" | "failed" | "uncertain";
+            capacity_applied: boolean;
+            operation_id: string | null;
+            error_code: string | null;
+            created_at: string;
+            updated_at: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        resume: (mind_id: string, expected_generation: number, options: import("./minds.js").MindsResumeOptions) => Promise<{
+            schema_version: "minds.controller.v1";
+            mind_id: string;
+            organization_id: string;
+            project_id: string;
+            name: string;
+            region: string;
+            plan: "free" | "pro";
+            capacity: components["schemas"]["Minds.Capacity"];
+            observed_capacity: components["schemas"]["Minds.Capacity"] | null;
+            services: string[];
+            volume_id: string;
+            base_url: string;
+            desired_state: "running" | "stopped" | "deleted";
+            observed_state: "pending" | "running" | "stopped" | "deleted" | "failed" | "uncertain";
+            desired_generation: number;
+            observed_generation: number;
+            status: "ready" | "provisioning" | "stopped" | "deleted" | "failed" | "uncertain";
+            capacity_applied: boolean;
+            operation_id: string | null;
+            error_code: string | null;
+            created_at: string;
+            updated_at: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        stop: (mind_id: string, expected_generation: number, options: import("./minds.js").MindsStopOptions) => Promise<{
+            schema_version: "minds.controller.v1";
+            mind_id: string;
+            organization_id: string;
+            project_id: string;
+            name: string;
+            region: string;
+            plan: "free" | "pro";
+            capacity: components["schemas"]["Minds.Capacity"];
+            observed_capacity: components["schemas"]["Minds.Capacity"] | null;
+            services: string[];
+            volume_id: string;
+            base_url: string;
+            desired_state: "running" | "stopped" | "deleted";
+            observed_state: "pending" | "running" | "stopped" | "deleted" | "failed" | "uncertain";
+            desired_generation: number;
+            observed_generation: number;
+            status: "ready" | "provisioning" | "stopped" | "deleted" | "failed" | "uncertain";
+            capacity_applied: boolean;
+            operation_id: string | null;
+            error_code: string | null;
+            created_at: string;
+            updated_at: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        memory: {
+            insert: (mind: string, event: import("./minds.js").MindsEventInput, options?: import("./minds.js").MindsRequestOptions) => Promise<{
+                id: string;
+            }>;
+            get: (mind: string, storage_id: string, options?: import("./minds.js").MindsRequestOptions) => Promise<{
+                item: components["schemas"]["Minds.EpisodicEvent"] | null;
+            }>;
+            update: (mind: string, storage_id: string, body: {
+                event_id: string;
+                content: string;
+            }, options?: import("./minds.js").MindsRequestOptions) => Promise<{
+                ok: true;
+            }>;
+            search: (mind: string, text: string, limit?: number, options?: import("./minds.js").MindsRequestOptions) => Promise<({
+                id: string;
+                content: string;
+                timestamp: string;
+                event_type: "Conversation" | "Command" | "Query" | "Document" | "Error" | "Success" | "Learning" | "Decision" | "Action" | "Context" | "Knowledge";
+                summary?: string | null;
+                tags: string[];
+            } & {
+                [key: string]: unknown;
+            })[]>;
+        };
+        groups: {
+            list: (options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+                groups: components["schemas"]["Minds.OwnerAgentGroup"][];
+            }>;
+            create: (body: {
+                operationId: string;
+                name: string;
+            }, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+                id: string;
+                organizationId: string;
+                ownerId: string;
+                organizationGeneration: number;
+                name: string;
+                version: number;
+                revokedAt: number | null;
+            }>;
+            members: {
+                list: (group_id: string, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+                    members: components["schemas"]["Minds.OwnerAgentGroupMember"][];
+                }>;
+                add: (group_id: string, body: import("./minds-owner.js").MindsOwnerVersion & {
+                    agentId: string;
+                }, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+                    groupId: string;
+                    agentId: string;
+                    agentDid: string;
+                    agentCreatedAt: number;
+                    version: number;
+                    revokedAt: number | null;
+                }>;
+                remove: (group_id: string, agent_id: string, body: import("./minds-owner.js").MindsOwnerVersion, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+                    groupId: string;
+                    agentId: string;
+                    agentDid: string;
+                    agentCreatedAt: number;
+                    version: number;
+                    revokedAt: number | null;
+                }>;
+            };
+        };
+        attachments: {
+            list: (mind_id: string, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+                attachments: components["schemas"]["Minds.MindAttachment"][];
+            }>;
+            attach: (mind_id: string, body: import("./minds-owner.js").MindsAttachInput, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+                id: string;
+                version: number;
+                organizationId: string;
+                projectId: string;
+                mindId: string;
+                subject: components["schemas"]["Minds.MindAttachmentSubject"];
+                permissions: ["minds.agent_data.read"] | ["minds.agent_data.read", "minds.agent_data.write"];
+                sharedNamespace: string | null;
+                expiresAt: number;
+                revokedAt: number | null;
+            }>;
+            detach: (mind_id: string, attachment_id: string, body: import("./minds-owner.js").MindsOwnerVersion, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+                id: string;
+                version: number;
+                organizationId: string;
+                projectId: string;
+                mindId: string;
+                subject: components["schemas"]["Minds.MindAttachmentSubject"];
+                permissions: ["minds.agent_data.read"] | ["minds.agent_data.read", "minds.agent_data.write"];
+                sharedNamespace: string | null;
+                expiresAt: number;
+                revokedAt: number | null;
+            }>;
+        };
+    };
+    readonly blinds: {
+        credentials: {
+            list: (init?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                credentials: string[];
+            }>;
+            store: (body: In<"blinds_storeCredential">["body"], init?: {
+                signal?: AbortSignal;
+                idempotencyKey?: string;
+            }) => Promise<{
+                variable_name: string;
+            }>;
+            revoke: (variable: string, init?: {
+                signal?: AbortSignal;
+                idempotencyKey?: string;
+            }) => Promise<unknown>;
+        };
+        oauth: {
+            connections: (init?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                connections: components["schemas"]["Blinds.OAuthConnection"][];
+                total: number;
+            }>;
+        };
+        consent: {
+            pending: (init?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                requests: components["schemas"]["Blinds.ConsentPending"][];
+            }>;
+            records: (init?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                records: components["schemas"]["Blinds.ConsentRecord"][];
+            }>;
+            approve: (consent_id: string, body: In<"blinds_approveConsent">["body"], init?: {
+                signal?: AbortSignal;
+                idempotencyKey?: string;
+            }) => Promise<unknown>;
+            deny: (consent_id: string, init?: {
+                signal?: AbortSignal;
+                idempotencyKey?: string;
+            }) => Promise<unknown>;
+            revoke: (consent_id: string, init?: {
+                signal?: AbortSignal;
+                idempotencyKey?: string;
+            }) => Promise<unknown>;
+        };
+        delegates: {
+            list: (init?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                delegates: components["schemas"]["Blinds.Delegate"][];
+            }>;
+            create: (body: In<"blinds_createDelegate">["body"], init?: {
+                signal?: AbortSignal;
+                idempotencyKey?: string;
+            }) => Promise<{
+                delegate_id: string;
+                parent_id?: string | null;
+                name: string;
+                issuer_did: string;
+                delegated_variables: string[];
+                max_depth?: number;
+                current_depth?: number;
+                ttl_seconds?: number;
+                created_at?: string;
+                expires_at: string;
+            }>;
+            revoke: (delegate_id: string, init?: {
+                signal?: AbortSignal;
+                idempotencyKey?: string;
+            }) => Promise<unknown>;
+        };
+        activity: (init?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            events: components["schemas"]["Blinds.ActivityEvent"][];
+        }>;
+        ownerEnrollment: {
+            reserve: (body: In<"blinds_ownerReserve">["body"], init?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                schemaVersion: 1;
+                requestId: string;
+                edReservationId: string;
+                operationId: string;
+                publicKey: string;
+                state: "key_ready" | "attached";
+                expiresAtMs: number;
+                originalOrganizationGeneration: number;
+            }>;
+            sign: (body: In<"blinds_ownerSign">["body"], init?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                schemaVersion: 1;
+                requestId: string;
+                edReservationId: string;
+                enrollmentIntentId: string;
+                operationId: string;
+                signingPayloadSha256: string;
+                signatureMultibase: string;
+            }>;
+            attach: (body: In<"blinds_ownerAttach">["body"], init?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                schemaVersion: 1;
+                requestId: string;
+                edReservationId: string;
+                enrollmentIntentId: string;
+                state: "attached";
+                creation: {
+                    intent_id: string;
+                    operation_id: string;
+                    creation_receipt_id: string;
+                    agent_id: string;
+                    canonical_did: string;
+                    registered_public_key: string;
+                    owner: {
+                        issuer: "https://auth.life.one";
+                        original_owner: string;
+                        organization_generation: number;
+                        scope: {
+                            platform_id: "blinds";
+                            organization_id: string;
+                            workspace_id: string | null;
+                            project_id: string | null;
+                            environment_id: "sandbox" | "live";
+                        };
+                    };
+                };
+            }>;
+            ensureP256: (body: In<"blinds_ownerP256Ensure">["body"], init?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                schemaVersion: 1;
+                requestId: string;
+                edReservationId: string;
+                enrollmentIntentId: string;
+                state: "ready";
+                dpopPublicJwk: {
+                    kty: "EC";
+                    crv: "P-256";
+                    x: string;
+                    y: string;
+                };
+                senderJkt: string;
+            }>;
+        };
+    };
+    readonly dials: {
+        routing: {
+            list: (scope: import("./dials.js").DialsScope) => Promise<{
+                ok: true;
+                scope: components["schemas"]["Dials.Scope"];
+                rules: components["schemas"]["Dials.RoutingRule"][];
+            }>;
+            create: (body: In<"dials_createRoutingRule">["body"]) => Promise<{
+                ok: true;
+                rule: components["schemas"]["Dials.RoutingRule"];
+                auditId: string;
+                idempotentReplay: boolean;
+            }>;
+            disable: (ruleId: string, body: In<"dials_disableRoutingRule">["body"]) => Promise<{
+                ok: true;
+                rule: components["schemas"]["Dials.RoutingRule"];
+                auditId: string | null;
+                idempotentReplay: boolean;
+            }>;
+        };
+        people: {
+            list: (scope: import("./dials.js").DialsScope) => Promise<{
+                ok: boolean;
+                humans: components["schemas"]["Dials.HumanProfile"][];
+            }>;
+            create: (body: In<"dials_createHumanProfile">["body"]) => Promise<{
+                ok: boolean;
+                human: components["schemas"]["Dials.HumanProfile"];
+                auditId: string;
+                usageEventId: string;
+                next: string;
+            }>;
+        };
+        agents: {
+            list: (scope: import("./dials.js").DialsScope) => Promise<{
+                ok: boolean;
+                agents: components["schemas"]["Dials.AgentProfile"][];
+            }>;
+            create: (body: In<"dials_createAgent">["body"]) => Promise<{
+                ok: boolean;
+                agent: components["schemas"]["Dials.AgentProfile"];
+                auditId: string;
+                usageEventId: string;
+                next: string;
+            }>;
+        };
+        voice: {
+            list: (scope: import("./dials.js").DialsScope) => Promise<{
+                ok: boolean;
+                voiceProfiles: components["schemas"]["Dials.VoiceProfile"][];
+            }>;
+            create: (body: In<"dials_createVoiceProfile">["body"]) => Promise<{
+                ok: boolean;
+                voiceProfile: components["schemas"]["Dials.VoiceProfile"];
+                auditId: string;
+                usageEventId: string;
+                next: string;
+            }>;
+        };
+        messages: {
+            list: (scope: import("./dials.js").DialsScope) => Promise<{
+                ok: boolean;
+                messages: components["schemas"]["Dials.MessageEvent"][];
+            }>;
+            send: (body: In<"dials_createOutboundMessage">["body"]) => Promise<{
+                ok: boolean;
+                message: components["schemas"]["Dials.MessageEvent"];
+                auditId: string;
+                usageEventId: string;
+                next: string;
+                idempotentReplay: boolean;
+            }>;
+            templates: {
+                list: (scope: import("./dials.js").DialsScope) => Promise<{
+                    ok: boolean;
+                    templates: components["schemas"]["Dials.MessageTemplate"][];
+                }>;
+                create: (body: In<"dials_createMessageTemplate">["body"]) => Promise<{
+                    ok: boolean;
+                    template: components["schemas"]["Dials.MessageTemplate"];
+                    auditId: string;
+                    usageEventId: string;
+                    next: string;
+                }>;
+            };
+            brands: {
+                list: (scope: import("./dials.js").DialsScope) => Promise<{
+                    ok: boolean;
+                    brands: components["schemas"]["Dials.MessagingBrand"][];
+                }>;
+                create: (body: In<"dials_createMessagingBrand">["body"]) => Promise<{
+                    ok: boolean;
+                    brand: components["schemas"]["Dials.MessagingBrand"];
+                    auditId: string;
+                    next: string;
+                }>;
+            };
+            campaigns: {
+                list: (scope: import("./dials.js").DialsScope) => Promise<{
+                    ok: boolean;
+                    campaigns: components["schemas"]["Dials.MessagingCampaign"][];
+                }>;
+                create: (body: In<"dials_createMessagingCampaign">["body"]) => Promise<{
+                    ok: boolean;
+                    campaign: components["schemas"]["Dials.MessagingCampaign"];
+                    auditId: string;
+                    next: string;
+                }>;
+                assignNumber: (campaignId: string, body: In<"dials_assignCampaignNumber">["body"]) => Promise<{
+                    ok: boolean;
+                    campaignId: string;
+                    phoneNumberId: string;
+                    auditId: string;
+                    next: string;
+                }>;
+            };
+        };
+        workflows: {
+            list: (scope: import("./dials.js").DialsScope) => Promise<{
+                ok: boolean;
+                workflows: components["schemas"]["Dials.WorkflowDocument"][];
+            }>;
+            deploy: (body: In<"dials_deployWorkflow">["body"]) => Promise<{
+                ok: boolean;
+                workflow: components["schemas"]["Dials.WorkflowDocument"];
+                auditId: string;
+                usageEventId: string;
+                next: string;
+                route: components["schemas"]["Dials.RoutingRule"];
+            }>;
+        };
+        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;
+            }>;
+            delete: (input: In<"dials_deleteNumber">) => Promise<{
+                ok: boolean;
+                number: components["schemas"]["Dials.Number"];
+                auditId: string;
+                usageEventId: string;
+                next: string;
+            }>;
+            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.CallListItem"][];
+            }>;
+            validate: (body: import("./dials.js").DialsOutboundCall) => Promise<{
+                [key: string]: unknown;
+            }>;
+            create: (body: import("./dials.js").DialsOutboundCall) => Promise<{
+                ok: boolean;
+                call: components["schemas"]["Dials.CallSession"];
+                auditId: string;
+                dispatchJobId: string;
+                usageEventId: string;
+                next: string;
+                idempotentReplay: boolean;
+            } & {
+                [key: string]: unknown;
+            }>;
+            recover: (body: import("./dials.js").DialsOutboundCall) => Promise<{
+                ok: boolean;
+                call: components["schemas"]["Dials.CallSession"];
+                auditId: string;
+                dispatchJobId: string;
+                usageEventId: string;
+                next: string;
+                idempotentReplay: boolean;
+            } & {
+                [key: string]: unknown;
+            } & {
+                idempotentReplay: true;
+            }>;
+        };
+    };
+    readonly henry: {
+        config: () => Promise<{
+            credential_configured: boolean;
+            models: {
+                id: string;
+            }[];
+        }>;
+        credential: (api_key: string) => Promise<{
+            credential_configured: boolean;
+            models: {
+                id: string;
+            }[];
+        }>;
+        models: () => Promise<{
+            models: {
+                id: string;
+            }[];
+        }>;
+        receipts: {
+            verificationKey: () => Promise<{
+                keyId: string;
+                publicKeyBase64: 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: {
+        agents: {
+            list: () => Promise<{
+                agents: components["schemas"]["Fleets.Agent"][];
+            }>;
+            launch: (body: {
+                name: string;
+                memory?: components["schemas"]["Fleets.Memory"];
+                model?: string;
+                instructions?: string;
+                idempotency_key?: string;
+            }) => Promise<{
+                id: string;
+                name: string;
+                state: "launching" | "running" | "stopping" | "stopped" | "recovering" | "recovery_required";
+                memory: components["schemas"]["Fleets.Memory"];
+                model?: string | null;
+                inference: {
+                    provider: "foundry";
+                    mode: "managed";
+                };
+                created_at_ms: number;
+                updated_at_ms: number;
+                last_operation_id?: string | null;
+            }>;
+            get: (agent_id: string) => Promise<{
+                id: string;
+                name: string;
+                state: "launching" | "running" | "stopping" | "stopped" | "recovering" | "recovery_required";
+                memory: components["schemas"]["Fleets.Memory"];
+                model?: string | null;
+                inference: {
+                    provider: "foundry";
+                    mode: "managed";
+                };
+                created_at_ms: number;
+                updated_at_ms: number;
+                last_operation_id?: string | null;
+            }>;
+            command: (agent_id: string, body: {
+                input: string;
+                delivery?: "queue" | "steer" | "interrupt";
+            }) => Promise<{
+                agent: components["schemas"]["Fleets.Agent"];
+                operation_id: string;
+                result?: {
+                    [key: string]: unknown;
+                };
+            }>;
+            stop: (agent_id: string) => Promise<{
+                agent: components["schemas"]["Fleets.Agent"];
+                operation_id: string;
+                result?: {
+                    [key: string]: unknown;
+                };
+            }>;
+            recover: (agent_id: string) => Promise<{
+                agent: components["schemas"]["Fleets.Agent"];
+                operation_id: string;
+                result?: {
+                    [key: string]: unknown;
+                };
+            }>;
+        };
+        instances: {
+            list: (query?: In<"fleets_listInstances">) => Promise<{
+                instances: components["schemas"]["Fleets.Instance"][];
+                next_cursor: string | null;
+            }>;
+            get: (instance_id: string) => Promise<{
+                id: string;
+                name: string;
+                organization_id: string;
+                workspace_id: string;
+                project_id: string;
+                admission_held: boolean | null;
+                physical_state: "created" | "running" | "held" | "stopped" | "recovery_required" | "released";
+                status_evidence: "live_controller" | "confirmed_release_receipt";
+                release_acknowledged_at_ms: number | null;
+                harness_ready: boolean;
+                observed_at_ms: number | null;
+                lease_expires: {
+                    wall_ms: number;
+                    logical: number;
+                } | null;
+            }>;
+            stop: (instance_id: string, options?: import("./fleets.js").FleetsInstanceOptions) => Promise<{
+                id: string;
+                state: "released";
+                reaped: true;
+                data_retained: true;
+                status_evidence: "confirmed_release_receipt";
+                release_acknowledged_at_ms: number;
+            }>;
+            start: (instance_id: string, options?: import("./fleets.js").FleetsInstanceOptions) => Promise<{
+                id: string;
+                name: string;
+                organization_id: string;
+                workspace_id: string;
+                project_id: string;
+                admission_held: boolean | null;
+                physical_state: "created" | "running" | "held" | "stopped" | "recovery_required" | "released";
+                status_evidence: "live_controller" | "confirmed_release_receipt";
+                release_acknowledged_at_ms: number | null;
+                harness_ready: boolean;
+                observed_at_ms: number | null;
+                lease_expires: {
+                    wall_ms: number;
+                    logical: number;
+                } | null;
+            }>;
+        };
+        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;
+            }>;
+        };
+        usage: {
+            events: (query?: In<"fleets_listUsageEvents">) => Promise<{
+                events: components["schemas"]["Fleets.UsageEvent"][];
+                next_before: string | null;
+            }>;
+        };
+        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<{
+        permission: Readonly<{
+            grant: (input: import("./runner-grant.js").RunnerSelfExecutionGrantInput, opts?: import("./runner.js").RunnerRequestOptions) => Promise<{
+                id: string;
+                principal_id: string;
+                organization_id: string;
+                project_id: string;
+                platform_id: "pf_console";
+                workspace_id: string;
+                environmentId: "sandbox";
+                role_ids: unknown[];
+                permissions: "runner.tasks.execute"[];
+                expires_at: number;
+                created_at: number;
+            }>;
+        }>;
+        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: {
+        fleets: {
+            list: (options?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                data: components["schemas"]["Beacons.DashboardFleet"][];
+            }>;
+            update: (id: string, body: {
+                name: string;
+            }, options?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                data: components["schemas"]["Beacons.DashboardFleet"];
+            }>;
+            peers: (id: string, options?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                data: components["schemas"]["Beacons.DashboardPeer"][];
+            }>;
+            policy: {
+                get: (id: string, options?: {
+                    signal?: AbortSignal;
+                }) => Promise<{
+                    data: {
+                        fleet_id: string;
+                        config: components["schemas"]["Beacons.DashboardPolicyConfig"];
+                        source: "default" | "persisted";
+                        updated_at: string | null;
+                        scope: components["schemas"]["Beacons.DashboardScope"];
+                    };
+                }>;
+                update: (id: string, config: {
+                    device_enrollment: "allowed_with_permission" | "paused";
+                    max_devices?: number;
+                }, options?: {
+                    signal?: AbortSignal;
+                }) => Promise<{
+                    data: {
+                        fleet_id: string;
+                        config: components["schemas"]["Beacons.DashboardPolicyConfig"];
+                        source: "default" | "persisted";
+                        updated_at: string | null;
+                        scope: components["schemas"]["Beacons.DashboardScope"];
+                    };
+                }>;
+            };
+            provision: (requestId: string, body?: {
+                name?: string;
+            }) => Promise<{
+                data: {
+                    fleet_id: string;
+                    organization_id: string;
+                    workspace_id: string;
+                    project_id: string;
+                    environment_id: string;
+                    metadata_only: true;
+                };
+            }>;
+        };
+        devices: {
+            revocations: (id: string) => Promise<{
+                data: components["schemas"]["Beacons.DeviceRevocation"][];
+            }>;
+            acknowledge: (id: string, version: number, body: In<"beacons_acknowledgeBridgeDeviceRevocation">["body"]) => Promise<{
+                data: components["schemas"]["Beacons.DeviceRevocation"];
+            }>;
+            challenge: (body: In<"beacons_issueBridgeDeviceChallenge">["body"]) => Promise<{
+                version: 1;
+                id: string;
+                nonce: string;
+                issuer: string;
+                organization: string;
+                principal: string;
+                workspace: string;
+                project: string;
+                environment: string;
+                binding_revision: string;
+                transport: string;
+                fleet_id: string;
+                proof_key: string;
+                tunnel_key: string;
+                issued_at: number;
+                expires_at: number;
+            }>;
+            enroll: (body: In<"beacons_enrollBridgeDevice">["body"]) => Promise<{
+                device_id: string;
+                fleet_id: string;
+                mesh: {
+                    [key: string]: unknown;
+                };
+            }>;
+            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 flocks: {
+        readiness: {
+            get: () => Promise<{
+                node_enrollment_available: boolean;
+                reason_code?: "node_credential_issuer_unavailable";
+            }>;
+        };
+        nodes: {
+            list: () => Promise<{
+                id: string;
+                name: string;
+                nickname: string;
+                platform: string;
+                cpu_count: number;
+                state: "enrolled" | "revoked";
+                last_seen_at: number;
+                enrolled_at: number;
+            }[]>;
+            rename: (id: string, nickname: string) => Promise<{
+                id: string;
+                name: string;
+                nickname: string;
+                platform: string;
+                cpu_count: number;
+                state: "enrolled" | "revoked";
+                last_seen_at: number;
+                enrolled_at: number;
+            }>;
+            revoke: (id: string) => Promise<{
+                id: string;
+                name: string;
+                nickname: string;
+                platform: string;
+                cpu_count: number;
+                state: "enrolled" | "revoked";
+                last_seen_at: number;
+                enrolled_at: number;
+            }>;
+            heartbeat: (id: string, nodeBinding: string) => Promise<{
+                accepted: boolean;
+            }>;
+            enroll: (body: In<"flocks_enrollNode">["body"]) => Promise<{
+                node: components["schemas"]["Flocks.Node"];
+                node_binding: string;
+                heartbeat_interval_seconds: number;
+            }>;
+            activate: (id: string, body: In<"flocks_activateNode">["body"]) => Promise<{
+                node: components["schemas"]["Flocks.Node"];
+                activated: boolean;
+            }>;
+            rotateCredential: (id: string, body: In<"flocks_rotateNodeCredential">["body"]) => Promise<{
+                accepted: boolean;
+            }>;
+        };
+        harnesses: {
+            list: (query?: In<"flocks_listHarnesses">) => Promise<{
+                known_harnesses: string[];
+                items: components["schemas"]["Flocks.NodeHarnesses"][];
+                next_cursor: string | null;
+            }>;
+        };
+        agents: {
+            list: (query?: In<"flocks_listAgents">) => Promise<{
+                items: components["schemas"]["Flocks.Agent"][];
+                next_cursor: string | null;
+            }>;
+            create: (body: In<"flocks_createAgent">["body"]) => Promise<{
+                id: string;
+                name: string;
+                harness: string;
+                node_id: string | null;
+                owner_subject?: string;
+                created_at: number;
+                updated_at: number;
+            }>;
+            get: (agent_id: string) => Promise<{
+                id: string;
+                name: string;
+                harness: string;
+                node_id: string | null;
+                owner_subject?: string;
+                created_at: number;
+                updated_at: number;
+            }>;
+            execute: (agent_id: string, body: In<"flocks_executeAgent">["body"]) => Promise<{
+                schemaVersion: 1;
+                agentId: string;
+                canonicalAgentDid: string;
+                bindingRevision: string;
+                executionId: string;
+                revision: number;
+                outcome: "accepted" | "already_admitted";
+            }>;
+            status: (agent_id: string) => Promise<{
+                schemaVersion: 1;
+                agentId: string;
+                canonicalAgentDid: string;
+                bindingRevision: string;
+                executionId: string;
+                revision: number;
+                status: "working" | "success" | "error";
+                observedAtMs: number;
+                expiresAtMs: number;
+            }>;
+            cancel: (agent_id: string, idempotency_key: string) => Promise<{
+                schemaVersion: 1;
+                agentId: string;
+                canonicalAgentDid: string;
+                bindingRevision: string;
+                executionId: string;
+                revision: number;
+                outcome: "cancelled" | "already_terminal" | "cancel_requested";
+                observedAtMs: number;
+                expiresAtMs: number;
+            }>;
+        };
+        runs: {
+            list: (query?: In<"flocks_listRuns">) => Promise<{
+                items: components["schemas"]["Flocks.Run"][];
+                next_cursor: string | null;
+            }>;
+            get: (run_id: string) => Promise<{
+                id: string;
+                agent_id: string;
+                harness: string;
+                node_id: string | null;
+                task: string;
+                state: "pending" | "running" | "completed" | "failed";
+                error_code: string | null;
+                owner_subject?: string;
+                created_at: number;
+                updated_at: number;
+            }>;
+        };
+        joinTokens: {
+            exchange: (body: In<"flocks_exchangeJoinToken">["body"]) => Promise<{
+                node_id: string;
+                organization_id: string;
+                credential_id: string;
+                credential_value: string;
+                scopes: "flocks:node"[];
+                expires_at: string;
+                node_nonce_hash?: string;
+            }>;
+            create: (ttlSeconds?: number) => Promise<{
+                token: string;
+                expires_at: number;
+            }>;
+        };
+    };
+    readonly rigs: {
+        list: () => Promise<{
+            product: "rigs";
+            instances: components["schemas"]["Rigs.Instance"][];
+        }>;
+    };
+    readonly panes: {
+        list: () => Promise<{
+            product: "panes";
+            instances: components["schemas"]["Panes.Instance"][];
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    readonly shells: {
+        list: () => Promise<{
+            product: "shells";
+            instances: components["schemas"]["Shells.Instance"][];
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    readonly gears: {
+        workflows: {
+            list: () => Promise<{
+                scope?: components["schemas"]["Gears.Scope"];
+                workflowId: string;
+                workflowVersion: string;
+                name: string;
+                definitionRef: string;
+                registeredBy: string;
+            }[]>;
+            get: (id: string) => Promise<{
+                scope?: components["schemas"]["Gears.Scope"];
+                workflowId: string;
+                workflowVersion: string;
+                name: string;
+                definitionRef: string;
+                registeredBy: string;
+            }>;
+            register: (body: In<"gears_registerWorkflow">["body"], idempotencyKey?: string) => Promise<{
+                scope?: components["schemas"]["Gears.Scope"];
+                workflowId: string;
+                workflowVersion: string;
+                name: string;
+                definitionRef: string;
+                registeredBy: string;
+            }>;
+        };
+        runs: {
+            list: () => Promise<{
+                id: string;
+                scope?: components["schemas"]["Gears.Scope"];
+                workflowId: string;
+                workflowVersion: string;
+                status: "Running" | "Succeeded" | "Failed" | "Cancelled";
+                actorId: string;
+                inputRef: string;
+                contextFrameId?: string | null;
+                stationSessionId?: string | null;
+            }[]>;
+            get: (id: string) => Promise<{
+                id: string;
+                scope?: components["schemas"]["Gears.Scope"];
+                workflowId: string;
+                workflowVersion: string;
+                status: "Running" | "Succeeded" | "Failed" | "Cancelled";
+                actorId: string;
+                inputRef: string;
+                contextFrameId?: string | null;
+                stationSessionId?: string | null;
+            }>;
+            history: (id: string) => Promise<{
+                sequence: number;
+                runId: string;
+                kind: string;
+                actorId?: string;
+                detailRef?: string | null;
+            }[]>;
+            start: (body: In<"gears_startRun">["body"], idempotencyKey?: string) => Promise<{
+                id: string;
+                scope?: components["schemas"]["Gears.Scope"];
+                workflowId: string;
+                workflowVersion: string;
+                status: "Running" | "Succeeded" | "Failed" | "Cancelled";
+                actorId: string;
+                inputRef: string;
+                contextFrameId?: string | null;
+                stationSessionId?: string | null;
+            }>;
+            signal: (id: string, body: In<"gears_signalRun">["body"], idempotencyKey?: string) => Promise<Record<string, never>>;
+        };
+        records: () => Promise<{
+            meterRecords?: {
+                product?: string;
+                gardenMeter?: string;
+                quantity?: number;
+                scopeKey?: string;
+            }[];
+            auditRecords?: {
+                product?: string;
+                auditAction?: string;
+                actorId?: string;
+                targetRef?: string;
+            }[];
+            evidenceRecords?: {
+                product?: string;
+                evidenceRef?: string;
+                evidenceKind?: string;
+            }[];
+            replayEvidence?: {
+                product?: string;
+                replayEngine?: string;
+                runId?: string;
+                journalSequence?: number;
+                evidenceRef?: string;
+            }[];
+            probeEvents?: {
+                product?: string;
+                eventType?: string;
+                actorId?: string;
+                targetRef?: string;
+            }[];
+        }>;
+    };
+    readonly lanes: {
+        records: {
+            get: (recordId: string) => Promise<{
+                id?: string;
+                scope?: Record<string, never>;
+                subject?: string;
+                contentRef?: string;
+                summary?: string;
+                visibility?: components["schemas"]["Lanes.Visibility"];
+                labels?: string[];
+            }>;
+            write: (body: {
+                subject: string;
+                contentRef: string;
+                summary: string;
+                visibility: components["schemas"]["Lanes.Visibility"];
+                labels: string[];
+                proposedDataClass?: string;
+            }, idempotencyKey: string) => Promise<{
+                id?: string;
+                scope?: Record<string, never>;
+                subject?: string;
+                contentRef?: string;
+                summary?: string;
+                visibility?: components["schemas"]["Lanes.Visibility"];
+                labels?: string[];
+            }>;
+            snapshot: (body: {
+                exportedBy: string;
+            }, idempotencyKey: string) => Promise<{
+                scope?: Record<string, never>;
+                exportedBy?: string;
+                evidenceRef?: string;
+            } & {
+                [key: string]: unknown;
+            }>;
+            restore: (body: {
+                scope?: Record<string, never>;
+                exportedBy?: string;
+                evidenceRef?: string;
+            } & {
+                [key: string]: unknown;
+            }, idempotencyKey: string) => Promise<unknown>;
+        };
+        retrieve: (body: {
+            agentId: string;
+            taskId: string;
+            query: string;
+            allowRawContext: boolean;
+            tokenBudget: number;
+        } | {
+            subject: {
+                agentId: string;
+                runId?: string;
+                sessionId?: string;
+                userId?: string;
+            };
+            query: string;
+            allowRawContext?: boolean;
+            tokenBudget?: number;
+            maxResults?: number;
+        }, idempotencyKey: string) => Promise<{
+            frame?: components["schemas"]["Lanes.Frame"];
+            route?: components["schemas"]["Lanes.Route"];
+        }>;
+        frames: {
+            create: (body: {
+                agentId: string;
+                taskId: string;
+                query: string;
+                allowRawContext: boolean;
+                tokenBudget: number;
+            }, idempotencyKey: string) => Promise<{
+                frame?: components["schemas"]["Lanes.Frame"];
+                route?: components["schemas"]["Lanes.Route"];
+            }>;
+        };
+        answer: (body: {
+            agentId: string;
+            taskId: string;
+            query: string;
+            allowRawContext: boolean;
+            tokenBudget: number;
+        }, idempotencyKey: string) => Promise<{
+            frame?: components["schemas"]["Lanes.Frame"];
+            routeDecision?: Record<string, never>;
+            route?: components["schemas"]["Lanes.Route"];
+            cache?: Record<string, never>;
+            answer?: unknown;
+            policyDecisionIds?: string[];
+        }>;
+        ledger: {
+            frame: (frameId: string) => Promise<{
+                sequence?: number;
+                frameId?: string;
+                kind?: string;
+                detail?: unknown;
+            }[]>;
+            snapshot: (body: {
+                exportedBy: string;
+            }, idempotencyKey: string) => Promise<{
+                scope?: Record<string, never>;
+                exportedBy?: string;
+                evidenceRef?: string;
+            } & {
+                [key: string]: unknown;
+            }>;
+            restore: (body: {
+                scope?: Record<string, never>;
+                exportedBy?: string;
+                evidenceRef?: string;
+            } & {
+                [key: string]: unknown;
+            }, idempotencyKey: string) => Promise<unknown>;
+        };
+        cache: {
+            lookup: (body: {
+                cacheKey: string;
+                cacheClass: string;
+                requestedBy: string;
+            }, idempotencyKey: string) => Promise<{
+                cacheKey?: string;
+                cacheClass?: string;
+                status?: string;
+                hit?: components["schemas"]["Lanes.CacheArtifact"] | null;
+                policyDecisionIds?: string[];
+            }>;
+            write: (body: {
+                cacheKey: string;
+                cacheClass: string;
+                valueRef: string;
+                summary: string;
+                labels: string[];
+                sourceRecordIds: string[];
+                writtenBy: string;
+            }, idempotencyKey: string) => Promise<{
+                id?: string;
+                scope?: Record<string, never>;
+                cacheKey?: string;
+                cacheClass?: string;
+                valueRef?: string;
+                summary?: string;
+                labels?: string[];
+                sourceRecordIds?: string[];
+                status?: string;
+                evidenceRef?: string;
+                policyDecisionIds?: string[];
+            }>;
+            snapshot: (body: {
+                exportedBy: string;
+            }, idempotencyKey: string) => Promise<{
+                scope?: Record<string, never>;
+                exportedBy?: string;
+                evidenceRef?: string;
+            } & {
+                [key: string]: unknown;
+            }>;
+            restore: (body: {
+                scope?: Record<string, never>;
+                exportedBy?: string;
+                evidenceRef?: string;
+            } & {
+                [key: string]: unknown;
+            }, idempotencyKey: string) => Promise<unknown>;
+        };
+        recovery: {
+            restore: (body: {
+                [key: string]: unknown;
+            }, idempotencyKey: string) => Promise<{
+                scope?: Record<string, never>;
+                contextRecordsRestored?: number;
+                cacheArtifactsRestored?: number;
+                framesRestored?: number;
+                ledgerEntriesRestored?: number;
+                stageOrder?: string[];
+            } & {
+                [key: string]: unknown;
+            }>;
+        };
+        tenant: {
+            export: (body: {
+                requestedBy: string;
+                includeLedger: boolean;
+                includeOperationalRecords: boolean;
+            }, idempotencyKey: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            delete: (body: {
+                requestedBy: string;
+                reason: string;
+                legalHold: boolean;
+            }, idempotencyKey: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+        policy: {
+            evaluate: (body: {
+                actorId: string;
+                action: string;
+                dataClass: string;
+                allowRawContext: boolean;
+                modelClass: string;
+            }, idempotencyKey: string) => Promise<{
+                decisionId?: string;
+                allowed?: boolean;
+                decision?: "allow" | "deny";
+                reason?: string;
+                requiresRedaction?: boolean;
+                auditLevel?: string;
+                reasons?: string[];
+                denialReasons?: string[];
+                explanation?: Record<string, never>;
+            }>;
+        };
+        foundryRoutes: {
+            enforce: (body: {
+                routeAlias: string;
+                modelClass: string;
+                dataUseTerms: string[];
+                tokenBudget: number;
+                inputTokens: number;
+            }, idempotencyKey: string) => Promise<{
+                allowed?: boolean;
+                routeAlias?: string;
+                modelClass?: string;
+                inputTokens?: number;
+                maxInputTokens?: number;
+                reasons?: string[];
+            }>;
+        };
+        promotions: {
+            list: () => Promise<{
+                [key: string]: unknown;
+            }[]>;
+            propose: (body: {
+                sourceRecordId: string;
+                proposedBy: string;
+                sanitizedContentRef?: string;
+                sanitizedSummary?: string;
+                labels?: string[];
+            }, idempotencyKey: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            review: (promotionId: string, body: In<"lanes_reviewPromotion">["body"], idempotencyKey: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+        operations: {
+            records: () => Promise<{
+                meterRecords?: Record<string, never>[];
+                auditRecords?: Record<string, never>[];
+                evidenceRecords?: Record<string, never>[];
+                probeEvents?: Record<string, never>[];
+            }>;
+            get: (operationId: string) => Promise<{
+                operationId?: string;
+                state?: string;
+                responseStatus?: number;
+            } & {
+                [key: string]: unknown;
+            }>;
+        };
+    };
+    readonly flares: {
+        list: (q?: In<"flares_listFlares">) => Promise<({
+            id?: string;
+            status?: string;
+            flareType?: string;
+            recipientId?: string;
+            recipientType?: string;
+            priority?: string;
+            channels?: string[];
+            createdAt?: string;
+            updatedAt?: string;
+            deliveryReceipts?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        })[]>;
+        get: (id: string) => Promise<{
+            id?: string;
+            status?: string;
+            flareType?: string;
+            recipientId?: string;
+            recipientType?: string;
+            priority?: string;
+            channels?: string[];
+            createdAt?: string;
+            updatedAt?: string;
+            deliveryReceipts?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        }>;
+        send: (body: In<"flares_sendFlare">["body"], key: string) => Promise<{
+            id?: string;
+            status?: string;
+        }>;
+        sendBatch: (body: In<"flares_sendFlareBatch">["body"], key: string) => Promise<{
+            results?: components["schemas"]["Flares.SendFlareResponse"][];
+        }>;
+        acknowledge: (id: string, body: In<"flares_acknowledgeFlare">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        act: (id: string, body: In<"flares_actOnFlare">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        conversations: {
+            list: () => Promise<{
+                [key: string]: unknown;
+            }[]>;
+            get: (id: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            create: (body: In<"flares_createConversation">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            send: (id: string, body: In<"flares_sendConversationMessage">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            close: (id: string, key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+        commitments: {
+            list: () => Promise<{
+                [key: string]: unknown;
+            }[]>;
+            get: (id: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            create: (body: In<"flares_createCommitment">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            accept: (id: string, key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            start: (id: string, key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            progress: (id: string, body: In<"flares_reportCommitmentProgress">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            fulfill: (id: string, body: In<"flares_fulfillCommitment">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            fail: (id: string, body: In<"flares_failCommitment">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+        presence: {
+            heartbeat: (body: In<"flares_presenceHeartbeat">["body"], key: string) => Promise<{
+                did?: string;
+                status?: string;
+                sessionId?: string;
+                sessionCount?: number;
+                lastSeenAt?: string;
+            } & {
+                [key: string]: unknown;
+            }>;
+            get: (did: string) => Promise<{
+                did?: string;
+                status?: string;
+                sessionId?: string;
+                sessionCount?: number;
+                lastSeenAt?: string;
+            } & {
+                [key: string]: unknown;
+            }>;
+        };
+        trust: {
+            score: (did: string) => Promise<{
+                did?: string;
+                score?: number;
+                confidence?: number;
+                dataPoints?: number;
+                computedAt?: string;
+                expiresAt?: string;
+                trustLevel?: string;
+                endorsementCount?: number;
+            } & {
+                [key: string]: unknown;
+            }>;
+            check: (body: In<"flares_checkTrust">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            endorsements: (did: string) => Promise<{
+                [key: string]: unknown;
+            }[]>;
+            endorse: (body: In<"flares_createEndorsement">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            revoke: (id: string, key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+        choreography: {
+            workflows: {
+                list: () => Promise<{
+                    [key: string]: unknown;
+                }[]>;
+                create: (body: In<"flares_createChoreographyWorkflow">["body"], key: string) => Promise<{
+                    [key: string]: unknown;
+                }>;
+                start: (workflow_id: string, key: string) => Promise<{
+                    [key: string]: unknown;
+                }>;
+            };
+            executions: {
+                list: () => Promise<{
+                    [key: string]: unknown;
+                }[]>;
+                get: (execution_id: string) => Promise<{
+                    [key: string]: unknown;
+                }>;
+                completeStep: (execution_id: string, step_id: string, body: In<"flares_completeChoreographyStep">["body"], key: string) => Promise<{
+                    [key: string]: unknown;
+                }>;
+                failStep: (execution_id: string, step_id: string, body: In<"flares_failChoreographyStep">["body"], key: string) => Promise<{
+                    [key: string]: unknown;
+                }>;
+                cancel: (execution_id: string, key: string) => Promise<{
+                    [key: string]: unknown;
+                }>;
+            };
+        };
+    };
+    readonly foundry: {
+        billing: {
+            profile: (options?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                schemaVersion: 1;
+                status: "ready" | "pending" | "attention_required";
+                organizationId: string;
+                billingAccountId: string;
+                environmentId: "sandbox";
+                stripeAccountId: string;
+                stripeCustomerId: string | null;
+                livemode: false;
+                canEnsure: boolean;
+            } | {
+                foundry_account_id: string;
+                available_microdollars: number;
+                granted_microdollars: number;
+                reserved_microdollars: number;
+                reserved_overage_microdollars: number;
+                settlement_owner: "foundry";
+                launch_listed: boolean;
+            }>;
+            ensureProfile: (operationKey: string, options?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                schemaVersion: 1;
+                status: "ready" | "pending" | "attention_required";
+                organizationId: string;
+                billingAccountId: string;
+                environmentId: "sandbox";
+                stripeAccountId: string;
+                stripeCustomerId: string | null;
+                livemode: false;
+                canEnsure: boolean;
+            } | {
+                intent_id: string;
+                stripe_checkout_session_id: string;
+                checkout_url?: string;
+                status?: "paid" | "processing";
+                stripe_payment_intent_id?: string;
+            }>;
+            checkoutCredits: (purchaseKey: string, options?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                schemaVersion: 1;
+                status: "ready" | "pending" | "attention_required";
+                organizationId: string;
+                billingAccountId: string;
+                environmentId: "sandbox";
+                stripeAccountId: string;
+                stripeCustomerId: string | null;
+                livemode: false;
+                canEnsure: boolean;
+            } | {
+                intent_id: string;
+                stripe_checkout_session_id: string;
+                checkout_url?: string;
+                status?: "paid" | "processing";
+                stripe_payment_intent_id?: string;
+            }>;
+            creditBalance: (options?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                schemaVersion: 1;
+                status: "ready" | "pending" | "attention_required";
+                organizationId: string;
+                billingAccountId: string;
+                environmentId: "sandbox";
+                stripeAccountId: string;
+                stripeCustomerId: string | null;
+                livemode: false;
+                canEnsure: boolean;
+            } | {
+                foundry_account_id: string;
+                available_microdollars: number;
+                granted_microdollars: number;
+                reserved_microdollars: number;
+                reserved_overage_microdollars: number;
+                settlement_owner: "foundry";
+                launch_listed: boolean;
+            }>;
+        };
+        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: {
+        volumes: {
+            list(project: string, query?: {
+                page?: number;
+                per_page?: number;
+            }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-volumes.js").HivesVolumePage>;
+            get(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-volumes.js").HivesVolume>;
+            create(project: string, input: import("./hives-volumes.js").HivesVolumeCreate, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-volumes.js").HivesVolume>;
+            mount(project: string, id: string, input: import("./hives-volumes.js").HivesVolumeMount, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-volumes.js").HivesVolume>;
+            unmount(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-volumes.js").HivesVolume>;
+            remove(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                success: true;
+                id: string;
+                message: string;
+            }>;
+        };
+        marketplace: {
+            list(project: string, query?: import("./hives-marketplace.js").HivesMarketplaceSearch, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-marketplace.js").HivesMarketplacePage<import("./hives-marketplace.js").HivesMarketplacePackage>>;
+            get(project: string, packageSlug: string, query?: {
+                version?: string | null;
+            }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-marketplace.js").HivesMarketplaceDetail>;
+            versions(project: string, packageSlug: string, query?: {
+                page?: number;
+                page_size?: number;
+            }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-marketplace.js").HivesMarketplacePage<import("./hives-marketplace.js").HivesMarketplaceVersion>>;
+            featured(project: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-marketplace.js").HivesMarketplacePage<import("./hives-marketplace.js").HivesMarketplacePackage>>;
+            categories(project: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-marketplace.js").HivesMarketplaceCategory[]>;
+            publish(project: string, input: import("./hives-marketplace.js").HivesMarketplacePublish, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-marketplace.js").HivesMarketplaceDetail>;
+            install(project: string, packageSlug: string, input?: import("./hives-marketplace.js").HivesMarketplaceInstall, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-marketplace.js").HivesMarketplaceInstallation>;
+            update(project: string, packageSlug: string, input?: import("./hives-marketplace.js").HivesMarketplaceInstall, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-marketplace.js").HivesMarketplaceInstallation>;
+            installed(project: string, query?: {
+                page?: number;
+                page_size?: number;
+            }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-marketplace.js").HivesMarketplacePage<import("./hives-marketplace.js").HivesMarketplaceInstallation>>;
+            getInstallation(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-marketplace.js").HivesMarketplaceInstallation>;
+            reconcile(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-marketplace.js").HivesMarketplaceInstallation>;
+            uninstall(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-marketplace.js").HivesMarketplaceInstallation>;
+        };
+        /** The gateway resolves the current authorized selection from an interactive One account session. */
+        context: {
+            get: () => Promise<{
+                binding: components["schemas"]["Hives.ProjectBindingMetadata"];
+                project: components["schemas"]["Hives.ContextProjectMetadata"];
+                selectedContext: components["schemas"]["Hives.SelectedContext"];
+            }>;
+            set: (body: In<"hives_set_context_project">["body"]) => Promise<{
+                binding: components["schemas"]["Hives.ProjectBindingMetadata"];
+                project: components["schemas"]["Hives.ContextProjectMetadata"];
+                selectedContext: components["schemas"]["Hives.SelectedContext"];
+            }>;
+            /** Detach this selection; the service project and customer resources are retained. */
+            detach: () => Promise<{
+                hivesProjectId: string;
+                removed: boolean;
+            }>;
+        };
+        environment: {
+            list: (project_id: string, q?: Omit<In<"hives_list_project_environment">, "project_id">) => Promise<{
+                data: components["schemas"]["Hives.EnvironmentVariableMetadata"][];
+                pagination: components["schemas"]["Hives.PaginationMeta"];
+                project_id: string;
+            }>;
+            upsert: (project_id: string, body: In<"hives_update_project_environment">["body"]) => Promise<{
+                project_id: string;
+                updated: components["schemas"]["Hives.EnvironmentVariableMetadata"][];
+            }>;
+            /** Explicit KMS reveal with a persisted names-only audit. Do not log the plaintext. */
+            reveal: (project_id: string, key: string) => Promise<{
+                name: string;
+                value: string;
+            }>;
+        };
+        projects: {
+            list: (q?: In<"hives_list_projects">) => Promise<{
+                data: (Record<string, never> & {
+                    active_instances?: number | null;
+                    current_version?: number | null;
+                    observation?: null | components["schemas"]["Hives.ProjectInvocationObservation"];
+                    requests_24h?: number | null;
+                    summary_state: components["schemas"]["Hives.ProjectSummaryState"];
+                    total_deployments?: number | null;
+                })[];
+                pagination: components["schemas"]["Hives.PaginationMeta"];
+            }>;
+            get: (project_id: string) => Promise<Record<string, never> & {
+                active_instances?: number | null;
+                current_version?: number | null;
+                observation?: null | components["schemas"]["Hives.ProjectInvocationObservation"];
+                requests_24h?: number | null;
+                summary_state: components["schemas"]["Hives.ProjectSummaryState"];
+                total_deployments?: number | null;
+            }>;
+            create: (body: In<"hives_create_project">["body"]) => Promise<Record<string, never> & {
+                active_instances?: number | null;
+                current_version?: number | null;
+                observation?: null | components["schemas"]["Hives.ProjectInvocationObservation"];
+                requests_24h?: number | null;
+                summary_state: components["schemas"]["Hives.ProjectSummaryState"];
+                total_deployments?: number | null;
+            }>;
+            update: (project_id: string, body: In<"hives_update_project">["body"]) => Promise<Record<string, never> & {
+                active_instances?: number | null;
+                current_version?: number | null;
+                observation?: null | components["schemas"]["Hives.ProjectInvocationObservation"];
+                requests_24h?: number | null;
+                summary_state: components["schemas"]["Hives.ProjectSummaryState"];
+                total_deployments?: number | null;
+            }>;
+            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;
+            }>;
+            stop: (project_id: string, deployment_id: string, init?: {
+                signal?: AbortSignal;
+            }) => 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?: HivesInvokeOptions) => Promise<Response>;
+            operations: {
+                get: (project_id: string, function_id: string, operation_id: string, init?: {
+                    signal?: AbortSignal;
+                }) => Promise<import("./hives-functions.js").HivesOperationStatus>;
+                release: (project_id: string, function_id: string, operation_id: string, init?: {
+                    signal?: AbortSignal;
+                }) => Promise<import("./hives-functions.js").HivesOperationStatus>;
+            };
+        };
+        regions: {
+            list: () => Promise<{
+                regions: components["schemas"]["Hives.Region"][];
+            }>;
+        };
+        cells: {
+            list(project: string, query?: {
+                page?: number;
+                per_page?: number;
+            }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-cells.js").HivesBucketList>;
+            get(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-cells.js").HivesBucket>;
+            create(project: string, body: import("./hives-cells.js").HivesCreateBucket, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-cells.js").HivesBucket>;
+            remove(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                id: string;
+                success: boolean;
+                message: string;
+            }>;
+            reconcile(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                bucket: import("./hives-cells.js").HivesBucket;
+                outcome: string;
+            }>;
+            cors: {
+                get: (project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<import("./hives-cells.js").HivesCorsRule[]>;
+                set: (project: string, id: string, rules: import("./hives-cells.js").HivesCorsRule[], options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<import("./hives-cells.js").HivesCorsRule[]>;
+            };
+            objects: {
+                list(project: string, id: string, query?: {
+                    prefix?: string;
+                    delimiter?: string;
+                    continuation_token?: string;
+                    max_keys?: number;
+                }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-cells.js").HivesObjectList>;
+                put(project: string, id: string, key: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: import("./hives-resources-transport.js").HivesResourceOptions & {
+                    content_type?: string;
+                }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement>;
+                remove: (project: string, id: string, key: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<void>;
+                download: (project: string, id: string, key: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<Response>;
+                putFlat(project: string, id: string, key: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: import("./hives-resources-transport.js").HivesResourceOptions & {
+                    content_type?: string;
+                }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement>;
+                removeFlat: (project: string, id: string, key: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<void>;
+            };
+            presign(project: string, id: string, body: import("./hives-cells.js").HivesPresign, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-cells.js").HivesPresignedUrl>;
+        };
+        queues: {
+            consumer: {
+                get(project: string, queue: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queue-consumer.js").HivesQueueConsumerStatus>;
+                configure(project: string, queue: string, input: import("./hives-queue-consumer.js").HivesQueueConsumerConfig, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queue-consumer.js").HivesQueueConsumerBinding>;
+                remove(project: string, queue: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                    success: true;
+                    queueId: string;
+                }>;
+            };
+            list(project: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                data: import("./hives-queues.js").HivesQueue[];
+                engine_available: true;
+            }>;
+            get(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queues.js").HivesQueue>;
+            create(project: string, body: import("./hives-queues.js").HivesQueueCreate, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queues.js").HivesQueue>;
+            configure(project: string, id: string, body: import("./hives-queues.js").HivesQueueConfig, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queues.js").HivesQueue>;
+            remove(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                deleted: true;
+            }>;
+            stats(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queues.js").HivesQueue>;
+            consumers: (project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<never>;
+            pause(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queues.js").HivesQueue>;
+            resume(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queues.js").HivesQueue>;
+            purge(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                purged: number;
+            }>;
+            send(project: string, id: string, body: import("./hives-queues.js").HivesQueueSend, options?: import("./hives-queue-funding.js").HivesQueueSendOptions): Promise<import("./hives-queue-funding.js").HivesQueueOperation | {
+                message_id: string;
+            }>;
+            operations: {
+                get(project: string, id: string, operationId: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-queue-funding.js").HivesQueueOperation>;
+            };
+            receive(project: string, id: string, body?: {
+                maxMessages?: number;
+                waitSeconds?: number;
+            }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                messages: import("./hives-queues.js").HivesQueueDelivery[];
+            }>;
+            ack: (project: string, id: string, message: string, receipt: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<{
+                acknowledged: boolean;
+                released: boolean;
+            }>;
+            nack: (project: string, id: string, message: string, receipt: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<{
+                acknowledged: boolean;
+                released: boolean;
+            }>;
+            deadLetters: (project: string, id: string, query?: {
+                limit?: number;
+                offset?: number;
+            }, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<{
+                messages: import("./hives-queues.js").HivesDeadLetter[];
+            }>;
+            deadLetterStats: (project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<import("./hives-queues.js").HivesDeadLetterStats>;
+            replay(project: string, id: string, message: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                message_id: string;
+                replayed: 1;
+            }>;
+            deleteDeadLetter(project: string, id: string, message: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                deleted: true;
+            }>;
+            purgeDeadLetters(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                purged: number;
+            }>;
+        };
+        topics: {
+            list(project: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                data: import("./hives-topics.js").HivesTopic[];
+            }>;
+            get(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-topics.js").HivesTopic>;
+            create(project: string, body: {
+                name: string;
+            }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-topics.js").HivesTopic>;
+            remove(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                deleted: true;
+            }>;
+            subscriptions: {
+                list(project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                    data: import("./hives-topics.js").HivesTopicSubscription[];
+                }>;
+                add(project: string, id: string, queueId: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-topics.js").HivesTopicSubscription>;
+                remove(project: string, id: string, subscriptionId: string, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<{
+                    deleted: true;
+                }>;
+            };
+            publish(project: string, id: string, body: import("./hives-topics.js").HivesTopicPublish, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-topics.js").HivesTopicPublication>;
+        };
+        runtimes: {
+            list: (options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<{
+                runtimes: import("./hives-runtimes.js").HivesRuntime[];
+            }>;
+            project: (project_id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<{
+                runtimes: import("./hives-runtimes.js").HivesRuntime[];
+            }>;
+            get: (name: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<import("./hives-runtimes.js").HivesRuntime>;
+            select: (input: {
+                wasi: string;
+                runner: string;
+                artifact: string;
+            }, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<import("./hives-runtimes.js").HivesRuntimeSelection>;
+        };
+        settings: {
+            get: (project_id: string) => Promise<{
+                autoDeployEnabled: boolean;
+                buildCommand?: string | null;
+                defaultRegion: string;
+                installCommand?: string | null;
+                outputDirectory?: string | null;
+                previewDeploymentsEnabled: boolean;
+            } & {
+                capabilities: components["schemas"]["Hives.ProjectSettingsCapabilities"];
+                effective: components["schemas"]["Hives.EffectiveProjectSettings"];
+            }>;
+            update: (project_id: string, body: In<"hives_update_project_settings">["body"]) => Promise<{
+                autoDeployEnabled: boolean;
+                buildCommand?: string | null;
+                defaultRegion: string;
+                installCommand?: string | null;
+                outputDirectory?: string | null;
+                previewDeploymentsEnabled: boolean;
+            } & {
+                capabilities: components["schemas"]["Hives.ProjectSettingsCapabilities"];
+                effective: components["schemas"]["Hives.EffectiveProjectSettings"];
+            }>;
+        };
+        crons: {
+            list: (project_id: string, q?: Omit<In<"hives_list_crons">, "project_id">) => Promise<Record<string, never>>;
+            get: (project_id: string, cron_id: string) => Promise<Record<string, never>>;
+            create: (project_id: string, body: In<"hives_create_cron">["body"]) => Promise<Record<string, never>>;
+            update: (project_id: string, cron_id: string, body: In<"hives_update_cron">["body"]) => Promise<Record<string, never>>;
+            delete: (project_id: string, cron_id: string) => Promise<{
+                id: string;
+                message: string;
+                success: boolean;
+            }>;
+            pause: (project_id: string, cron_id: string) => Promise<Record<string, never>>;
+            resume: (project_id: string, cron_id: string) => Promise<Record<string, never>>;
+            trigger: (project_id: string, cron_id: string) => Promise<unknown>;
+            runs: (project_id: string, cron_id: string, q?: Omit<In<"hives_get_cron_runs">, "project_id" | "cron_id">) => Promise<{
+                data: {
+                    duration_ms?: number | null;
+                    ended_at?: string | null;
+                    error?: string | null;
+                    id: string;
+                    logs_url?: string | null;
+                    started_at: string;
+                    status: string;
+                }[];
+                pagination: components["schemas"]["Hives.PaginationMeta"];
+            }>;
+        };
+        metrics: {
+            project: (project_id: string, q?: Omit<In<"hives_get_project_metrics">, "project_id">) => Promise<{
+                active_deployments: number;
+                avg_api_http_duration_ms?: number | null;
+                avg_response_time_ms?: number | null;
+                cron_executions?: number | null;
+                data_transfer_bytes: number;
+                error_count: number;
+                error_rate?: number | null;
+                function_invocations: number;
+                observation: components["schemas"]["Hives.ObservationScope"];
+                observed_request_payload_bytes: number;
+                observed_response_payload_bytes: number;
+                p95_response_time_ms?: number | null;
+                p99_response_time_ms?: number | null;
+                project_id: string;
+                storage_bytes?: number | null;
+                time_range: components["schemas"]["Hives.TimeRange"];
+                total_requests: number;
+                unique_visitors?: number | null;
+            }>;
+            dashboard: (project_id: string, q?: Omit<In<"hives_get_dashboard_metrics">, "project_id">) => Promise<{
+                activeDeployments: number;
+                avgApiHttpDurationMs?: number | null;
+                avgLatencyMs?: number | null;
+                deploymentsChange?: number | null;
+                errorRate?: number | null;
+                errorRateChange?: number | null;
+                errorTimeSeries: components["schemas"]["Hives.MetricDataPoint"][];
+                latencyChange?: number | null;
+                latencyTimeSeries: components["schemas"]["Hives.MetricDataPoint"][];
+                observation: components["schemas"]["Hives.ObservationScope"];
+                observedRequestPayloadBytes: number;
+                observedResponsePayloadBytes: number;
+                requestsChange?: number | null;
+                requestsTimeSeries: components["schemas"]["Hives.MetricDataPoint"][];
+                totalRequests: number;
+            }>;
+            requests: (project_id: string, q?: Omit<In<"hives_get_request_metrics">, "project_id">) => Promise<{
+                aggregation: components["schemas"]["Hives.MetricAggregation"];
+                data: components["schemas"]["Hives.MetricDataPoint"][];
+                name: string;
+                observation: components["schemas"]["Hives.ObservationScope"];
+                resolution_seconds: number;
+                time_range: components["schemas"]["Hives.TimeRange"];
+            }>;
+            latency: (project_id: string, q?: Omit<In<"hives_get_latency_metrics">, "project_id">) => Promise<{
+                aggregation: components["schemas"]["Hives.MetricAggregation"];
+                data: components["schemas"]["Hives.MetricDataPoint"][];
+                name: string;
+                observation: components["schemas"]["Hives.ObservationScope"];
+                resolution_seconds: number;
+                time_range: components["schemas"]["Hives.TimeRange"];
+            }>;
+            errors: (project_id: string, q?: Omit<In<"hives_get_error_metrics">, "project_id">) => Promise<{
+                aggregation: components["schemas"]["Hives.MetricAggregation"];
+                data: components["schemas"]["Hives.MetricDataPoint"][];
+                name: string;
+                observation: components["schemas"]["Hives.ObservationScope"];
+                resolution_seconds: number;
+                time_range: components["schemas"]["Hives.TimeRange"];
+            }>;
+            function: (project_id: string, function_id: string, q?: Omit<In<"hives_get_function_metrics">, "project_id" | "function_id">) => Promise<{
+                avg_api_http_duration_ms?: number | null;
+                avg_duration_ms?: number | null;
+                billed_gb_seconds?: number | null;
+                cold_starts?: number | null;
+                configured_memory_limit_mb: number;
+                failed_invocations: number;
+                function_id: string;
+                function_name: string;
+                memory_mb?: number | null;
+                observation: components["schemas"]["Hives.ObservationScope"];
+                observed_request_payload_bytes: number;
+                observed_response_payload_bytes: number;
+                p50_duration_ms?: number | null;
+                p95_duration_ms?: number | null;
+                p99_duration_ms?: number | null;
+                success_rate?: number | null;
+                successful_invocations: number;
+                time_range: components["schemas"]["Hives.TimeRange"];
+                timeouts?: number | null;
+                total_invocations: number;
+            }>;
+            invocations: (project_id: string, function_id: string, q?: Omit<In<"hives_get_function_invocations_series">, "project_id" | "function_id">) => Promise<{
+                aggregation: components["schemas"]["Hives.MetricAggregation"];
+                data: components["schemas"]["Hives.MetricDataPoint"][];
+                name: string;
+                observation: components["schemas"]["Hives.ObservationScope"];
+                resolution_seconds: number;
+                time_range: components["schemas"]["Hives.TimeRange"];
+            }>;
+            deployment: (project_id: string, deployment_id: string, q?: Omit<In<"hives_get_deployment_metrics">, "project_id" | "deployment_id">) => Promise<{
+                active_instances?: number | null;
+                avg_api_http_duration_ms?: number | null;
+                avg_cpu_percent?: number | null;
+                avg_memory_mb?: number | null;
+                avg_response_time_ms?: number | null;
+                deployment_id: string;
+                error_count: number;
+                error_rate?: number | null;
+                max_instances?: number | null;
+                min_instances?: number | null;
+                network_in_bytes?: number | null;
+                network_out_bytes?: number | null;
+                observation: components["schemas"]["Hives.ObservationScope"];
+                observed_request_payload_bytes: number;
+                observed_response_payload_bytes: number;
+                p95_response_time_ms?: number | null;
+                time_range: components["schemas"]["Hives.TimeRange"];
+                total_requests: number;
+            }>;
+            resources: (project_id: string, q?: Omit<In<"hives_get_resource_usage">, "project_id">) => Promise<{
+                active_deployments: number;
+                avg_api_http_duration_ms?: number | null;
+                bandwidth_gb?: number | null;
+                build_minutes?: number | null;
+                compute_gb_seconds?: number | null;
+                custom_domains: number;
+                function_invocations: number;
+                observation: components["schemas"]["Hives.ObservationScope"];
+                observed_request_payload_bytes: number;
+                observed_response_payload_bytes: number;
+                scheduled_jobs: number;
+                ssl_certificates: number;
+                storage_gb?: number | null;
+                time_range: components["schemas"]["Hives.TimeRange"];
+            }>;
+            realtime: (project_id: string) => Promise<{
+                active_connections?: number | null;
+                avg_api_http_duration_ms?: number | null;
+                avg_response_time_ms?: number | null;
+                cpu_percent?: number | null;
+                error_rate?: number | null;
+                memory_percent?: number | null;
+                observation: components["schemas"]["Hives.ObservationScope"];
+                observed_request_payload_bytes: number;
+                observed_response_payload_bytes: number;
+                requests_per_second: number;
+                updated_at: string;
+            }>;
+        };
+    };
+    readonly silos: {
+        /** Internal resource UUIDs; organization and parent ownership are enforced by Silos. */
+        databases: {
+            list: (project_id: string) => Promise<{
+                project: components["schemas"]["Silos.Project"];
+                databases: components["schemas"]["Silos.DatabaseResource"][];
+            }>;
+            get: (project_id: string, database_id: string) => Promise<{
+                project: components["schemas"]["Silos.Project"];
+                database: components["schemas"]["Silos.DatabaseResource"];
+            }>;
+        };
+        projects: {
+            list: () => Promise<{
+                projects: components["schemas"]["Silos.Project"][];
+            }>;
+            create: (body: In<"silos_createProject">["body"]) => Promise<{
+                project: components["schemas"]["Silos.Project"];
+            }>;
+            get: (project_id: string) => Promise<{
+                project: components["schemas"]["Silos.Project"];
+                databases: components["schemas"]["Silos.Database"][];
+            }>;
+        };
+    };
+    readonly traces: {
+        runs: {
+            create: (body: In<"traces_createRun">["body"], idempotencyKey: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            list: (q?: {
+                limit?: number;
+            }) => Promise<{
+                [key: string]: unknown;
+            }>;
+            get: (id: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            evidence: (id: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+        search: (body: In<"traces_search">["body"], idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        usage: {
+            events: () => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+    };
+    readonly relays: {
+        enrollment: {
+            get: (options?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                state: "ready" | "not_enrolled";
+                organizationId: string;
+                projectId: string;
+                workspaceId: string;
+                resourceEnvironment: "sandbox";
+            }>;
+            activate: (options?: {
+                signal?: AbortSignal;
+            }) => Promise<{
+                state: "ready";
+                organizationId: string;
+                projectId: string;
+                workspaceId: string;
+                resourceEnvironment: "sandbox";
+                created: boolean;
+            }>;
+        };
+        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;
+            }>;
+            dnssec: (zone: string) => Promise<{
+                zone: string;
+                enabled: boolean;
+                keys: {
+                    [key: string]: unknown;
+                }[];
+                ds_records: {
+                    [key: string]: unknown;
+                }[];
+                settings: {
+                    nsec3: {
+                        algorithm?: number;
+                        flags?: number;
+                        iterations?: number;
+                        salt?: string;
+                    } | null;
+                    auto_publish_cds: boolean;
+                    auto_publish_cdnskey: boolean;
+                };
+            }>;
+            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;
+            }>;
+        };
+    };
+    /** One account 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? (One account verify: org, principal, scopes, kind) */
+    whoami(): Promise<S['Iam.VerifiedPrincipal']>;
+    private streamChat;
+}
+export {};