@onesi/genesis 0.0.1-stage → 0.2.0

package/dist/hives-operations.d.ts

@@ -0,0 +1,451 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** The original Hives scheduler, settings and measured activity use the same gateway and identity. */
+export declare function hivesOperations(client: GenesisClient): {
+    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: import("./index.js").components["schemas"]["Hives.ProjectSettingsCapabilities"];
+            effective: import("./index.js").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: import("./index.js").components["schemas"]["Hives.ProjectSettingsCapabilities"];
+            effective: import("./index.js").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>>;
+        /** Admission returns a persisted run ID; read history to learn its actual outcome. No retry. */
+        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: import("./index.js").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: import("./index.js").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: import("./index.js").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: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            latencyChange?: number | null;
+            latencyTimeSeries: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            observedRequestPayloadBytes: number;
+            observedResponsePayloadBytes: number;
+            requestsChange?: number | null;
+            requestsTimeSeries: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            totalRequests: number;
+        }>;
+        requests: (project_id: string, q?: Omit<In<"hives_get_request_metrics">, "project_id">) => Promise<{
+            aggregation: import("./index.js").components["schemas"]["Hives.MetricAggregation"];
+            data: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            name: string;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            resolution_seconds: number;
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+        }>;
+        latency: (project_id: string, q?: Omit<In<"hives_get_latency_metrics">, "project_id">) => Promise<{
+            aggregation: import("./index.js").components["schemas"]["Hives.MetricAggregation"];
+            data: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            name: string;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            resolution_seconds: number;
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+        }>;
+        errors: (project_id: string, q?: Omit<In<"hives_get_error_metrics">, "project_id">) => Promise<{
+            aggregation: import("./index.js").components["schemas"]["Hives.MetricAggregation"];
+            data: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            name: string;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            resolution_seconds: number;
+            time_range: import("./index.js").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: import("./index.js").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: import("./index.js").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: import("./index.js").components["schemas"]["Hives.MetricAggregation"];
+            data: import("./index.js").components["schemas"]["Hives.MetricDataPoint"][];
+            name: string;
+            observation: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            resolution_seconds: number;
+            time_range: import("./index.js").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: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            observed_request_payload_bytes: number;
+            observed_response_payload_bytes: number;
+            p95_response_time_ms?: number | null;
+            time_range: import("./index.js").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: import("./index.js").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: import("./index.js").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: import("./index.js").components["schemas"]["Hives.ObservationScope"];
+            observed_request_payload_bytes: number;
+            observed_response_payload_bytes: number;
+            requests_per_second: number;
+            updated_at: string;
+        }>;
+    };
+    logs: {
+        query: (project_id: string, q?: Omit<In<"hives_query_logs">, "project_id">) => Promise<{
+            logs: import("./index.js").components["schemas"]["Hives.LogEntry"][];
+            pagination: import("./index.js").components["schemas"]["Hives.PaginationMeta"];
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+        }>;
+        stream: (project_id: string, q?: import("./hives-platform.js").HivesLogStreamQuery, init?: {
+            signal?: AbortSignal;
+        }) => AsyncGenerator<import("./hives-platform.js").HivesLogStreamEvent, void, any>;
+        window: (project_id: string, q?: import("./hives-platform.js").HivesLogStreamQuery, options?: import("./hives-platform.js").HivesLogWindowOptions) => Promise<import("./hives-platform.js").HivesLogWindow>;
+    };
+    domains: {
+        list: (project_id: string, q?: Omit<In<"hives_list_domains">, "project_id">) => Promise<{
+            data: {
+                created_at: string;
+                dns_status: string;
+                domain: string;
+                domain_type: import("./index.js").components["schemas"]["Hives.DomainType"];
+                id: string;
+                ssl_expires_at?: string | null;
+                ssl_status: string;
+                verification_record?: null | import("./index.js").components["schemas"]["Hives.VerificationRecord"];
+            }[];
+            pagination: import("./index.js").components["schemas"]["Hives.PaginationMeta"];
+        }>;
+        add: (project_id: string, body: In<"hives_add_domain">["body"]) => Promise<{
+            created_at: string;
+            dns_status: string;
+            domain: string;
+            domain_type: import("./index.js").components["schemas"]["Hives.DomainType"];
+            id: string;
+            ssl_expires_at?: string | null;
+            ssl_status: string;
+            verification_record?: null | import("./index.js").components["schemas"]["Hives.VerificationRecord"];
+        }>;
+        verify: (project_id: string, domain_id: string) => Promise<{
+            checked_at: string;
+            dns_status: string;
+            error?: string | null;
+            verified: boolean;
+        }>;
+        provisionSsl: (project_id: string, domain_id: string) => Promise<{
+            error?: string | null;
+            expires_at?: string | null;
+            ssl_status: string;
+            started: boolean;
+        }>;
+    };
+    auth: {
+        me: () => Promise<{
+            avatar?: string | null;
+            createdAt: string;
+            email: string;
+            id: string;
+            name: string;
+            organizationId?: string | null;
+            role: string;
+        }>;
+    };
+    fleets: {
+        list: () => Promise<{
+            fleets: import("./index.js").components["schemas"]["Hives.FleetStatusView"][];
+        }>;
+        deploy: (body: In<"hives_deploy_fleet">["body"]) => Promise<{
+            fleetId: string;
+            gatewayEndpoint?: string | null;
+            totalInstances: number;
+        }>;
+        status: (fleet_id: string) => Promise<{
+            fleetId: string;
+            gateway?: null | import("./index.js").components["schemas"]["Hives.GatewaySummary"];
+            healthyInstances: number;
+            name: string;
+            protocols: import("./index.js").components["schemas"]["Hives.ProtocolStatusView"][];
+            state: string;
+            totalInstances: number;
+        }>;
+        teardown: (fleet_id: string) => Promise<void>;
+    };
+    remote: {
+        sessions: {
+            list: (project_id: string, q?: Omit<In<"hives_list_remote_sessions">, "project_id">) => Promise<Record<string, never>>;
+            close: (project_id: string, session_id: string) => Promise<Record<string, never>>;
+        };
+        ssh: (project_id: string, body: In<"hives_create_ssh_session">["body"]) => Promise<{
+            expires_at: string;
+            fingerprint: string;
+            host: string;
+            port: number;
+            session_id: string;
+            username: string;
+        }>;
+        terminal: (project_id: string, body: In<"hives_create_terminal_session">["body"]) => Promise<{
+            expires_at: string;
+            session_id: string;
+            token: string;
+            websocket_url: string;
+        }>;
+        debug: (project_id: string, body: In<"hives_create_debug_session">["body"]) => Promise<{
+            debug_url: string;
+            expires_at: string;
+            protocol: string;
+            session_id: string;
+            token: string;
+        }>;
+        sftp: {
+            list: (project_id: string, target_id: string, q?: {
+                path?: string;
+            }) => Promise<Record<string, never>>;
+            read: (project_id: string, target_id: string, path: string) => Promise<Record<string, never>>;
+            write: (project_id: string, target_id: string, body: In<"hives_sftp_write">["body"]) => Promise<Record<string, never>>;
+            delete: (project_id: string, target_id: string, body: In<"hives_sftp_delete">["body"]) => Promise<Record<string, never>>;
+        };
+    };
+};

package/dist/hives-operations.js

@@ -0,0 +1,43 @@
+import { hivesTopics } from './hives-topics.js';
+import { hivesCells } from './hives-cells.js';
+import { hivesQueues } from './hives-queues.js';
+import { hivesRuntimes } from './hives-runtimes.js';
+import { hivesPlatform } from './hives-platform.js';
+/** The original Hives scheduler, settings and measured activity use the same gateway and identity. */
+export function hivesOperations(client) {
+    return {
+        ...hivesPlatform(client),
+        cells: hivesCells(client),
+        queues: hivesQueues(client),
+        topics: hivesTopics(client),
+        runtimes: hivesRuntimes(client),
+        settings: {
+            get: (project_id) => client.request('hives_get_project_settings', { project_id }),
+            update: (project_id, body) => client.request('hives_update_project_settings', { project_id, body }),
+        },
+        crons: {
+            list: (project_id, q = {}) => client.request('hives_list_crons', { ...q, project_id }),
+            get: (project_id, cron_id) => client.request('hives_get_cron', { project_id, cron_id }),
+            create: (project_id, body) => client.request('hives_create_cron', { project_id, body }),
+            update: (project_id, cron_id, body) => client.request('hives_update_cron', { project_id, cron_id, body }),
+            delete: (project_id, cron_id) => client.request('hives_delete_cron', { project_id, cron_id }),
+            pause: (project_id, cron_id) => client.request('hives_pause_cron', { project_id, cron_id }),
+            resume: (project_id, cron_id) => client.request('hives_resume_cron', { project_id, cron_id }),
+            /** Admission returns a persisted run ID; read history to learn its actual outcome. No retry. */
+            trigger: (project_id, cron_id) => client.request('hives_trigger_cron', { project_id, cron_id }),
+            runs: (project_id, cron_id, q = {}) => client.request('hives_get_cron_runs', { ...q, project_id, cron_id }),
+        },
+        metrics: {
+            project: (project_id, q = {}) => client.request('hives_get_project_metrics', { ...q, project_id }),
+            dashboard: (project_id, q = {}) => client.request('hives_get_dashboard_metrics', { ...q, project_id }),
+            requests: (project_id, q = {}) => client.request('hives_get_request_metrics', { ...q, project_id }),
+            latency: (project_id, q = {}) => client.request('hives_get_latency_metrics', { ...q, project_id }),
+            errors: (project_id, q = {}) => client.request('hives_get_error_metrics', { ...q, project_id }),
+            function: (project_id, function_id, q = {}) => client.request('hives_get_function_metrics', { ...q, project_id, function_id }),
+            invocations: (project_id, function_id, q = {}) => client.request('hives_get_function_invocations_series', { ...q, project_id, function_id }),
+            deployment: (project_id, deployment_id, q = {}) => client.request('hives_get_deployment_metrics', { ...q, project_id, deployment_id }),
+            resources: (project_id, q = {}) => client.request('hives_get_resource_usage', { ...q, project_id }),
+            realtime: (project_id) => client.request('hives_get_realtime_metrics', { project_id }),
+        },
+    };
+}

package/dist/hives-platform.d.ts

@@ -0,0 +1,149 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** One Server-Sent Event from `GET /v1/hives/projects/{project_id}/logs/stream`. `data` is parsed JSON when it is JSON. */
+export interface HivesLogStreamEvent {
+    event: string;
+    id?: string;
+    data: unknown;
+}
+export type HivesLogStreamQuery = Omit<In<'hives_stream_logs'>, 'project_id'>;
+export interface HivesLogWindowOptions {
+    /** Stop after this many events (1–10000, default 100). */
+    maxEvents?: number;
+    /** Stop after this many seconds (1–300, default 10). */
+    seconds?: number;
+    signal?: AbortSignal;
+}
+export interface HivesLogWindow {
+    events: HivesLogStreamEvent[];
+    ended: 'max_events' | 'time' | 'closed';
+}
+/** Pull-based SSE reader. `cancel()` closes the connection even while a read is pending. */
+export declare function hivesSseReader(response: Response): {
+    next(): Promise<HivesLogStreamEvent | undefined>;
+    cancel(): Promise<void>;
+};
+/** Yield SSE events until the caller stops iterating, the signal aborts or the server closes the stream. */
+export declare function hivesSseEvents(response: Response): AsyncGenerator<HivesLogStreamEvent>;
+/**
+ * Hives platform reads and actions the gateway already routes: project logs (query and live SSE), custom domains,
+ * the Hives identity, Hives fleets and remote sessions/SFTP.
+ */
+export declare function hivesPlatform(client: GenesisClient): {
+    logs: {
+        query: (project_id: string, q?: Omit<In<"hives_query_logs">, "project_id">) => Promise<{
+            logs: import("./index.js").components["schemas"]["Hives.LogEntry"][];
+            pagination: import("./index.js").components["schemas"]["Hives.PaginationMeta"];
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+        }>;
+        /** Live SSE events. Iterate and `break` (or abort the signal) to close the connection; it never ends on its own. */
+        stream: (project_id: string, q?: HivesLogStreamQuery, init?: {
+            signal?: AbortSignal;
+        }) => AsyncGenerator<HivesLogStreamEvent, void, any>;
+        /** A bounded window of the live stream: the first `maxEvents` events or `seconds` of stream, whichever comes first. */
+        window: (project_id: string, q?: HivesLogStreamQuery, options?: HivesLogWindowOptions) => Promise<HivesLogWindow>;
+    };
+    domains: {
+        list: (project_id: string, q?: Omit<In<"hives_list_domains">, "project_id">) => Promise<{
+            data: {
+                created_at: string;
+                dns_status: string;
+                domain: string;
+                domain_type: import("./index.js").components["schemas"]["Hives.DomainType"];
+                id: string;
+                ssl_expires_at?: string | null;
+                ssl_status: string;
+                verification_record?: null | import("./index.js").components["schemas"]["Hives.VerificationRecord"];
+            }[];
+            pagination: import("./index.js").components["schemas"]["Hives.PaginationMeta"];
+        }>;
+        add: (project_id: string, body: In<"hives_add_domain">["body"]) => Promise<{
+            created_at: string;
+            dns_status: string;
+            domain: string;
+            domain_type: import("./index.js").components["schemas"]["Hives.DomainType"];
+            id: string;
+            ssl_expires_at?: string | null;
+            ssl_status: string;
+            verification_record?: null | import("./index.js").components["schemas"]["Hives.VerificationRecord"];
+        }>;
+        verify: (project_id: string, domain_id: string) => Promise<{
+            checked_at: string;
+            dns_status: string;
+            error?: string | null;
+            verified: boolean;
+        }>;
+        provisionSsl: (project_id: string, domain_id: string) => Promise<{
+            error?: string | null;
+            expires_at?: string | null;
+            ssl_status: string;
+            started: boolean;
+        }>;
+    };
+    auth: {
+        me: () => Promise<{
+            avatar?: string | null;
+            createdAt: string;
+            email: string;
+            id: string;
+            name: string;
+            organizationId?: string | null;
+            role: string;
+        }>;
+    };
+    fleets: {
+        list: () => Promise<{
+            fleets: import("./index.js").components["schemas"]["Hives.FleetStatusView"][];
+        }>;
+        deploy: (body: In<"hives_deploy_fleet">["body"]) => Promise<{
+            fleetId: string;
+            gatewayEndpoint?: string | null;
+            totalInstances: number;
+        }>;
+        status: (fleet_id: string) => Promise<{
+            fleetId: string;
+            gateway?: null | import("./index.js").components["schemas"]["Hives.GatewaySummary"];
+            healthyInstances: number;
+            name: string;
+            protocols: import("./index.js").components["schemas"]["Hives.ProtocolStatusView"][];
+            state: string;
+            totalInstances: number;
+        }>;
+        teardown: (fleet_id: string) => Promise<void>;
+    };
+    remote: {
+        sessions: {
+            list: (project_id: string, q?: Omit<In<"hives_list_remote_sessions">, "project_id">) => Promise<Record<string, never>>;
+            close: (project_id: string, session_id: string) => Promise<Record<string, never>>;
+        };
+        ssh: (project_id: string, body: In<"hives_create_ssh_session">["body"]) => Promise<{
+            expires_at: string;
+            fingerprint: string;
+            host: string;
+            port: number;
+            session_id: string;
+            username: string;
+        }>;
+        terminal: (project_id: string, body: In<"hives_create_terminal_session">["body"]) => Promise<{
+            expires_at: string;
+            session_id: string;
+            token: string;
+            websocket_url: string;
+        }>;
+        debug: (project_id: string, body: In<"hives_create_debug_session">["body"]) => Promise<{
+            debug_url: string;
+            expires_at: string;
+            protocol: string;
+            session_id: string;
+            token: string;
+        }>;
+        sftp: {
+            list: (project_id: string, target_id: string, q?: {
+                path?: string;
+            }) => Promise<Record<string, never>>;
+            read: (project_id: string, target_id: string, path: string) => Promise<Record<string, never>>;
+            write: (project_id: string, target_id: string, body: In<"hives_sftp_write">["body"]) => Promise<Record<string, never>>;
+            delete: (project_id: string, target_id: string, body: In<"hives_sftp_delete">["body"]) => Promise<Record<string, never>>;
+        };
+    };
+};