@onesi/genesis 0.1.13 → 0.2.1

package/dist/garden.js

@@ -0,0 +1,76 @@
+import { idempotencyHeaders, ifMatchHeaders } from './idempotency.js';
+const query = (q) => Object.fromEntries(Object.entries(q).filter(([, v]) => v !== undefined));
+/** Garden (finance): books, chart of accounts, journal, customers and vendors, invoices, payments, payouts,
+ * reports and the audit trail. Changes to an existing record take the `version` you read (sent as If-Match);
+ * payments, payouts and invoice receipts take an optional idempotency key (a retry returns the first result). */
+export function gardenModule(client) {
+    return {
+        whoami: () => client.request('garden_whoami'),
+        books: {
+            list: (includeArchived) => client.request('garden_listBooks', includeArchived === undefined ? {} : { include_archived: includeArchived }),
+            get: (books) => client.request('garden_getBooks', { books }),
+            create: (body) => client.request('garden_createBooks', { body }),
+            update: (books, version, body) => client.request('garden_updateBooks', { books, body }, { headers: ifMatchHeaders('garden_updateBooks', version) }),
+            archive: (books, version) => client.request('garden_archiveBooks', { books }, { headers: ifMatchHeaders('garden_archiveBooks', version) }),
+            accounts: (books, includeArchived) => client.request('garden_listAccounts', includeArchived === undefined ? { books } : { books, include_archived: includeArchived }),
+            createAccount: (books, body) => client.request('garden_createAccount', { books, body }),
+            journalEntries: (books, filter = {}) => client.request('garden_listJournalEntries', query({ books, ...filter })),
+            createJournalEntry: (books, body) => client.request('garden_createJournalEntry', { books, body }),
+            counterparties: (books, filter = {}) => client.request('garden_listCounterparties', query({ books, ...filter })),
+            createCounterparty: (books, body) => client.request('garden_createCounterparty', { books, body }),
+            invoices: (books, filter = {}) => client.request('garden_listInvoices', query({ books, ...filter })),
+            createInvoice: (books, body) => client.request('garden_createInvoice', { books, body }),
+            payments: (books, filter = {}) => client.request('garden_listPayments', query({ books, ...filter })),
+            /** 201 when it settled, 202 while it waits for authority, 200 when replayed with the same key. */
+            createPayment: (books, body, idempotencyKey) => client.request('garden_createPayment', { books, body }, { headers: idempotencyHeaders('garden_createPayment', idempotencyKey) }),
+            payouts: (books, filter = {}) => client.request('garden_listPayouts', query({ books, ...filter })),
+            /** Needs garden:manage. 201 when it settled, 202 while it waits for authority, 200 when replayed with the same key. */
+            createPayout: (books, body, idempotencyKey) => client.request('garden_createPayout', { books, body }, { headers: idempotencyHeaders('garden_createPayout', idempotencyKey) }),
+            /** Oldest first from `after` (response `next_after`), or newest first with `order: 'desc'` from `before` (response `next_before`). */
+            events: (books, page = {}) => client.request('garden_listEvents', query({ books, ...page })),
+            verifyEvents: (books) => client.request('garden_verifyEvents', { books }),
+        },
+        reports: {
+            trialBalance: (books, asOf) => client.request('garden_getTrialBalance', query({ books, as_of: asOf })),
+            balanceSheet: (books, asOf) => client.request('garden_getBalanceSheet', query({ books, as_of: asOf })),
+            incomeStatement: (books, from, to) => client.request('garden_getIncomeStatement', { books, from, to }),
+            arAging: (books, asOf) => client.request('garden_getArAging', query({ books, as_of: asOf })),
+        },
+        accounts: {
+            get: (account) => client.request('garden_getAccount', { account }),
+            update: (account, version, body) => client.request('garden_updateAccount', { account, body }, { headers: ifMatchHeaders('garden_updateAccount', version) }),
+        },
+        journalEntries: {
+            get: (entry) => client.request('garden_getJournalEntry', { entry }),
+            update: (entry, version, body) => client.request('garden_updateJournalEntry', { entry, body }, { headers: ifMatchHeaders('garden_updateJournalEntry', version) }),
+            discard: (entry, version) => client.request('garden_discardJournalEntry', { entry }, { headers: ifMatchHeaders('garden_discardJournalEntry', version) }),
+            post: (entry, version) => client.request('garden_postJournalEntry', { entry }, { headers: ifMatchHeaders('garden_postJournalEntry', version) }),
+            reverse: (entry, body = {}) => client.request('garden_reverseJournalEntry', { entry, body }),
+        },
+        counterparties: {
+            get: (counterparty) => client.request('garden_getCounterparty', { counterparty }),
+            update: (counterparty, version, body) => client.request('garden_updateCounterparty', { counterparty, body }, { headers: ifMatchHeaders('garden_updateCounterparty', version) }),
+        },
+        invoices: {
+            get: (invoice) => client.request('garden_getInvoice', { invoice }),
+            update: (invoice, version, body) => client.request('garden_updateInvoice', { invoice, body }, { headers: ifMatchHeaders('garden_updateInvoice', version) }),
+            finalize: (invoice, version) => client.request('garden_finalizeInvoice', { invoice }, { headers: ifMatchHeaders('garden_finalizeInvoice', version) }),
+            void: (invoice, version, body = {}) => client.request('garden_voidInvoice', { invoice, body }, { headers: ifMatchHeaders('garden_voidInvoice', version) }),
+            markUncollectible: (invoice, version, body = {}) => client.request('garden_markInvoiceUncollectible', { invoice, body }, { headers: ifMatchHeaders('garden_markInvoiceUncollectible', version) }),
+            /** 201 when recorded, 200 when replayed with the same key. */
+            recordPayment: (invoice, body, idempotencyKey) => client.request('garden_recordInvoicePayment', { invoice, body }, { headers: idempotencyHeaders('garden_recordInvoicePayment', idempotencyKey) }),
+        },
+        payments: {
+            get: (payment) => client.request('garden_getPayment', { payment }),
+            /** As the principal Auto escalated to: 200 when it settled or failed, 202 while it still waits. */
+            authorize: (payment) => client.request('garden_authorizePayment', { payment }),
+            cancel: (payment, body = {}) => client.request('garden_cancelPayment', { payment, body }),
+        },
+        /** Payout authorize and cancel need garden:manage. */
+        payouts: {
+            get: (payout) => client.request('garden_getPayout', { payout }),
+            authorize: (payout) => client.request('garden_authorizePayout', { payout }),
+            cancel: (payout, body = {}) => client.request('garden_cancelPayout', { payout, body }),
+        },
+    };
+}

package/dist/gateway.d.ts

@@ -0,0 +1,365 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** Reads the gateway answers itself (status, caller, errors, spec, usage). Gateway-only: there is no direct upstream. */
+export declare function gatewayModule(client: GenesisClient): {
+    /** Live state of each Genesis service (public). */
+    status: () => Promise<{
+        object: "gateway_status";
+        checked_at: string;
+        cache_ttl_seconds: number;
+        services: {
+            service: string;
+            state: "up" | "degraded" | "down" | "unknown" | "disabled";
+            http_status?: number;
+            latency_ms?: number;
+            reason?: string;
+        }[];
+    }>;
+    /** The verified caller as the gateway sees it: kind, org, principal, scopes, selected context. */
+    whoami: () => Promise<{
+        object: "principal";
+        kind: "api_key" | "m2m_token" | "bridge_session";
+        org: string;
+        principal: string;
+        scopes: string[];
+        selected_context?: {
+            organization_id?: string;
+            project_id?: string | null;
+            workspace_id?: string | null;
+            platform_id?: string;
+            environment?: string;
+        };
+    }>;
+    /** Your organization's usage, or one service's detail with `service`. Login session with genesis.usage.read. */
+    usage: (service?: string) => Promise<{
+        object: string;
+        org_id: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    /** Every error code the gateway emits (public). */
+    errors: () => Promise<{
+        object: "list";
+        docs_url: string;
+        data: {
+            code: string;
+            status: number;
+            type: string;
+            description: string;
+        }[];
+    }>;
+    /** The OpenAPI document this gateway serves (public). */
+    openapi: () => Promise<{
+        [key: string]: unknown;
+    }>;
+    /** Auth's public discovery documents, passed through unchanged (public). `issuer` stays https://auth.life.one. */
+    auth: {
+        /** OpenID Connect discovery document (`/.well-known/openid-configuration`). */
+        openidConfiguration: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        /** JSON Web Key Set that verifies Auth-issued tokens (`/.well-known/jwks.json`). */
+        jwks: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        /** One account discovery document (`/.well-known/lifeid`). */
+        lifeid: () => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+};
+/** Your own organization's usage and billing reads. Login session only; `org` must be the session's organization. */
+export declare function orgsModule(client: GenesisClient): {
+    usage: (org: string) => Promise<{
+        object: string;
+        org_id: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    observations: (org: string, days?: 7 | 30) => Promise<{
+        object: string;
+        org_id: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    billing: (org: string) => Promise<{
+        object: string;
+        org_id: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    paymentMethods: (org: string) => Promise<{
+        object: "org_payment_methods";
+        org_id: string;
+        has_more: boolean;
+        data: {
+            type: string;
+            card_brand: string | null;
+            last4: string | null;
+            exp_month: number | null;
+            exp_year: number | null;
+            default: boolean;
+        }[];
+    }>;
+    service: (org: string, service: string) => Promise<{
+        object: string;
+        org_id: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+};
+/**
+ * Your organization's billing: account, contacts, tax IDs, activity, quotas and quota requests, the Minds account,
+ * invoices, the raw usage report and the public service catalog. A login session, or an org API key bound to `org`
+ * holding genesis.billing.read (reads), genesis.billing.manage (writes) or genesis.usage.read (usage report).
+ * Writes need a stable idempotency key; reuse it to replay instead of acting twice. Nothing here pays or charges.
+ */
+export declare function billingModule(client: GenesisClient): {
+    account: {
+        get: (org: string) => Promise<{
+            object: "billing_account";
+            org_id: string;
+            environment: "sandbox" | "live";
+            status: "not_created" | "active" | "customer_deleted";
+            legal_name?: string | null;
+            email?: string | null;
+            phone?: string | null;
+            address?: import("./index.js").components["schemas"]["Gateway.BillingAddress"] | null;
+            currency?: string;
+            invoice?: {
+                po_number?: string | null;
+                memo?: string | null;
+            };
+            stripe?: {
+                account_id?: string;
+                customer_id?: string | null;
+                livemode?: boolean;
+            };
+            created_at?: string | null;
+            updated_at?: string | null;
+        }>;
+        update: (org: string, body: In<"gateway_updateBillingAccount">["body"], idempotencyKey: string) => Promise<{
+            object: "billing_account";
+            org_id: string;
+            environment: "sandbox" | "live";
+            status: "not_created" | "active" | "customer_deleted";
+            legal_name?: string | null;
+            email?: string | null;
+            phone?: string | null;
+            address?: import("./index.js").components["schemas"]["Gateway.BillingAddress"] | null;
+            currency?: string;
+            invoice?: {
+                po_number?: string | null;
+                memo?: string | null;
+            };
+            stripe?: {
+                account_id?: string;
+                customer_id?: string | null;
+                livemode?: boolean;
+            };
+            created_at?: string | null;
+            updated_at?: string | null;
+        }>;
+        activity: (org: string) => Promise<{
+            object: "list";
+            data: {
+                object: "billing_activity";
+                id: string;
+                at: string;
+                actor: string;
+                surface: string;
+                action: string;
+                target?: string | null;
+                changed?: string[];
+                request_id?: string | null;
+                stripe_request_id?: string | null;
+            }[];
+        }>;
+    };
+    contacts: {
+        list: (org: string) => Promise<{
+            object: "list";
+            data: import("./index.js").components["schemas"]["Gateway.BillingContact"][];
+        }>;
+        create: (org: string, body: In<"gateway_createBillingContact">["body"], idempotencyKey: string) => Promise<{
+            object: "billing_contact";
+            id: string;
+            email: string;
+            name?: string | null;
+            created_at?: string;
+        }>;
+        delete: (org: string, contactId: string, idempotencyKey: string) => Promise<{
+            object: "billing_contact" | "billing_tax_id";
+            id: string;
+            deleted: true;
+        }>;
+    };
+    taxIds: {
+        list: (org: string) => Promise<{
+            object: "list";
+            data: import("./index.js").components["schemas"]["Gateway.BillingTaxId"][];
+        }>;
+        create: (org: string, body: In<"gateway_createBillingTaxId">["body"], idempotencyKey: string) => Promise<{
+            object: "billing_tax_id";
+            id: string;
+            type: string;
+            value: string;
+            country?: string | null;
+            verification?: {
+                status?: string;
+                verified_name?: string | null;
+            } | null;
+        }>;
+        delete: (org: string, taxId: string, idempotencyKey: string) => Promise<{
+            object: "billing_contact" | "billing_tax_id";
+            id: string;
+            deleted: true;
+        }>;
+    };
+    quotas: {
+        get: (org: string) => Promise<{
+            object: "org_quotas";
+            org_id: string;
+            coverage_rule?: string;
+            pools: ({
+                pool?: string;
+                label?: string;
+                products?: string[];
+                tier?: {
+                    [key: string]: unknown;
+                };
+                org?: {
+                    [key: string]: unknown;
+                };
+                user?: {
+                    [key: string]: unknown;
+                };
+                how_to_raise?: {
+                    [key: string]: unknown;
+                };
+                placeholder_limits?: boolean;
+            } & {
+                [key: string]: unknown;
+            })[];
+        }>;
+        requests: {
+            list: (org: string) => Promise<{
+                object: "list";
+                data: import("./index.js").components["schemas"]["Gateway.QuotaRequest"][];
+            }>;
+            create: (org: string, body: In<"gateway_createQuotaRequest">["body"], idempotencyKey: string) => Promise<{
+                object?: "quota_increase_request";
+                id: number;
+                pool: string;
+                org_id: string;
+                requested_by?: string;
+                scope: "org" | "user";
+                max_concurrent_units?: number | null;
+                max_monthly_hours?: number | null;
+                justification?: string;
+                status: string;
+                decided_by?: string | null;
+                decision_note?: string | null;
+            }>;
+        };
+    };
+    minds: {
+        account: (org: string) => Promise<{
+            object: string;
+            org_id: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    invoices: (org: string, query?: {
+        service?: string;
+        limit?: number;
+    }) => Promise<{
+        object: "list";
+        org_id: string;
+        service?: string | null;
+        has_more: boolean;
+        data: {
+            [key: string]: unknown;
+        }[];
+    }>;
+    usage: {
+        /** Raw metered quantities over a window (ISO-8601 UTC `from`/`to`, default the last 30 days). */
+        report: (org: string, query?: {
+            service?: string;
+            from?: string;
+            to?: string;
+        }) => Promise<{
+            object: "usage";
+            org_id: string;
+            service?: string | null;
+            period: {
+                from?: string;
+                to?: string;
+            };
+            generated_at: string;
+            metered: boolean;
+            data: {
+                service?: string;
+                meter?: string;
+                unit?: string | null;
+                quantity?: string;
+                event_count?: number;
+                first_occurred_at?: string;
+                last_occurred_at?: string;
+            }[];
+        }>;
+        /** Allowance consumption, one line per service (same as genesis.orgs.usage). */
+        get: (org: string) => Promise<{
+            object: string;
+            org_id: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        observations: (org: string, days?: 7 | 30) => Promise<{
+            object: string;
+            org_id: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    summary: (org: string) => Promise<{
+        object: string;
+        org_id: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    paymentMethods: (org: string) => Promise<{
+        object: "org_payment_methods";
+        org_id: string;
+        has_more: boolean;
+        data: {
+            type: string;
+            card_brand: string | null;
+            last4: string | null;
+            exp_month: number | null;
+            exp_year: number | null;
+            default: boolean;
+        }[];
+    }>;
+    service: (org: string, service: string) => Promise<{
+        object: string;
+        org_id: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    /** The metered service catalog (public, no credential). */
+    catalog: () => Promise<{
+        object: "list";
+        data: {
+            service: string;
+            display_name: string;
+            meter_status: string;
+            meters: {
+                event_name?: string;
+                code_meter?: string | null;
+                unit?: string;
+            }[];
+        }[];
+    }>;
+};

package/dist/gateway.js

@@ -0,0 +1,82 @@
+import { idempotencyHeaders } from './idempotency.js';
+/** Reads the gateway answers itself (status, caller, errors, spec, usage). Gateway-only: there is no direct upstream. */
+export function gatewayModule(client) {
+    return {
+        /** Live state of each Genesis service (public). */
+        status: () => client.request('gateway_getStatus'),
+        /** The verified caller as the gateway sees it: kind, org, principal, scopes, selected context. */
+        whoami: () => client.request('gateway_whoami'),
+        /** Your organization's usage, or one service's detail with `service`. Login session with genesis.usage.read. */
+        usage: (service) => client.request('gateway_getUsage', service === undefined ? {} : { service }),
+        /** Every error code the gateway emits (public). */
+        errors: () => client.request('gateway_listErrors'),
+        /** The OpenAPI document this gateway serves (public). */
+        openapi: () => client.request('gateway_getOpenApi'),
+        /** Auth's public discovery documents, passed through unchanged (public). `issuer` stays https://auth.life.one. */
+        auth: {
+            /** OpenID Connect discovery document (`/.well-known/openid-configuration`). */
+            openidConfiguration: () => client.request('gateway_getAuthOpenIdConfiguration'),
+            /** JSON Web Key Set that verifies Auth-issued tokens (`/.well-known/jwks.json`). */
+            jwks: () => client.request('gateway_getAuthJwks'),
+            /** One account discovery document (`/.well-known/lifeid`). */
+            lifeid: () => client.request('gateway_getAuthLifeId'),
+        },
+    };
+}
+/** Your own organization's usage and billing reads. Login session only; `org` must be the session's organization. */
+export function orgsModule(client) {
+    return {
+        usage: (org) => client.request('gateway_getOrgUsage', { org }),
+        observations: (org, days) => client.request('gateway_getOrgUsageObservations', { org, ...(days === undefined ? {} : { days }) }),
+        billing: (org) => client.request('gateway_getOrgBilling', { org }),
+        paymentMethods: (org) => client.request('gateway_listOrgPaymentMethods', { org }),
+        service: (org, service) => client.request('gateway_getOrgServiceBilling', { org, service }),
+    };
+}
+/**
+ * Your organization's billing: account, contacts, tax IDs, activity, quotas and quota requests, the Minds account,
+ * invoices, the raw usage report and the public service catalog. A login session, or an org API key bound to `org`
+ * holding genesis.billing.read (reads), genesis.billing.manage (writes) or genesis.usage.read (usage report).
+ * Writes need a stable idempotency key; reuse it to replay instead of acting twice. Nothing here pays or charges.
+ */
+export function billingModule(client) {
+    const write = (id, input, idempotencyKey) => client.request(id, input, { headers: idempotencyHeaders(id, idempotencyKey) });
+    return {
+        account: {
+            get: (org) => client.request('gateway_getBillingAccount', { org }),
+            update: (org, body, idempotencyKey) => write('gateway_updateBillingAccount', { org, body }, idempotencyKey),
+            activity: (org) => client.request('gateway_listBillingActivity', { org }),
+        },
+        contacts: {
+            list: (org) => client.request('gateway_listBillingContacts', { org }),
+            create: (org, body, idempotencyKey) => write('gateway_createBillingContact', { org, body }, idempotencyKey),
+            delete: (org, contactId, idempotencyKey) => write('gateway_deleteBillingContact', { org, contact_id: contactId }, idempotencyKey),
+        },
+        taxIds: {
+            list: (org) => client.request('gateway_listBillingTaxIds', { org }),
+            create: (org, body, idempotencyKey) => write('gateway_createBillingTaxId', { org, body }, idempotencyKey),
+            delete: (org, taxId, idempotencyKey) => write('gateway_deleteBillingTaxId', { org, tax_id: taxId }, idempotencyKey),
+        },
+        quotas: {
+            get: (org) => client.request('gateway_getOrgQuotas', { org }),
+            requests: {
+                list: (org) => client.request('gateway_listQuotaRequests', { org }),
+                create: (org, body, idempotencyKey) => write('gateway_createQuotaRequest', { org, body }, idempotencyKey),
+            },
+        },
+        minds: { account: (org) => client.request('gateway_getMindsAccount', { org }) },
+        invoices: (org, query = {}) => client.request('gateway_listOrgInvoices', { org, ...query }),
+        usage: {
+            /** Raw metered quantities over a window (ISO-8601 UTC `from`/`to`, default the last 30 days). */
+            report: (org, query = {}) => client.request('gateway_getOrgUsageReport', { org, ...query }),
+            /** Allowance consumption, one line per service (same as genesis.orgs.usage). */
+            get: (org) => client.request('gateway_getOrgUsage', { org }),
+            observations: (org, days) => client.request('gateway_getOrgUsageObservations', { org, ...(days === undefined ? {} : { days }) }),
+        },
+        summary: (org) => client.request('gateway_getOrgBilling', { org }),
+        paymentMethods: (org) => client.request('gateway_listOrgPaymentMethods', { org }),
+        service: (org, service) => client.request('gateway_getOrgServiceBilling', { org, service }),
+        /** The metered service catalog (public, no credential). */
+        catalog: () => client.request('gateway_listBillingServices'),
+    };
+}

package/dist/gears.d.ts

@@ -1,7 +1,7 @@
 import type { GenesisClient } from './client.js';
 import type { OperationInput as In } from './types.js';
-/** Gears durable workflows: exactly the gateway-admitted reads, register, start and signal.
- * Writes take an optional idempotency key; with one, a retry returns the original result. */
+/** Gears durable workflows: exactly the gateway-admitted reads, register, start, signal and run lifecycle verbs.
+ * Writes the service keys by Idempotency-Key take an optional key; with one, a retry returns the original result. */
 export declare function gearsModule(client: GenesisClient): {
     workflows: {
         list: () => Promise<{
@@ -71,7 +71,126 @@ export declare function gearsModule(client: GenesisClient): {
             stationSessionId?: string | null;
         }>;
         signal: (id: string, body: In<"gears_signalRun">["body"], idempotencyKey?: string) => Promise<Record<string, never>>;
+        cancel: (id: string, idempotencyKey?: string) => Promise<{
+            id: string;
+            scope?: import("./index.js").components["schemas"]["Gears.Scope"];
+            workflowId: string;
+            workflowVersion: string;
+            status: "Running" | "Succeeded" | "Failed" | "Cancelled";
+            actorId: string;
+            inputRef: string;
+            contextFrameId?: string | null;
+            stationSessionId?: string | null;
+        }>;
+        resume: (id: string) => Promise<{
+            id: string;
+            scope?: import("./index.js").components["schemas"]["Gears.Scope"];
+            workflowId: string;
+            workflowVersion: string;
+            status: "Running" | "Succeeded" | "Failed" | "Cancelled";
+            actorId: string;
+            inputRef: string;
+            contextFrameId?: string | null;
+            stationSessionId?: string | null;
+        }>;
+        complete: (id: string, body: In<"gears_completeRun">["body"], idempotencyKey?: string) => Promise<{
+            id: string;
+            scope?: import("./index.js").components["schemas"]["Gears.Scope"];
+            workflowId: string;
+            workflowVersion: string;
+            status: "Running" | "Succeeded" | "Failed" | "Cancelled";
+            actorId: string;
+            inputRef: string;
+            contextFrameId?: string | null;
+            stationSessionId?: string | null;
+        }>;
+        fail: (id: string, body: In<"gears_failRun">["body"], idempotencyKey?: string) => Promise<{
+            id: string;
+            scope?: import("./index.js").components["schemas"]["Gears.Scope"];
+            workflowId: string;
+            workflowVersion: string;
+            status: "Running" | "Succeeded" | "Failed" | "Cancelled";
+            actorId: string;
+            inputRef: string;
+            contextFrameId?: string | null;
+            stationSessionId?: string | null;
+        }>;
+        timers: {
+            start: (id: string, body: In<"gears_startTimer">["body"], idempotencyKey?: string) => Promise<{
+                timerId: string;
+                runId: string;
+                actorId: string;
+                durationMs: number;
+                timerRef: string;
+                status: string;
+            }>;
+        };
+        retries: {
+            schedule: (id: string, body: In<"gears_scheduleRetry">["body"], idempotencyKey?: string) => Promise<{
+                runId: string;
+                stepId: string;
+                attempt: number;
+                maxAttempts: number;
+                backoffMs: number;
+                reasonRef: string;
+                actorId: string;
+                retryRef: string;
+                status: string;
+                journalSequence: number;
+            }>;
+            execute: (id: string, stepId: string, attempt: number, body: In<"gears_executeRetry">["body"], idempotencyKey?: string) => Promise<Record<string, never>>;
+        };
+        stepRefs: {
+            record: (id: string, body: In<"gears_recordStepRefs">["body"], idempotencyKey?: string) => Promise<Record<string, never>>;
+        };
+        children: {
+            start: (id: string, body: In<"gears_startChildRun">["body"]) => Promise<{
+                parentRunId: string;
+                childRunId: string;
+                workflowId: string;
+                workflowVersion: string;
+                actorId: string;
+                inputRef: string;
+                closePolicy: import("./index.js").components["schemas"]["Gears.ChildClosePolicy"];
+                childRunRef: string;
+                childExecutionRef: string;
+                status: string;
+            }>;
+        };
+        compensations: {
+            register: (id: string, body: In<"gears_registerCompensation">["body"]) => Promise<{
+                runId: string;
+                name: string;
+                actionRef: string;
+                payloadRef: string;
+                actorId: string;
+                stackIndex: number;
+                compensationRef: string;
+                status: string;
+            }>;
+            rollback: (id: string, body: In<"gears_rollbackCompensations">["body"]) => Promise<{
+                runId: string;
+                actorId: string;
+                results: {
+                    name: string;
+                    stackIndex: number;
+                    success: boolean;
+                    attempts: number;
+                    compensationRef: string;
+                    error?: string | null;
+                }[];
+            }>;
+        };
     };
+    runtime: () => Promise<{
+        engineId?: string;
+        runtimeType?: string;
+        configType?: string;
+        executionContextType?: string;
+        workflowHandlerTrait?: string;
+        defaultDispatchMode?: string;
+        durablePrimitives?: string[];
+    }>;
     records: () => Promise<{
         meterRecords?: {
             product?: string;