@lifesi/genesis 0.1.1 → 0.1.3

package/dist/genesis.d.ts

@@ -21,6 +21,136 @@ export declare class Genesis extends GenesisClient {
         headers?: Record<string, string>;
     }) => Promise<import("./types.js").OperationOutput<K>>;
     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;
@@ -113,6 +243,13 @@ export declare class Genesis extends GenesisClient {
             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;
             }>;
@@ -127,14 +264,35 @@ export declare class Genesis extends GenesisClient {
         calls: {
             list: (scope: import("./dials.js").DialsScope) => Promise<{
                 ok: boolean;
-                calls: components["schemas"]["Dials.Call"][];
+                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: {
@@ -150,6 +308,12 @@ export declare class Genesis extends GenesisClient {
                 id: string;
             }[];
         }>;
+        receipts: {
+            verificationKey: () => Promise<{
+                keyId: string;
+                publicKeyBase64: string;
+            }>;
+        };
         runs: {
             list: (page_token?: string) => Promise<{
                 runs: components["schemas"]["Henry.Run"][];
@@ -290,6 +454,117 @@ export declare class Genesis extends GenesisClient {
         };
     };
     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;
@@ -360,6 +635,21 @@ export declare class Genesis extends GenesisClient {
         };
     };
     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"];
@@ -399,7 +689,52 @@ export declare class Genesis extends GenesisClient {
         }>;
     }>;
     readonly beacons: {
+        fleets: {
+            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"][];
             }>;
@@ -414,6 +749,76 @@ export declare class Genesis extends GenesisClient {
             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;
+            }>;
+        };
+        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 foundry: {
         models: {
             list: () => Promise<{
@@ -460,33 +865,112 @@ export declare class Genesis extends GenesisClient {
         };
     };
     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 LifeID 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;
+                    active_instances?: number | null;
                     current_version?: number | null;
-                    requests_24h: number;
-                    total_deployments: number;
+                    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;
+                active_instances?: number | null;
                 current_version?: number | null;
-                requests_24h: number;
-                total_deployments: number;
+                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;
+                active_instances?: number | null;
                 current_version?: number | null;
-                requests_24h: number;
-                total_deployments: number;
+                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;
+                active_instances?: number | null;
                 current_version?: number | null;
-                requests_24h: number;
-                total_deployments: number;
+                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"][];
@@ -733,6 +1217,304 @@ export declare class Genesis extends GenesisClient {
                 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: {
+            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-resources-transport.js").HivesResourceOptions): Promise<{
+                message_id: string;
+            }>;
+            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;
+            }>;
+        };
+        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 relays: {
         zones: {