@lifesi/genesis 0.1.1 → 0.1.3

package/dist/hives-marketplace.js

@@ -0,0 +1,187 @@
+import { hivesResourceCall, hivesResourceId, resourceError } from './hives-resources-transport.js';
+function invalid() { throw resourceError(0); }
+function record(value) { if (!value || typeof value !== 'object' || Array.isArray(value))
+    invalid(); return value; }
+function keys(value, allowed) { if (Object.keys(value).some(key => !allowed.includes(key)))
+    invalid(); }
+function text(value, max) { if (typeof value !== 'string' || new TextEncoder().encode(value).length > max)
+    invalid(); return value; }
+function uuid(value) { const result = text(value, 36); if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(result))
+    invalid(); return result.toLowerCase(); }
+function slug(value) { const result = text(value, 64); if (!/^[a-z][a-z0-9-]*[a-z0-9]$/.test(result))
+    invalid(); return result; }
+function semver(value, maxCore = 18446744073709551615n) {
+    const result = text(value, 64);
+    const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(result);
+    if (!match || match.slice(1, 4).some(part => BigInt(part) > maxCore)
+        || match[4]?.split('.').some(part => /^\d+$/.test(part) && part.length > 1 && part.startsWith('0')))
+        invalid();
+    return result;
+}
+function count(value, min = 0, max = Number.MAX_SAFE_INTEGER) { if (!Number.isSafeInteger(value) || value < min || value > max)
+    invalid(); return value; }
+function bool(value) { if (typeof value !== 'boolean')
+    invalid(); return value; }
+function strings(value, limit, max) { if (!Array.isArray(value) || value.length > limit)
+    invalid(); return value.map(item => text(item, max)); }
+function date(value) { const result = text(value, 64); if (!Number.isFinite(Date.parse(result)))
+    invalid(); return result; }
+function nullable(value, parse) { return value === null ? null : parse(value); }
+function deployment(value) { const id = text(value, 64); if (!/^dpl_[A-Za-z0-9_-]+$/.test(id))
+    invalid(); return id; }
+function packageRow(value) {
+    const r = record(value);
+    if (!['public', 'private', 'unlisted'].includes(String(r.visibility)) || r.visibility === 'private' && r.owned !== true)
+        invalid();
+    return { id: uuid(r.id), slug: slug(r.slug), name: text(r.name, 128), description: text(r.description, 500), author_name: text(r.author_name, 1000),
+        visibility: r.visibility, categories: strings(r.categories, 5, 64), keywords: strings(r.keywords, 20, 64), license: text(r.license, 64),
+        installs: count(r.installs), stars: count(r.stars), verified: bool(r.verified), featured: bool(r.featured), free: bool(r.free),
+        latest_version: semver(r.latest_version), version_count: count(r.version_count, 1), owned: bool(r.owned), created_at: date(r.created_at), updated_at: date(r.updated_at) };
+}
+function versionRow(value, expectedPackage) {
+    const r = record(value);
+    const packageId = uuid(r.package_id);
+    const hash = text(r.module_hash, 64);
+    if (expectedPackage && packageId !== expectedPackage || !/^[a-f0-9]{64}$/.test(hash))
+        invalid();
+    return { id: uuid(r.id), package_id: packageId, version: semver(r.version), module_hash: hash, size_bytes: count(r.size_bytes, 1, 10 * 1024 * 1024),
+        readme: text(r.readme, 50_000), changelog: text(r.changelog, 2000), required_env: strings(r.required_env, 50, 128), downloads: count(r.downloads), deprecated: bool(r.deprecated), published_at: date(r.published_at) };
+}
+function installationRow(value, project, expectedId) {
+    const r = record(value);
+    if (r.project_id !== project || expectedId && uuid(r.id) !== uuid(expectedId) || !['active', 'updating', 'failed', 'uninstalled'].includes(String(r.status))
+        || !(r.operation === null || ['install', 'update', 'cleanup', 'uninstall'].includes(String(r.operation))))
+        invalid();
+    const result = { id: uuid(r.id), package_id: uuid(r.package_id), slug: slug(r.slug), name: text(r.name, 128), project_id: project,
+        version: nullable(r.version, semver), deployment_id: nullable(r.deployment_id, deployment), deployment_status: nullable(r.deployment_status, v => text(v, 32)),
+        pending_version: nullable(r.pending_version, semver), pending_deployment_id: nullable(r.pending_deployment_id, deployment), pending_deployment_status: nullable(r.pending_deployment_status, v => text(v, 32)),
+        operation: r.operation, status: r.status,
+        latest_version: nullable(r.latest_version, semver), installed_at: date(r.installed_at) };
+    if (result.status === 'uninstalled' && (result.operation || result.deployment_id || result.pending_deployment_id))
+        invalid();
+    return result;
+}
+function page(value, pageNumber, pageSize, parse) {
+    const r = record(value);
+    const p = record(r.pagination);
+    const total = count(p.total);
+    const pages = Math.ceil(total / pageSize);
+    if (p.page !== pageNumber || p.page_size !== pageSize || p.total_pages !== pages || p.has_next !== (pageNumber < pages) || p.has_prev !== (pageNumber > 1)
+        || !Array.isArray(r.data) || r.data.length > pageSize)
+        invalid();
+    const data = r.data.map(parse);
+    if (new Set(data.map(row => row.id)).size !== data.length)
+        invalid();
+    return { data, pagination: { page: pageNumber, page_size: pageSize, total, total_pages: pages, has_next: pageNumber < pages, has_prev: pageNumber > 1 } };
+}
+function details(value, expectedSlug, exactVersion) {
+    const r = record(value);
+    const pkg = packageRow(r);
+    if (pkg.slug !== expectedSlug || !Array.isArray(r.versions) || r.versions.length > 5 || r.versions.length === 0)
+        invalid();
+    const versions = r.versions.map(row => versionRow(row, pkg.id));
+    if (new Set(versions.map(row => row.id)).size !== versions.length || exactVersion && versions.some(row => row.version !== exactVersion))
+        invalid();
+    return { ...pkg, versions };
+}
+function pagination(query, max) {
+    keys(record(query), ['page', 'page_size']);
+    return { page: count(query.page ?? 1, 1, 100_000), page_size: count(query.page_size ?? max, 1, max) };
+}
+function installInput(input) {
+    const r = record(input);
+    keys(r, ['version', 'env_overrides']);
+    const env = record(r.env_overrides ?? {});
+    if (Object.keys(env).length > 50)
+        invalid();
+    const entries = Object.entries(env).map(([key, value]) => [text(key, 128), text(value, 4096)]);
+    return { ...(r.version == null ? {} : { version: semver(r.version) }), env_overrides: Object.fromEntries(entries) };
+}
+function publishInput(input) {
+    const r = record(input);
+    keys(r, ['slug', 'name', 'module_hash', 'version', 'description', 'visibility', 'categories', 'keywords', 'readme', 'changelog', 'required_env', 'license']);
+    const name = text(r.name, 128);
+    const hash = text(r.module_hash, 64);
+    const visibility = r.visibility ?? 'public';
+    if (!name.trim() || !/^[a-f0-9]{64}$/.test(hash) || !['public', 'private', 'unlisted'].includes(String(visibility)))
+        invalid();
+    const required = strings(r.required_env ?? [], 50, 128);
+    if (new Set(required).size !== required.length || required.some(key => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)))
+        invalid();
+    return { slug: slug(r.slug), name, module_hash: hash, version: semver(r.version, 2147483647n), description: text(r.description ?? '', 500),
+        visibility: visibility, categories: strings(r.categories ?? [], 5, 64), keywords: strings(r.keywords ?? [], 20, 64),
+        readme: text(r.readme ?? '', 50_000), changelog: text(r.changelog ?? '', 2000), required_env: required, license: text(r.license ?? '', 64) };
+}
+/** Native Marketplace reuses verified project ownership and persisted deployment lifecycle.
+ * Writes are sent once. Read/reconcile saved state after an uncertain acknowledgement. */
+export function hivesMarketplace(client) {
+    const projectInput = (project) => ({ project_id: hivesResourceId(project) });
+    const call = (operation, input, options) => hivesResourceCall(client, `hives_marketplace_${operation}`, input, options);
+    const mutate = async (operation, project, packageSlug, input, options) => {
+        const body = installInput(input);
+        const result = installationRow(await call(operation, { ...projectInput(project), slug: slug(packageSlug), body }, options), project);
+        if (result.slug !== packageSlug || result.status === 'uninstalled' || body.version && result.version !== body.version && result.pending_version !== body.version)
+            invalid();
+        return result;
+    };
+    return {
+        async list(project, query = {}, options) {
+            keys(record(query), ['q', 'category', 'free_only', 'verified_only', 'sort', 'order', 'page', 'page_size']);
+            const p = { page: count(query.page ?? 1, 1, 100_000), page_size: count(query.page_size ?? 20, 1, 100) };
+            const sort = query.sort ?? 'installs';
+            const order = query.order ?? 'desc';
+            if (!['name', 'installs', 'stars', 'created', 'updated'].includes(sort) || !['asc', 'desc'].includes(order))
+                invalid();
+            const input = { ...projectInput(project), ...p, sort, order, free_only: bool(query.free_only ?? false), verified_only: bool(query.verified_only ?? false),
+                ...(query.q == null ? {} : { q: text(query.q, 200) }), ...(query.category == null ? {} : { category: text(query.category, 64) }) };
+            return page(await call('list_packages', input, options), p.page, p.page_size, packageRow);
+        },
+        async get(project, packageSlug, query = {}, options) {
+            keys(record(query), ['version']);
+            const version = query.version == null ? undefined : semver(query.version);
+            return details(await call('get_package', { ...projectInput(project), slug: slug(packageSlug), ...(version === undefined ? {} : { version }) }, options), packageSlug, version);
+        },
+        async versions(project, packageSlug, query = {}, options) {
+            const p = pagination(query, 5);
+            const result = page(await call('list_versions', { ...projectInput(project), slug: slug(packageSlug), ...p }, options), p.page, p.page_size, row => versionRow(row));
+            if (new Set(result.data.map(row => row.package_id)).size > 1)
+                invalid();
+            return result;
+        },
+        async featured(project, options) { return page(await call('featured', projectInput(project), options), 1, 20, packageRow); },
+        async categories(project, options) {
+            const result = await call('categories', projectInput(project), options);
+            if (!Array.isArray(result) || result.length > 100)
+                invalid();
+            const data = result.map(value => {
+                const r = record(value);
+                return { id: uuid(r.id), slug: slug(r.slug), name: text(r.name, 128),
+                    description: nullable(r.description, v => text(v, 1000)), icon_url: nullable(r.icon_url, v => text(v, 2048)), package_count: count(r.package_count), sort_order: count(r.sort_order, -2147483648, 2147483647) };
+            });
+            if (new Set(data.map(row => row.id)).size !== data.length)
+                invalid();
+            return data;
+        },
+        async publish(project, input, options) {
+            const body = publishInput(input);
+            const result = details(await call('publish', { ...projectInput(project), body }, options), body.slug);
+            if (!result.owned || !result.versions.some(v => v.version === body.version && v.module_hash === body.module_hash))
+                invalid();
+            return result;
+        },
+        async install(project, packageSlug, input = {}, options) { return mutate('install', project, packageSlug, input, options); },
+        async update(project, packageSlug, input = {}, options) { return mutate('update', project, packageSlug, input, options); },
+        async installed(project, query = {}, options) {
+            const p = pagination(query, 20);
+            return page(await call('installed', { ...projectInput(project), ...p }, options), p.page, p.page_size, row => installationRow(row, project));
+        },
+        async getInstallation(project, id, options) { return installationRow(await call('get_installation', { ...projectInput(project), installation_id: uuid(id) }, options), project, id); },
+        async reconcile(project, id, options) { return installationRow(await call('reconcile', { ...projectInput(project), installation_id: uuid(id) }, options), project, id); },
+        async uninstall(project, id, options) {
+            const result = installationRow(await call('uninstall', { ...projectInput(project), installation_id: uuid(id) }, options), project, id);
+            if (result.status !== 'uninstalled' || result.operation || result.deployment_id || result.pending_deployment_id)
+                invalid();
+            return result;
+        },
+    };
+}

package/dist/hives-node.js

@@ -12,6 +12,8 @@ export async function closeHivesNodeTransport() {
     await current?.destroy();
 }
 export function hivesOperationBudget(id) {
+    if (['hives_list_buckets', 'hives_create_bucket', 'hives_get_bucket', 'hives_delete_bucket', 'hives_list_objects', 'hives_upload_object', 'hives_upload_object_by_key', 'hives_delete_object', 'hives_delete_object_by_key', 'hives_download_object_by_key', 'hives_get_cors_config', 'hives_set_cors_config', 'hives_generate_presigned_url', 'hives_reconcile'].includes(id))
+        return 100_000;
     if (id === 'hives_cancel_deployment' || id === 'hives_delete_deployment')
         return 330_000;
     if (['hives_create_deployment', 'hives_upload_deployment', 'hives_invoke_deployment', 'hives_invoke_function', 'hives_invoke_function_async'].includes(id))

package/dist/hives-operations.d.ts

@@ -0,0 +1,304 @@
+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: {
+        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: 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;
+        }>;
+    };
+};

package/dist/hives-operations.js

@@ -0,0 +1,39 @@
+import { hivesCells } from './hives-cells.js';
+import { hivesQueues } from './hives-queues.js';
+import { hivesRuntimes } from './hives-runtimes.js';
+/** The original Hives scheduler, settings and measured activity use the same gateway and identity. */
+export function hivesOperations(client) {
+    return {
+        cells: hivesCells(client),
+        queues: hivesQueues(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 }),
+        },
+    };
+}