@onesi/genesis 0.0.1-stage → 0.1.13

package/dist/flares.js

@@ -0,0 +1,56 @@
+import { idempotencyHeaders } from './idempotency.js';
+/** Flares v2 (Sandbox): flares, conversations, commitments, presence, trust and choreography.
+ * Every mutation needs one stable idempotency key; reuse it to replay instead of acting twice. */
+export function flaresModule(client) {
+    const write = async (id, input, idempotencyKey) => client.request(id, input, { headers: idempotencyHeaders(id, idempotencyKey) });
+    return {
+        list: (q = {}) => client.request('flares_listFlares', q),
+        get: (id) => client.request('flares_getFlare', { id }),
+        send: (body, key) => write('flares_sendFlare', { body }, key),
+        sendBatch: (body, key) => write('flares_sendFlareBatch', { body }, key),
+        acknowledge: (id, body, key) => write('flares_acknowledgeFlare', { id, body }, key),
+        act: (id, body, key) => write('flares_actOnFlare', { id, body }, key),
+        conversations: {
+            list: () => client.request('flares_listConversations'),
+            get: (id) => client.request('flares_getConversation', { id }),
+            create: (body, key) => write('flares_createConversation', { body }, key),
+            send: (id, body, key) => write('flares_sendConversationMessage', { id, body }, key),
+            close: (id, key) => write('flares_closeConversation', { id }, key),
+        },
+        commitments: {
+            list: () => client.request('flares_listCommitments'),
+            get: (id) => client.request('flares_getCommitment', { id }),
+            create: (body, key) => write('flares_createCommitment', { body }, key),
+            accept: (id, key) => write('flares_acceptCommitment', { id }, key),
+            start: (id, key) => write('flares_startCommitment', { id }, key),
+            progress: (id, body, key) => write('flares_reportCommitmentProgress', { id, body }, key),
+            fulfill: (id, body, key) => write('flares_fulfillCommitment', { id, body }, key),
+            fail: (id, body, key) => write('flares_failCommitment', { id, body }, key),
+        },
+        presence: {
+            heartbeat: (body, key) => write('flares_presenceHeartbeat', { body }, key),
+            get: (did) => client.request('flares_getPresence', { did }),
+        },
+        trust: {
+            score: (did) => client.request('flares_getTrustScore', { did }),
+            check: (body, key) => write('flares_checkTrust', { body }, key),
+            endorsements: (did) => client.request('flares_listEndorsements', { did }),
+            endorse: (body, key) => write('flares_createEndorsement', { body }, key),
+            revoke: (id, key) => write('flares_revokeEndorsement', { id }, key),
+        },
+        choreography: {
+            workflows: {
+                list: () => client.request('flares_listChoreographyWorkflows'),
+                create: (body, key) => write('flares_createChoreographyWorkflow', { body }, key),
+                start: (workflow_id, key) => write('flares_startChoreographyExecution', { workflow_id }, key),
+            },
+            executions: {
+                list: () => client.request('flares_listChoreographyExecutions'),
+                get: (execution_id) => client.request('flares_getChoreographyExecution', { execution_id }),
+                completeStep: (execution_id, step_id, body, key) => write('flares_completeChoreographyStep', { execution_id, step_id, body }, key),
+                failStep: (execution_id, step_id, body, key) => write('flares_failChoreographyStep', { execution_id, step_id, body }, key),
+                cancel: (execution_id, key) => write('flares_cancelChoreographyExecution', { execution_id }, key),
+            },
+        },
+    };
+}

package/dist/fleets.d.ts

@@ -0,0 +1,186 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput } from './types.js';
+type TaskInput = NonNullable<OperationInput<'fleets_submitTask'>['body']>;
+type AgentLaunchInput = NonNullable<OperationInput<'fleets_launchAgent'>['body']>;
+type AgentCommandInput = NonNullable<OperationInput<'fleets_commandAgent'>['body']>;
+export interface FleetsInstanceOptions {
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+/** Managed Henry instances and tasks scoped to the credential's verified org. */
+export declare function fleetsModule(client: GenesisClient): {
+    agents: {
+        list: () => Promise<{
+            agents: import("./index.js").components["schemas"]["Fleets.Agent"][];
+        }>;
+        launch: (body: AgentLaunchInput) => Promise<{
+            id: string;
+            name: string;
+            state: "launching" | "running" | "stopping" | "stopped" | "recovering" | "recovery_required";
+            memory: import("./index.js").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: import("./index.js").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: AgentCommandInput) => Promise<{
+            agent: import("./index.js").components["schemas"]["Fleets.Agent"];
+            operation_id: string;
+            result?: {
+                [key: string]: unknown;
+            };
+        }>;
+        stop: (agent_id: string) => Promise<{
+            agent: import("./index.js").components["schemas"]["Fleets.Agent"];
+            operation_id: string;
+            result?: {
+                [key: string]: unknown;
+            };
+        }>;
+        recover: (agent_id: string) => Promise<{
+            agent: import("./index.js").components["schemas"]["Fleets.Agent"];
+            operation_id: string;
+            result?: {
+                [key: string]: unknown;
+            };
+        }>;
+    };
+    instances: {
+        list: (query?: OperationInput<"fleets_listInstances">) => Promise<{
+            instances: import("./index.js").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?: 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?: FleetsInstanceOptions) => Promise<{
+            id: string;
+            name: string;
+            organization_id: string;
+            workspace_id: string;
+            project_id: string;
+            admission_held: boolean | null;
+            physical_state: "created" | "running" | "held" | "stopped" | "recovery_required" | "released";
+            status_evidence: "live_controller" | "confirmed_release_receipt";
+            release_acknowledged_at_ms: number | null;
+            harness_ready: boolean;
+            observed_at_ms: number | null;
+            lease_expires: {
+                wall_ms: number;
+                logical: number;
+            } | null;
+        }>;
+    };
+    connection: {
+        get: () => Promise<{
+            connected: boolean;
+            model: string;
+            updated_at?: number;
+        }>;
+        set: (api_key: string) => Promise<{
+            connected: boolean;
+            model: string;
+            updated_at?: number;
+        }>;
+        delete: () => Promise<{
+            connected: boolean;
+            model: string;
+            updated_at?: number;
+        }>;
+    };
+    usage: {
+        /** Task lifecycle and execution-time usage events, paged by task like tasks.list. */
+        events: (query?: OperationInput<"fleets_listUsageEvents">) => Promise<{
+            events: import("./index.js").components["schemas"]["Fleets.UsageEvent"][];
+            next_before: string | null;
+        }>;
+    };
+    tasks: {
+        list: (query?: OperationInput<"fleets_listTasks">) => Promise<{
+            tasks: import("./index.js").components["schemas"]["Fleets.Summary"][];
+            next_before: string | null;
+        }>;
+        submit: (body: TaskInput) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+            submitted_at: string;
+            started_at?: string | null;
+            completed_at?: string | null;
+        }>;
+        get: (task_id: string) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+            submitted_at: string;
+            started_at?: string | null;
+            completed_at?: string | null;
+        }>;
+        cancel: (task_id: string) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+        }>;
+        receipt: (task_id: string) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+            submitted_at: string;
+            started_at?: string | null;
+            completed_at?: string | null;
+        } & {
+            tenant: string;
+            principal: string;
+            idempotency_key: string | null;
+            request_fingerprint: string;
+            timeout_seconds: number;
+            exit_code: number | null;
+            exit_signal: number | null;
+            cleanup_result: {
+                process_group_gone?: boolean;
+                workdir_removed?: boolean;
+                sigkill_sent?: boolean;
+            } | null;
+            henry_receipt?: {
+                [key: string]: unknown;
+            };
+        }>;
+    };
+};
+export {};

package/dist/fleets.js

@@ -0,0 +1,136 @@
+import { GenesisError } from './errors.js';
+const byteLength = (value) => new TextEncoder().encode(value).byteLength;
+const invalid = (operationId, message) => new GenesisError({
+    status: 0, type: 'invalid_request', operationId, message,
+});
+function instanceOptions(operation, options) {
+    const key = options.idempotencyKey;
+    if (key !== undefined && (typeof key !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(key))) {
+        throw invalid(operation, 'Idempotency-Key must be one canonical UUID4.');
+    }
+    return { signal: options.signal, ...(key === undefined ? {} : { headers: { 'idempotency-key': key } }) };
+}
+function validateTask(body) {
+    if (typeof body?.input !== 'string' || !body.input || byteLength(body.input) > 65536 || body.input.includes('\0')) {
+        throw invalid('fleets_submitTask', 'Task input must contain 1–65536 UTF-8 bytes without NUL.');
+    }
+    if (body.timeout_seconds !== undefined && (!Number.isInteger(body.timeout_seconds) || body.timeout_seconds < 1 || body.timeout_seconds > 3600)) {
+        throw invalid('fleets_submitTask', 'Timeout must be 1–3600 seconds.');
+    }
+    if (body.idempotency_key !== undefined && (typeof body.idempotency_key !== 'string' || !/^[!-~]{1,128}$/.test(body.idempotency_key))) {
+        throw invalid('fleets_submitTask', 'Idempotency key must contain 1–128 visible ASCII characters.');
+    }
+}
+function validateKey(apiKey) {
+    if (typeof apiKey !== 'string' || !apiKey || byteLength(apiKey) > 4096 || /[\r\n\0]/.test(apiKey)) {
+        throw invalid('fleets_setConnection', 'Foundry key must contain 1–4096 UTF-8 bytes without CR, LF or NUL.');
+    }
+}
+const instanceId = (value, operation) => {
+    if (typeof value !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
+        throw invalid(operation, 'Invalid Fleets instance ID.');
+    }
+};
+const agentId = (value, operation) => {
+    if (typeof value !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
+        throw invalid(operation, 'Invalid Fleets agent ID.');
+    }
+};
+function validateAgentLaunch(body) {
+    if (!body || typeof body.name !== 'string' || !body.name.trim() || byteLength(body.name) > 128) {
+        throw invalid('fleets_launchAgent', 'Agent name must contain 1–128 UTF-8 bytes.');
+    }
+    if (body.instructions !== undefined && (byteLength(body.instructions) > 65536 || body.instructions.includes('\0'))) {
+        throw invalid('fleets_launchAgent', 'Agent instructions must contain at most 65536 UTF-8 bytes without NUL.');
+    }
+    if (body.model !== undefined && (!body.model || byteLength(body.model) > 128)) {
+        throw invalid('fleets_launchAgent', 'Agent model must contain 1–128 UTF-8 bytes.');
+    }
+    if (body.memory !== undefined) {
+        if (!['minds', 'files', 'custom'].includes(body.memory.provider))
+            throw invalid('fleets_launchAgent', 'Memory provider must be minds, files, or custom.');
+        if (body.memory.provider === 'custom' && !body.memory.endpoint)
+            throw invalid('fleets_launchAgent', 'Custom memory requires an endpoint.');
+    }
+    if (body.idempotency_key !== undefined && (typeof body.idempotency_key !== 'string' || !/^[!-~]{1,128}$/.test(body.idempotency_key))) {
+        throw invalid('fleets_launchAgent', 'Idempotency key must contain 1–128 visible ASCII characters.');
+    }
+}
+function validateAgentCommand(body) {
+    if (!body || typeof body.input !== 'string' || !body.input.trim() || byteLength(body.input) > 65536 || body.input.includes('\0')) {
+        throw invalid('fleets_commandAgent', 'Agent input must contain 1–65536 UTF-8 bytes without NUL.');
+    }
+}
+/** Managed Henry instances and tasks scoped to the credential's verified org. */
+export function fleetsModule(client) {
+    return {
+        agents: {
+            list: () => client.request('fleets_listAgents'),
+            launch: async (body) => {
+                validateAgentLaunch(body);
+                return client.request('fleets_launchAgent', { body });
+            },
+            get: async (agent_id) => {
+                agentId(agent_id, 'fleets_getAgent');
+                return client.request('fleets_getAgent', { agent_id });
+            },
+            command: async (agent_id, body) => {
+                agentId(agent_id, 'fleets_commandAgent');
+                validateAgentCommand(body);
+                return client.request('fleets_commandAgent', { agent_id, body });
+            },
+            stop: async (agent_id) => {
+                agentId(agent_id, 'fleets_stopAgent');
+                return client.request('fleets_stopAgent', { agent_id });
+            },
+            recover: async (agent_id) => {
+                agentId(agent_id, 'fleets_recoverAgent');
+                return client.request('fleets_recoverAgent', { agent_id });
+            },
+        },
+        instances: {
+            list: async (query = {}) => {
+                if (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 50)) {
+                    throw invalid('fleets_listInstances', 'Limit must be 1–50.');
+                }
+                if (query.after !== undefined)
+                    instanceId(query.after, 'fleets_listInstances');
+                return client.request('fleets_listInstances', query);
+            },
+            get: async (instance_id) => {
+                instanceId(instance_id, 'fleets_getInstance');
+                return client.request('fleets_getInstance', { instance_id });
+            },
+            stop: async (instance_id, options = {}) => {
+                instanceId(instance_id, 'fleets_stopInstance');
+                return client.request('fleets_stopInstance', { instance_id }, instanceOptions('fleets_stopInstance', options));
+            },
+            start: async (instance_id, options = {}) => {
+                instanceId(instance_id, 'fleets_startInstance');
+                return client.request('fleets_startInstance', { instance_id }, instanceOptions('fleets_startInstance', options));
+            },
+        },
+        connection: {
+            get: () => client.request('fleets_getConnection', {}),
+            set: async (api_key) => {
+                validateKey(api_key);
+                return client.request('fleets_setConnection', { body: { api_key } });
+            },
+            delete: () => client.request('fleets_deleteConnection', {}),
+        },
+        usage: {
+            /** Task lifecycle and execution-time usage events, paged by task like tasks.list. */
+            events: (query = {}) => client.request('fleets_listUsageEvents', query),
+        },
+        tasks: {
+            list: (query = {}) => client.request('fleets_listTasks', query),
+            submit: async (body) => {
+                validateTask(body);
+                return client.request('fleets_submitTask', { body });
+            },
+            get: (task_id) => client.request('fleets_getTask', { task_id }),
+            cancel: (task_id) => client.request('fleets_cancelTask', { task_id }),
+            receipt: (task_id) => client.request('fleets_getTaskReceipt', { task_id }),
+        },
+    };
+}

package/dist/flocks.d.ts

@@ -0,0 +1,155 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput } from './types.js';
+/** Org scope comes from the One account credential verified by the gateway. */
+export declare function flocksModule(client: GenesisClient): {
+    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: OperationInput<"flocks_enrollNode">["body"]) => Promise<{
+            node: import("./index.js").components["schemas"]["Flocks.Node"];
+            node_binding: string;
+            heartbeat_interval_seconds: number;
+        }>;
+        activate: (id: string, body: OperationInput<"flocks_activateNode">["body"]) => Promise<{
+            node: import("./index.js").components["schemas"]["Flocks.Node"];
+            activated: boolean;
+        }>;
+        rotateCredential: (id: string, body: OperationInput<"flocks_rotateNodeCredential">["body"]) => Promise<{
+            accepted: boolean;
+        }>;
+    };
+    /** Harnesses each node reports, with version and readiness. */
+    harnesses: {
+        list: (query?: OperationInput<"flocks_listHarnesses">) => Promise<{
+            known_harnesses: string[];
+            items: import("./index.js").components["schemas"]["Flocks.NodeHarnesses"][];
+            next_cursor: string | null;
+        }>;
+    };
+    /** Harness agents (pick a harness, optionally pin a node) and canonical agent execution (a_<ULID>, human session token). */
+    agents: {
+        list: (query?: OperationInput<"flocks_listAgents">) => Promise<{
+            items: import("./index.js").components["schemas"]["Flocks.Agent"][];
+            next_cursor: string | null;
+        }>;
+        create: (body: OperationInput<"flocks_createAgent">["body"]) => Promise<{
+            id: string;
+            name: string;
+            harness: string;
+            node_id: string | null;
+            owner_subject?: string;
+            created_at: number;
+            updated_at: number;
+        }>;
+        get: (agent_id: string) => Promise<{
+            id: string;
+            name: string;
+            harness: string;
+            node_id: string | null;
+            owner_subject?: string;
+            created_at: number;
+            updated_at: number;
+        }>;
+        execute: (agent_id: string, body: OperationInput<"flocks_executeAgent">["body"]) => Promise<{
+            schemaVersion: 1;
+            agentId: string;
+            canonicalAgentDid: string;
+            bindingRevision: string;
+            executionId: string;
+            revision: number;
+            outcome: "accepted" | "already_admitted";
+        }>;
+        status: (agent_id: string) => Promise<{
+            schemaVersion: 1;
+            agentId: string;
+            canonicalAgentDid: string;
+            bindingRevision: string;
+            executionId: string;
+            revision: number;
+            status: "working" | "success" | "error";
+            observedAtMs: number;
+            expiresAtMs: number;
+        }>;
+        cancel: (agent_id: string, idempotency_key: string) => Promise<{
+            schemaVersion: 1;
+            agentId: string;
+            canonicalAgentDid: string;
+            bindingRevision: string;
+            executionId: string;
+            revision: number;
+            outcome: "cancelled" | "already_terminal" | "cancel_requested";
+            observedAtMs: number;
+            expiresAtMs: number;
+        }>;
+    };
+    runs: {
+        list: (query?: OperationInput<"flocks_listRuns">) => Promise<{
+            items: import("./index.js").components["schemas"]["Flocks.Run"][];
+            next_cursor: string | null;
+        }>;
+        get: (run_id: string) => Promise<{
+            id: string;
+            agent_id: string;
+            harness: string;
+            node_id: string | null;
+            task: string;
+            state: "pending" | "running" | "completed" | "failed";
+            error_code: string | null;
+            owner_subject?: string;
+            created_at: number;
+            updated_at: number;
+        }>;
+    };
+    joinTokens: {
+        exchange: (body: OperationInput<"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;
+        }>;
+    };
+};

package/dist/flocks.js

@@ -0,0 +1,39 @@
+/** Org scope comes from the One account credential verified by the gateway. */
+export function flocksModule(client) {
+    const nodePath = (id) => ({ id });
+    return {
+        readiness: {
+            get: () => client.request('flocks_getEnrollmentReadiness'),
+        },
+        nodes: {
+            list: () => client.request('flocks_listNodes'),
+            rename: (id, nickname) => client.request('flocks_renameNode', { ...nodePath(id), body: { nickname } }),
+            revoke: (id) => client.request('flocks_revokeNode', nodePath(id)),
+            heartbeat: (id, nodeBinding) => client.request('flocks_heartbeatNode', { ...nodePath(id), body: { node_binding: nodeBinding } }),
+            enroll: (body) => client.request('flocks_enrollNode', { body }),
+            activate: (id, body) => client.request('flocks_activateNode', { id, body }),
+            rotateCredential: (id, body) => client.request('flocks_rotateNodeCredential', { id, body }),
+        },
+        /** Harnesses each node reports, with version and readiness. */
+        harnesses: {
+            list: (query = {}) => client.request('flocks_listHarnesses', query),
+        },
+        /** Harness agents (pick a harness, optionally pin a node) and canonical agent execution (a_<ULID>, human session token). */
+        agents: {
+            list: (query = {}) => client.request('flocks_listAgents', query),
+            create: (body) => client.request('flocks_createAgent', { body }),
+            get: (agent_id) => client.request('flocks_getAgent', { agent_id }),
+            execute: (agent_id, body) => client.request('flocks_executeAgent', { agent_id, body }),
+            status: (agent_id) => client.request('flocks_getAgentStatus', { agent_id }),
+            cancel: (agent_id, idempotency_key) => client.request('flocks_cancelAgent', { agent_id, body: { idempotency_key } }),
+        },
+        runs: {
+            list: (query = {}) => client.request('flocks_listRuns', query),
+            get: (run_id) => client.request('flocks_getRun', { run_id }),
+        },
+        joinTokens: {
+            exchange: (body) => client.request('flocks_exchangeJoinToken', { body }),
+            create: (ttlSeconds = 600) => client.request('flocks_createJoinToken', { body: { ttl_seconds: ttlSeconds } }),
+        },
+    };
+}

package/dist/foundry-billing.d.ts

@@ -0,0 +1,97 @@
+import type { GenesisClient } from './client.js';
+export declare const foundryBillingOperations: readonly ["foundry_readBillingProfile", "foundry_ensureBillingProfile", "foundry_createNativeCreditCheckout", "foundry_readNativeCreditBalance"];
+export declare const isFoundryBillingOperation: (id: string) => boolean;
+/** One gateway dispatch, no redirect or automatic retry. Native billing always
+ * uses the caller's original human credential; customer/provider selectors are absent. */
+export declare function foundryBillingTransport(options: {
+    operationId: string;
+    input: Record<string, unknown>;
+    headers?: Record<string, string>;
+    routing: string;
+    url: string;
+    credential: () => Promise<string | undefined>;
+    fetch: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<Response>;
+export declare function foundryBilling(client: GenesisClient): {
+    profile: (options?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        schemaVersion: 1;
+        status: "ready" | "pending" | "attention_required";
+        organizationId: string;
+        billingAccountId: string;
+        environmentId: "sandbox";
+        stripeAccountId: string;
+        stripeCustomerId: string | null;
+        livemode: false;
+        canEnsure: boolean;
+    } | {
+        foundry_account_id: string;
+        available_microdollars: number;
+        granted_microdollars: number;
+        reserved_microdollars: number;
+        reserved_overage_microdollars: number;
+        settlement_owner: "foundry";
+        launch_listed: boolean;
+    }>;
+    ensureProfile: (operationKey: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        schemaVersion: 1;
+        status: "ready" | "pending" | "attention_required";
+        organizationId: string;
+        billingAccountId: string;
+        environmentId: "sandbox";
+        stripeAccountId: string;
+        stripeCustomerId: string | null;
+        livemode: false;
+        canEnsure: boolean;
+    } | {
+        intent_id: string;
+        stripe_checkout_session_id: string;
+        checkout_url?: string;
+        status?: "paid" | "processing";
+        stripe_payment_intent_id?: string;
+    }>;
+    checkoutCredits: (purchaseKey: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        schemaVersion: 1;
+        status: "ready" | "pending" | "attention_required";
+        organizationId: string;
+        billingAccountId: string;
+        environmentId: "sandbox";
+        stripeAccountId: string;
+        stripeCustomerId: string | null;
+        livemode: false;
+        canEnsure: boolean;
+    } | {
+        intent_id: string;
+        stripe_checkout_session_id: string;
+        checkout_url?: string;
+        status?: "paid" | "processing";
+        stripe_payment_intent_id?: string;
+    }>;
+    creditBalance: (options?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        schemaVersion: 1;
+        status: "ready" | "pending" | "attention_required";
+        organizationId: string;
+        billingAccountId: string;
+        environmentId: "sandbox";
+        stripeAccountId: string;
+        stripeCustomerId: string | null;
+        livemode: false;
+        canEnsure: boolean;
+    } | {
+        foundry_account_id: string;
+        available_microdollars: number;
+        granted_microdollars: number;
+        reserved_microdollars: number;
+        reserved_overage_microdollars: number;
+        settlement_owner: "foundry";
+        launch_listed: boolean;
+    }>;
+};