@sovaria/sdk 0.0.0-stage → 0.5.0

package/dist/generated.d.ts

@@ -0,0 +1,2462 @@
+import type { JsonObject, JsonValue, RequestOptions } from './index.js';
+type Request = <T>(method: string, path: string, options?: RequestOptions) => Promise<T>;
+type Scope = () => {
+    orgId?: string;
+    projectId?: string;
+    envId?: string;
+} | undefined;
+/** Every Sovaria API operation, grouped by module. */
+export declare function createGeneratedApi(request: Request, scope: Scope): {
+    ai: {
+        /** Model-gateway routes, the models they may use, plan limits and cache size. `GET /api/v1/sovariq/gateway` */
+        gatewayOverview: () => Promise<JsonValue>;
+        /** Create or change a route: models in order (fallbacks), retry_on, cache {enabled, ttl_s}, access, daily_requests_per_user. `PUT /api/v1/sovariq/gateway/routes/{name}` */
+        saveGatewayRoute: (args: {
+            name: string;
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Delete a route (refused while an agent uses it). `DELETE /api/v1/sovariq/gateway/routes/{name}` */
+        deleteGatewayRoute: (args: {
+            name: string;
+        }) => Promise<JsonValue>;
+        /** One completion on a route: the first model that answers (fallbacks), or the cache. `POST /api/v1/sovariq/gateway/{route}/complete` */
+        gatewayComplete: (args: {
+            route: string;
+            messages: JsonValue;
+            system?: JsonValue;
+            maxTokens?: JsonValue;
+            cache?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Requests, errors, fallbacks, cache hits, tokens and latency per model and route. `GET /api/v1/sovariq/gateway/usage` */
+        gatewayUsage: (args?: {
+            days?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Drop every cached model response of the project. `POST /api/v1/sovariq/gateway/cache/clear` */
+        clearGatewayCache: () => Promise<JsonValue>;
+        /** An agent's published version and kept versions. `GET /api/v1/sovariq/agents/{agent_id}/versions` */
+        listAgentVersions: (args: {
+            agentId: string;
+        }) => Promise<JsonValue>;
+        /** Publish the agent's draft as its next version. `POST /api/v1/sovariq/agents/{agent_id}/versions` */
+        publishAgentVersion: (args: {
+            agentId: string;
+            note?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One version's definition (secrets hidden). `GET /api/v1/sovariq/agents/{agent_id}/versions/{version}` */
+        getAgentVersion: (args: {
+            agentId: string;
+            version: string;
+        }) => Promise<JsonValue>;
+        /** What changed between two versions (or a version and the draft). `GET /api/v1/sovariq/agents/{agent_id}/versions/compare` */
+        compareAgentVersions: (args: {
+            agentId: string;
+            a: JsonValue;
+            b?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Republish an older version as a new version and make it the draft. `POST /api/v1/sovariq/agents/{agent_id}/versions/{version}/rollback` */
+        rollbackAgentVersion: (args: {
+            agentId: string;
+            version: string;
+            note?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    analytics: {
+        /** DAU, WAU, MAU, events, new users, top events, platforms and countries over the last days (capped by analytics.retention_days). `GET /api/v1/analytics/overview` */
+        overview: (args?: {
+            days?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Event names with counts over the last days. `GET /api/v1/analytics/events` */
+        listEvents: (args?: {
+            days?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Daily count and distinct users of one event, and its common properties. `GET /api/v1/analytics/events/{name}/trend` */
+        eventTrend: (args: {
+            name: string;
+            days?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Ordered funnel: users who did each step after the previous one within window_hours of step 1 (steps: [{name, where?}]). `POST /api/v1/analytics/funnel` */
+        funnel: (args: {
+            steps: JsonValue;
+            windowHours?: JsonValue;
+            days?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Retention cohorts by first activity (or start_event), share active (or doing return_event) in each later week or day. `GET /api/v1/analytics/retention` */
+        retention: (args?: {
+            startEvent?: JsonValue;
+            returnEvent?: JsonValue;
+            period?: JsonValue;
+            periods?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Recently seen app users with their properties (q: prefix of user key or id). `GET /api/v1/analytics/users` */
+        listUsers: (args?: {
+            q?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One app user: profile, consent and their latest events. `GET /api/v1/analytics/users/{user_key}` */
+        getUser: (args: {
+            userKey: string;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Erase one app user's analytics (events, properties, activity) and record that they opted out. `DELETE /api/v1/analytics/users/{user_key}` */
+        eraseUser: (args: {
+            userKey: string;
+        }) => Promise<JsonValue>;
+        /** Newest events received (debug view), optionally since an ISO time. `GET /api/v1/analytics/live` */
+        live: (args?: {
+            since?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Analytics events accepted and dropped this month, and the plan's limits. `GET /api/v1/analytics/usage` */
+        usage: () => Promise<JsonValue>;
+        /** Project analytics settings (require consent) and whether staff turned analytics off. `GET /api/v1/analytics/settings` */
+        getSettings: () => Promise<JsonValue>;
+        /** Require consent: only app users who said yes (PUT /analytics/v1/consent) are recorded. `PUT /api/v1/analytics/settings` */
+        putSettings: (args: {
+            requireConsent: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    attestation: {
+        /** App attestation settings, credentials (metadata only), debug tokens and the last 7 days. `GET /api/v1/projects/{project_id}/attestation` */
+        getConfig: (args?: {
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Set mode (off | monitor | enforce), tokenTtlSeconds, providers, playIntegrity, appAttest. `PUT /api/v1/projects/{project_id}/attestation` */
+        updateConfig: (args: {
+            projectId?: string;
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Google service account for Play Integrity (encrypted, write-only). `PUT /api/v1/projects/{project_id}/attestation/credentials/google` */
+        setGoogleCredentials: (args: {
+            projectId?: string;
+            serviceAccount: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Apple key with DeviceCheck enabled (encrypted, write-only). `PUT /api/v1/projects/{project_id}/attestation/credentials/apple` */
+        setAppleCredentials: (args: {
+            projectId?: string;
+            p8: JsonValue;
+            keyId: JsonValue;
+            teamId: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Remove the google or apple attestation credentials. `DELETE /api/v1/projects/{project_id}/attestation/credentials/{which}` */
+        deleteCredentials: (args: {
+            projectId?: string;
+            which: string;
+        }) => Promise<JsonValue>;
+        /** Create a debug token for simulators and CI (shown once). `POST /api/v1/projects/{project_id}/attestation/debug-tokens` */
+        createDebugToken: (args?: {
+            projectId?: string;
+            name?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete a debug token. `DELETE /api/v1/projects/{project_id}/attestation/debug-tokens/{token_id}` */
+        deleteDebugToken: (args: {
+            projectId?: string;
+            tokenId: string;
+        }) => Promise<JsonValue>;
+        /** One-time challenge to bind attestation evidence to (anon key). `POST /api/v1/attest/challenge` */
+        challenge: () => Promise<JsonValue>;
+        /** Exchange Play Integrity / App Attest / DeviceCheck / debug evidence for an attestation token. `POST /api/v1/attest/exchange` */
+        exchange: (args: {
+            provider: JsonValue;
+            appId?: JsonValue;
+            challenge?: JsonValue;
+            token?: JsonValue;
+            keyId?: JsonValue;
+            attestation?: JsonValue;
+            assertion?: JsonValue;
+            development?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    auth: {
+        /** Confirm an email verification token. `POST /api/v1/auth/verify-email/confirm` */
+        confirmVerificationEmail: (args: {
+            token: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `DELETE /api/v1/auth/mfa` */
+        disableMfa: (args: {
+            totpCode: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/auth/mfa/enroll` */
+        enrollMfa: () => Promise<JsonValue>;
+        /** `GET /api/v1/auth/mfa/status` */
+        getMfaStatus: () => Promise<JsonValue>;
+        /** `GET /api/v1/auth/providers/config` */
+        getProvidersConfig: () => Promise<JsonValue>;
+        /** `GET /api/v1/auth/sessions/config` */
+        getSessionsConfig: () => Promise<JsonValue>;
+        /** `GET /api/v1/auth/product-users` */
+        listConsoleProductUsers: () => Promise<JsonValue>;
+        /** `GET /api/v1/auth/sessions` */
+        listSessions: () => Promise<JsonValue>;
+        /** `POST /api/v1/auth/sessions/revoke-others` */
+        revokeOtherSessions: () => Promise<JsonValue>;
+        /** `DELETE /api/v1/auth/sessions/{session_id}` */
+        revokeSession: (args: {
+            sessionId: string;
+        }) => Promise<JsonValue>;
+        /** Trigger a verification email for the authenticated user. `POST /api/v1/auth/verify-email/send` */
+        sendVerificationEmail: () => Promise<JsonValue>;
+        /** `PUT /api/v1/auth/providers/config` */
+        updateProvidersConfig: (args: {
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** `PUT /api/v1/auth/sessions/config` */
+        updateSessionsConfig: (args: {
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Devices the signed-in user is signed in on (current = this one). `GET /api/v1/auth/devices` */
+        listDevices: () => Promise<JsonValue>;
+        /** Sign one device out: its sessions end and push tokens are removed. `DELETE /api/v1/auth/devices/{device_id}` */
+        signOutDevice: (args: {
+            deviceId: string;
+        }) => Promise<JsonValue>;
+        /** Registration options for a new passkey for the signed-in user. `POST /api/v1/auth/passkeys/register/start` */
+        passkeyRegisterStart: (args?: {
+            name?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Save a passkey from the authenticator's WebAuthn JSON. `POST /api/v1/auth/passkeys/register/finish` */
+        passkeyRegisterFinish: (args: {
+            credential: JsonValue;
+            name?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Passkey sign-in options: challenge_id and options. `POST /api/v1/auth/passkeys/authenticate/start` */
+        passkeyAuthenticateStart: (args?: {
+            userId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Verify a signed passkey challenge and return a session. `POST /api/v1/auth/passkeys/authenticate/finish` */
+        passkeyAuthenticateFinish: (args: {
+            challengeId: JsonValue;
+            credential: JsonValue;
+        }) => Promise<JsonValue>;
+        /** The signed-in user's passkeys. `GET /api/v1/auth/passkeys` */
+        listPasskeys: () => Promise<JsonValue>;
+        /** Remove one of the signed-in user's passkeys. `DELETE /api/v1/auth/passkeys/{passkey_id}` */
+        deletePasskey: (args: {
+            passkeyId: string;
+        }) => Promise<JsonValue>;
+    };
+    billing: {
+        /** `POST /api/v1/invoices/{org_id}/build` */
+        buildInvoice: (args?: {
+            orgId?: string;
+            period?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/accounts/{account_id}/cancel` */
+        cancelAccount: (args: {
+            accountId: string;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/billing/checkout` */
+        checkout: (args: {
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/accounts/{account_id}` */
+        getAccount: (args: {
+            accountId: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/billing/accounts/{account_id}/overage` */
+        getAccountOverage: (args: {
+            accountId: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/billing/accounts/{account_id}/overage-prefs` */
+        getAccountOveragePrefs: (args: {
+            accountId: string;
+        }) => Promise<JsonValue>;
+        /** The org's overage switches (one setting for the whole org) `GET /api/v1/billing/orgs/{org_id}/overage-prefs` */
+        getOrgOveragePrefs: (args?: {
+            orgId?: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/compute/{org_id}` */
+        getCompute: (args?: {
+            orgId?: string;
+            period?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/billing/fx` */
+        getFx: () => Promise<JsonValue>;
+        /** `GET /api/v1/billing/invoices/open` */
+        getOpenInvoice: () => Promise<JsonValue>;
+        /** `GET /api/v1/billing/overage/{org_id}` */
+        getOverage: (args?: {
+            orgId?: string;
+        }) => Promise<JsonValue>;
+        /** Fetch a billing plan by name. `GET /api/v1/plans/{name}` */
+        getPlan: (args: {
+            name: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/billing/provider` */
+        getProvider: () => Promise<JsonValue>;
+        /** Fetch the active subscription for an organisation. `GET /api/v1/subscriptions/{org_id}` */
+        getSubscription: (args?: {
+            orgId?: string;
+        }) => Promise<JsonValue>;
+        /** Fetch usage counters for an organisation. `GET /api/v1/usage/{org_id}` */
+        getUsage: (args?: {
+            orgId?: string;
+            period?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Fetch historical usage for an organisation. `GET /api/v1/usage/{org_id}/history` */
+        getUsageHistory: (args?: {
+            orgId?: string;
+            months?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/invoices/{org_id}` */
+        listInvoices: (args?: {
+            orgId?: string;
+        }) => Promise<JsonValue>;
+        /** List public billing plans. `GET /api/v1/plans` */
+        listPlans: () => Promise<JsonValue>;
+        /** List subscriptions visible to the authenticated caller. `GET /api/v1/subscriptions` */
+        listSubscriptions: () => Promise<JsonValue>;
+        /** `POST /api/v1/billing/invoices/{org_id}/{period}/pay` */
+        payInvoice: (args: {
+            orgId?: string;
+            period: string;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/billing/razorpay/create-order` */
+        razorpayCreateOrder: (args: {
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/billing/razorpay/verify-payment` */
+        razorpayVerifyPayment: (args: {
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/accounts/{account_id}/resume` */
+        resumeAccount: (args: {
+            accountId: string;
+        }) => Promise<JsonValue>;
+        /** `PUT /api/v1/billing/accounts/{account_id}/overage-prefs` */
+        setAccountOveragePrefs: (args: {
+            accountId: string;
+            services: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Change the org's overage switches (org owners and admins) `PUT /api/v1/billing/orgs/{org_id}/overage-prefs` */
+        setOrgOveragePrefs: (args: {
+            orgId?: string;
+            services: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Add-ons on the billing account: price, paid units, what renews, paid-through date, and the autopay mandate `GET /api/v1/accounts/{account_id}/addons` */
+        listAccountAddons: (args: {
+            accountId: string;
+        }) => Promise<JsonValue>;
+        /** Start paying for more add-on units (prorated to the period end); they count once the payment is verified `POST /api/v1/accounts/{account_id}/addons/{addon_id}/checkout` */
+        addonCheckout: (args: {
+            accountId: string;
+            addonId: string;
+            quantity: JsonValue;
+            projectId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** How many units renew at the period end (0 cancels); paid units keep working until then `PUT /api/v1/accounts/{account_id}/addons/{addon_id}/renewal` */
+        setAddonRenewal: (args: {
+            accountId: string;
+            addonId: string;
+            renewQuantity: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Older switch: lowering schedules at the period end; more units than are paid for answer 402 (use addonCheckout) `POST /api/v1/accounts/{account_id}/addons/{addon_id}` */
+        setAccountAddon: (args: {
+            accountId: string;
+            addonId: string;
+            enabled: JsonValue;
+            quantity?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Renew automatically (true) or end the plan with the paid period (false) `POST /api/v1/accounts/{account_id}/autopay` */
+        setAccountAutopay: (args: {
+            accountId: string;
+            enabled: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Start a ₹1 (refunded) authorisation that saves a card or UPI mandate for automatic renewals `POST /api/v1/accounts/{account_id}/autopay/setup` */
+        autopaySetup: (args: {
+            accountId: string;
+            customerEmail?: JsonValue;
+            name?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Remove the saved mandate; renewals become invoices to pay by hand `DELETE /api/v1/accounts/{account_id}/autopay/mandate` */
+        removeAutopayMandate: (args: {
+            accountId: string;
+        }) => Promise<JsonValue>;
+        /** Add-on prices (USD per month per unit) and the plans each is sold on, as staff set them. `GET /api/v1/plans/addons` */
+        billingListAddonPrices: () => Promise<JsonValue>;
+    };
+    builds: {
+        /** Check an app build Sovariq wrote (title, description, migration {name, up_sql, down_sql}, policies [{id, spl}], functions [{name, runtime, files}], tests [rules test cases]) against the project — nothing changes: the migration is dry-run up, down and up again, rules are simulated, rules tests run with the build's rules. Returns the build id and the report. `POST /api/v1/fn/builds/check` */
+        check: (args: {
+            build: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Recent app builds of the project: title, status (checked, failed, pr_opened), each check's result and the pull request. `GET /api/v1/fn/builds` */
+        list: (args?: {
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One app build: its files (the bundle), the check report and the pull request. `GET /api/v1/fn/builds/{build_id}` */
+        get: (args: {
+            buildId: string;
+        }) => Promise<JsonValue>;
+        /** Check the build again and open it as a pull request on the project's linked GitHub repository (one commit on a new branch; dev.app_build_prs_month). GitHub needs repository access: connect it with repository access or pass a token with repo scope. `POST /api/v1/fn/builds/{build_id}/pull-request` */
+        pullRequest: (args: {
+            buildId: string;
+            token?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Forget an app build (its pull request, if opened, stays on GitHub). `DELETE /api/v1/fn/builds/{build_id}` */
+        delete: (args: {
+            buildId: string;
+        }) => Promise<JsonValue>;
+    };
+    byok: {
+        /** Your organization's own encryption key (Enterprise): whether it's on, the key, its data key version, whether it is usable now, what it covers, and setup (Sovaria's AWS principal and the key policy statement). `GET /api/v1/byok` */
+        get: () => Promise<JsonValue>;
+        /** Use your AWS KMS key (its ARN) for the organization's storage files and backups. Checked end to end first (wrap, unwrap, a file written and read with it). Organization owners. `PUT /api/v1/byok` */
+        set: (args: {
+            provider?: JsonValue;
+            keyRef: JsonValue;
+        }) => Promise<JsonValue>;
+        /** A new data key version under the same KMS key; older versions stay to decrypt what they encrypted. Organization owners. `POST /api/v1/byok/rotate` */
+        rotate: () => Promise<JsonValue>;
+        /** Ask your KMS now whether Sovaria can still use the key. `POST /api/v1/byok/check` */
+        check: () => Promise<JsonValue>;
+        /** Rewrite the organization's existing storage files under its key (in the background; progress in byok.get). Organization owners. `POST /api/v1/byok/reencrypt-storage` */
+        reencryptStorage: () => Promise<JsonValue>;
+    };
+    compliance: {
+        /** Compliance overview for an organization (owners and admins): audit-log check, encryption, backups, access, regions. `GET /api/v1/org/{org_id}/compliance` */
+        overview: (args?: {
+            orgId?: string;
+            projectId?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    crashes: {
+        /** App crash issues of the project (grouped reports from sov.crashes), newest first, filtered by status, release, app environment, platform or text, with a 24-hour trend and the plan's limits. `GET /api/v1/crashes/issues` */
+        listIssues: (args?: {
+            status?: JsonValue;
+            limit?: JsonValue;
+            release?: JsonValue;
+            environment?: JsonValue;
+            platform?: JsonValue;
+            q?: JsonValue;
+            sort?: JsonValue;
+            handled?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One crash issue: sample report (stack, breadcrumbs, device, release) and its last 50 reports. `GET /api/v1/crashes/issues/{fingerprint}` */
+        getIssue: (args: {
+            fingerprint: string;
+        }) => Promise<JsonValue>;
+        /** Mark a crash issue open, resolved (reopens if it happens again) or ignored. `POST /api/v1/crashes/issues/{fingerprint}/status` */
+        setIssueStatus: (args: {
+            fingerprint: string;
+            status: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Crash reports, release-health sessions and debug-file storage used this month, and the plan's limits. `GET /api/v1/crashes/usage` */
+        usage: () => Promise<JsonValue>;
+        /** Crash events over time (hourly up to 2 days, else daily) and the releases, app environments and platforms seen. `GET /api/v1/crashes/trends` */
+        trends: (args?: {
+            days?: JsonValue;
+            release?: JsonValue;
+            environment?: JsonValue;
+            platform?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Release health: sessions, crash-free sessions and users, and adoption per release. `GET /api/v1/crashes/releases` */
+        releases: (args?: {
+            days?: JsonValue;
+            environment?: JsonValue;
+            platform?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Uploaded source maps, ProGuard/R8 mappings and Apple symbols, and the storage used. `GET /api/v1/crashes/debug-files` */
+        listDebugFiles: (args?: {
+            kind?: JsonValue;
+            release?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete one debug file (frames of that release stay as they were stored). `DELETE /api/v1/crashes/debug-files/{file_id}` */
+        deleteDebugFile: (args: {
+            fileId: string;
+        }) => Promise<JsonValue>;
+    };
+    data: {
+        /** Add a column to an existing table. `POST /api/v1/data/rel/column/add` */
+        addColumn: (args: {
+            tableName: JsonValue;
+            columnName: JsonValue;
+            dataType: JsonValue;
+            isNullable?: JsonValue;
+            isUnique?: JsonValue;
+            defaultValue?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Add a foreign-key relation. `POST /api/v1/data/rel/foreign-key/add` */
+        addForeignKey: (args: {
+            tableName: JsonValue;
+            columnName: JsonValue;
+            referencedTable: JsonValue;
+            referencedColumn: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Start a table transaction and receive tx/snapshot IDs. `POST /api/v1/data/rel/transaction/begin` */
+        beginTransaction: () => Promise<JsonValue>;
+        /** Commit a previously opened table transaction. `POST /api/v1/data/rel/transaction/commit` */
+        commitTransaction: (args: {
+            txid: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Drop a column from a table. `POST /api/v1/data/rel/column/drop` */
+        dropColumn: (args: {
+            tableName: JsonValue;
+            columnName: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Drop a foreign-key relation. `POST /api/v1/data/rel/foreign-key/drop` */
+        dropForeignKey: (args: {
+            tableName: JsonValue;
+            columnName: JsonValue;
+            referencedTable: JsonValue;
+            referencedColumn: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Drop a relational table. `POST /api/v1/data/rel/drop` */
+        dropTable: (args: {
+            tableName: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/data/rel/transaction/rollback` */
+        rollbackTransaction: (args: {
+            txid: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Tables that keep history (versions, oldest, retention) and the plan's db.history_* limits. `GET /api/v1/data/rel/history` */
+        tableHistory: () => Promise<JsonValue>;
+        /** Turn a table's history on (every row version kept; read with sov_as_of(NULL::table, time)) or off (versions dropped). `POST /api/v1/data/rel/history` */
+        setTableHistory: (args: {
+            tableName: JsonValue;
+            enabled: JsonValue;
+            keepDays?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** The schema as one short line per table: columns with types, keys, →references, allowed values, indexes and owner-only rows. tables (comma-separated) expands only those in a big schema; since=<version> answers unchanged when nothing changed. `GET /api/v1/data/rel/schema/digest` */
+        schemaDigest: (args?: {
+            tables?: JsonValue;
+            maxChars?: JsonValue;
+            since?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Create or extend tables from one declarative plan ([{name, columns, patterns, unique, indexes}]; columns as objects or short form like "status text!='draft' in(draft|live)" or "customer_id →customers cascade"). Checked first (422 lists every problem, nothing changes), then applied as one reversible migration and verified. dry_run returns the SQL without applying. `POST /api/v1/data/rel/schema/plan` */
+        applySchemaPlan: (args: {
+            tables: JsonValue;
+            dryRun?: JsonValue;
+            name?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Apply a migration and record it in the project's history, in one transaction (all or nothing). down_sql makes it reversible; the same version with the same SQL again does nothing, with different SQL it is refused (409). `POST /api/v1/data/rel/migrations/apply` */
+        applyMigration: (args: {
+            name: JsonValue;
+            upSql: JsonValue;
+            downSql?: JsonValue;
+            version?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Run a migration inside a transaction and roll it back: whether it would apply. Nothing is kept. `POST /api/v1/data/rel/migrations/dry-run` */
+        dryRunMigration: (args: {
+            name: JsonValue;
+            upSql: JsonValue;
+            downSql?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Check several migrations ([{name, up_sql}], up to 500 and 5 MB of SQL) in order inside one transaction that is rolled back, so later ones see what earlier ones create. Returns status dry_run_ok, or failed with failed.index, name and error for the first that fails. `POST /api/v1/data/rel/migrations/dry-run-sequence` */
+        dryRunMigrations: (args: {
+            migrations: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Undo the most recent migration with its down SQL (or version, with force when it isn't the latest). `POST /api/v1/data/rel/migrations/rollback` */
+        rollbackMigration: (args?: {
+            version?: JsonValue;
+            force?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Drop every user table and forget the migration history, in one transaction (what `sov db reset` runs). dry_run lists what would be dropped. `POST /api/v1/data/rel/migrations/reset` */
+        resetMigrations: (args?: {
+            dryRun?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Run a document pipeline: where, aggregate, distinct, sort, offset, limit, select, remove_fields, sample. `POST /api/v1/data/doc/_pipeline/{collection}` */
+        docPipeline: (args: {
+            collection: string;
+            stages: JsonValue;
+            collectionGroup?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** How two environments' databases differ (to_env '' = production): migrations to deploy and only in the target, and the tables, columns, indexes, constraints and row policies that would be added, changed or dropped. Read-only. `GET /api/v1/data/rel/schema/diff` */
+        schemaDiff: (args: {
+            fromEnv: JsonValue;
+            toEnv?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Deploy a branch (or staging environment) into production, or into a staging environment with to_env_id: its migrations, functions, policies and project settings, all checked first with nothing written (dry_run=true returns only the check). from_name/to_name label the commit. accept_violations deploys even when production's access simulation finds new write access (deploys into staging aren't simulated). `POST /api/v1/data/rel/migrations/promote` */
+        promoteEnvironment: (args: {
+            fromEnvId: JsonValue;
+            toEnvId?: JsonValue;
+            fromName?: JsonValue;
+            toName?: JsonValue;
+            dryRun?: JsonValue;
+            acceptViolations?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    deadLetters: {
+        /** Background runs that ran out of tries (trigger events, async calls, schedules), kept for the plan's fn.dead_letter_days. `GET /api/v1/fn/dead-letters` */
+        list: (args?: {
+            functionName?: JsonValue;
+            triggerId?: JsonValue;
+            limit?: JsonValue;
+            offset?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Run a dead-lettered event again (on the function's live version). `POST /api/v1/fn/dead-letters/{invocation_id}/replay` */
+        replay: (args: {
+            invocationId: string;
+        }) => Promise<JsonValue>;
+        /** Replay up to 100 dead letters at once; returns replayed and failed ids. `POST /api/v1/fn/dead-letters/replay` */
+        replayMany: (args: {
+            ids: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Discard a dead letter for good. `DELETE /api/v1/fn/dead-letters/{invocation_id}` */
+        discard: (args: {
+            invocationId: string;
+        }) => Promise<JsonValue>;
+    };
+    distribution: {
+        /** Tester builds, groups, testers, usage and the plan's limits. `GET /api/v1/projects/{project_id}/distribution` */
+        overview: (args?: {
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Start a tester build upload: returns the release and a signed upload URL (PUT the .apk/.aab/.ipa there, then finalize). `POST /api/v1/projects/{project_id}/distribution/releases` */
+        createRelease: (args: {
+            projectId?: string;
+            filename: JsonValue;
+            sizeBytes: JsonValue;
+            notes?: JsonValue;
+            groups?: JsonValue;
+            env?: JsonValue;
+            gitRef?: JsonValue;
+            appId?: JsonValue;
+            notify?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Read the uploaded build (package/bundle id, version, build, minimum OS), share it with its groups and email their testers. `POST /api/v1/projects/{project_id}/distribution/releases/{release_id}/finalize` */
+        finalizeRelease: (args: {
+            projectId?: string;
+            releaseId: string;
+        }) => Promise<JsonValue>;
+        /** Change a build's notes or groups. `PATCH /api/v1/projects/{project_id}/distribution/releases/{release_id}` */
+        updateRelease: (args: {
+            projectId?: string;
+            releaseId: string;
+            notes?: JsonValue;
+            groups?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete a tester build and its file. `DELETE /api/v1/projects/{project_id}/distribution/releases/{release_id}` */
+        deleteRelease: (args: {
+            projectId?: string;
+            releaseId: string;
+        }) => Promise<JsonValue>;
+        /** Add testers by email to groups and send them install links. `POST /api/v1/projects/{project_id}/distribution/testers` */
+        addTesters: (args: {
+            projectId?: string;
+            emails: JsonValue;
+            groups?: JsonValue;
+            sendInvite?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Remove a tester; their install links stop working at once. `DELETE /api/v1/projects/{project_id}/distribution/testers/{tester_id}` */
+        removeTester: (args: {
+            projectId?: string;
+            testerId: string;
+        }) => Promise<JsonValue>;
+        /** Send a tester a new install link (older links stop working). `POST /api/v1/projects/{project_id}/distribution/testers/{tester_id}/invite` */
+        resendInvite: (args: {
+            projectId?: string;
+            testerId: string;
+        }) => Promise<JsonValue>;
+        /** Delete a tester group. `DELETE /api/v1/projects/{project_id}/distribution/groups/{name}` */
+        deleteGroup: (args: {
+            projectId?: string;
+            name: string;
+        }) => Promise<JsonValue>;
+    };
+    e2ee: {
+        /** Create (or fetch) the active e2ee channel key. `POST /api/v1/rt/e2ee/keys/bootstrap` */
+        bootstrapKey: (args: {
+            channel: JsonValue;
+            ttlSeconds?: JsonValue;
+            forceNew?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Get the active e2ee key for a channel, wrapped for ``client_public_key``. `GET /api/v1/rt/e2ee/keys/active/{channel}` */
+        getActiveKey: (args: {
+            channel: string;
+            clientPublicKey?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Get key material by channel/key_id, wrapped for ``client_public_key``. `GET /api/v1/rt/e2ee/keys/{channel}/{key_id}` */
+        getKey: (args: {
+            channel: string;
+            keyId: string;
+            clientPublicKey?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** List key metadata for a channel. `GET /api/v1/rt/e2ee/keys/{channel}` */
+        listKeys: (args: {
+            channel: string;
+        }) => Promise<JsonValue>;
+        /** Revoke an active or historical channel key. `POST /api/v1/rt/e2ee/keys/revoke` */
+        revokeKey: (args: {
+            channel: JsonValue;
+            keyId?: JsonValue;
+            reason?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Rotate e2ee key material for a channel. `POST /api/v1/rt/e2ee/keys/rotate` */
+        rotateKey: (args: {
+            channel: JsonValue;
+            ttlSeconds?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    embeddings: {
+        /** The project's embedding model, who pays (managed | own_key), dimensions and list price. `GET /api/v1/embeddings/settings` */
+        getSettings: () => Promise<JsonValue>;
+        /** Use the project's own provider key: provider (openai | gemini | openai_compatible), model, dimensions, base_url, api_key. Tested before it is saved. `PUT /api/v1/embeddings/settings` */
+        setSettings: (args: {
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Go back to Sovaria's managed embedding model. `DELETE /api/v1/embeddings/settings` */
+        clearSettings: () => Promise<JsonValue>;
+        /** Texts, tokens and estimated cost per month, model and who paid. `GET /api/v1/embeddings/usage` */
+        usage: (args?: {
+            months?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    experiments: {
+        /** A/B experiments of an environment and the plan's limits. `GET /api/v1/projects/{project_id}/experiments` */
+        listExperiments: (args?: {
+            projectId?: string;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Create an experiment on a parameter: variants [{name, value, weight}], control, condition?, exposure_pct?, goal {type, event|sql, value_prop?}, min_sample?. `POST /api/v1/projects/{project_id}/experiments` */
+        createExperiment: (args: {
+            projectId?: string;
+            name: JsonValue;
+            param: JsonValue;
+            variants: JsonValue;
+            control?: JsonValue;
+            condition?: JsonValue;
+            exposurePct?: JsonValue;
+            goal: JsonValue;
+            minSample?: JsonValue;
+            description?: JsonValue;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One experiment (by id or name). `GET /api/v1/projects/{project_id}/experiments/{ref}` */
+        getExperiment: (args: {
+            projectId?: string;
+            ref: string;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Change an experiment: weights and exposure while running (assigned units keep their variant); anything while draft. `PATCH /api/v1/projects/{project_id}/experiments/{ref}` */
+        updateExperiment: (args: {
+            projectId?: string;
+            ref: string;
+            variants?: JsonValue;
+            control?: JsonValue;
+            exposurePct?: JsonValue;
+            goal?: JsonValue;
+            minSample?: JsonValue;
+            description?: JsonValue;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete a draft or stopped experiment. `DELETE /api/v1/projects/{project_id}/experiments/{ref}` */
+        deleteExperiment: (args: {
+            projectId?: string;
+            ref: string;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Start an experiment (publishes a config version with it). `POST /api/v1/projects/{project_id}/experiments/{ref}/start` */
+        startExperiment: (args: {
+            projectId?: string;
+            ref: string;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Stop an experiment (optionally naming the winner). `POST /api/v1/projects/{project_id}/experiments/{ref}/stop` */
+        stopExperiment: (args: {
+            projectId?: string;
+            ref: string;
+            winner?: JsonValue;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Per-variant results: z-test or Welch with 95% intervals, sample-ratio check, winner once every variant has min_sample units. `GET /api/v1/projects/{project_id}/experiments/{ref}/results` */
+        results: (args: {
+            projectId?: string;
+            ref: string;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Make a variant (the winner by default) the parameter's default, end the experiment and publish. `POST /api/v1/projects/{project_id}/experiments/{ref}/rollout` */
+        rollout: (args: {
+            projectId?: string;
+            ref: string;
+            variant?: JsonValue;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    functions: {
+        /** `DELETE /api/v1/fn/functions/{function_name}` */
+        delete: (args: {
+            functionName: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/fn/functions/{function_name}` */
+        get: (args: {
+            functionName: string;
+            projectId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/fn/functions/{function_name}/bindings` */
+        getBindings: (args: {
+            functionName: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/fn/functions/{function_name}/policy` */
+        getPolicy: (args: {
+            functionName: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/fn/functions/{function_name}/source` */
+        getSource: (args: {
+            functionName: string;
+            projectId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/fn/github/commit` */
+        githubCommit: (args: {
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/fn/github/import` */
+        githubImport: (args: {
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Get status for an async Forge invocation id. `GET /api/v1/fn/invocations/{invocation_id}` */
+        invocationStatus: (args: {
+            invocationId: string;
+            projectId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** List Forge functions with active version and queue summary. `GET /api/v1/fn/functions` */
+        list: (args?: {
+            projectId?: JsonValue;
+            limit?: JsonValue;
+            offset?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Diff two simulation invocation outputs. `GET /api/v1/fn/{function_name}/history/simulation-diff` */
+        simulationDiff: (args: {
+            functionName: string;
+            projectId?: JsonValue;
+            leftInvocationId?: JsonValue;
+            rightInvocationId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Get forge deployment status by deploy id. `GET /api/v1/fn/{deploy_id}/status` */
+        status: (args: {
+            deployId: string;
+            projectId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `PATCH /api/v1/fn/functions/{function_name}` */
+        update: (args: {
+            functionName: string;
+            body: JsonObject;
+            projectId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `PUT /api/v1/fn/functions/{function_name}/bindings` */
+        updateBindings: (args: {
+            functionName: string;
+            bindings: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `PUT /api/v1/fn/functions/{function_name}/policy` */
+        updatePolicy: (args: {
+            functionName: string;
+            policy: JsonObject;
+        }) => Promise<JsonValue>;
+        /** List deployment versions for a Forge function. `GET /api/v1/fn/{function_name}/versions` */
+        versions: (args: {
+            functionName: string;
+            projectId?: JsonValue;
+            limit?: JsonValue;
+            offset?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Preview environments of the linked GitHub repository's open pull requests: PR number and title, status (creating, deploying, ready, partial, error), API URL, functions and migrations applied. `GET /api/v1/fn/github/previews` */
+        listGithubPreviews: () => Promise<JsonValue>;
+        /** A function's own memory, timeout and minimum-instances settings, what it runs with (effective) and the plan's maximums. `GET /api/v1/fn/functions/{function_name}/limits` */
+        getFunctionLimits: (args: {
+            functionName: string;
+        }) => Promise<JsonValue>;
+        /** Lower a function's timeout or memory (never above the plan; null = plan maximum) and set its minimum instances: pre-started sandboxes kept for it so its calls start warm (plan fn.min_instances; left out = unchanged). `PUT /api/v1/fn/functions/{function_name}/limits` */
+        setFunctionLimits: (args: {
+            functionName: string;
+            timeoutSec?: JsonValue;
+            memoryMb?: JsonValue;
+            minInstances?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    governance: {
+        /** `GET /api/v1/governance/admin/databases` */
+        adminDatabases: () => Promise<JsonValue>;
+        /** `GET /api/v1/governance/tenants/{org_id}` */
+        getTenant: (args?: {
+            orgId?: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/governance/tenants/{org_id}/databases/{project_id}/connection` */
+        getTenantDatabaseConnection: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/governance/hosts` */
+        listHosts: (args?: {
+            regionId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/governance/regions` */
+        listRegions: () => Promise<JsonValue>;
+        /** `GET /api/v1/governance/tenants/{org_id}/databases/{project_id}/backups` */
+        listTenantDatabaseBackups: (args?: {
+            orgId?: string;
+            projectId?: string;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/governance/tenants/{org_id}/databases` */
+        listTenantDatabases: (args?: {
+            orgId?: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/governance/tenants` */
+        listTenants: () => Promise<JsonValue>;
+        /** `GET /api/v1/governance/metrics/overview` */
+        metricsOverview: () => Promise<JsonValue>;
+        /** `PATCH /api/v1/governance/hosts/{host_id}` */
+        patchHost: (args: {
+            hostId: string;
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** `PATCH /api/v1/governance/regions/{region_id}` */
+        patchRegion: (args: {
+            regionId: string;
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/pause` */
+        pauseTenantDatabase: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/resize` */
+        resizeTenantDatabase: (args: {
+            orgId?: string;
+            projectId?: string;
+            computeSize: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/resume` */
+        resumeTenantDatabase: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Reveal a database connection string (staff, with an active access grant). `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/connection/reveal` */
+        revealTenantDatabaseConnection: (args: {
+            orgId?: string;
+            projectId?: string;
+            grantId: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/governance/tenants/{org_id}/status` */
+        setTenantStatus: (args: {
+            orgId?: string;
+            status: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/backups` */
+        triggerTenantDatabaseBackup: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Read replicas of the project's dedicated database: status, connection string, lag behind the primary, plan limit. `GET /api/v1/governance/tenants/{org_id}/databases/{project_id}/replicas` */
+        listDatabaseReplicas: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Start a streaming read replica (status provisioning until its base backup is done, then ready). `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/replicas` */
+        createDatabaseReplica: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Remove a read replica and its copy of the data. `DELETE /api/v1/governance/tenants/{org_id}/databases/{project_id}/replicas/{replica_id}` */
+        deleteDatabaseReplica: (args: {
+            orgId?: string;
+            projectId?: string;
+            replicaId: string;
+        }) => Promise<JsonValue>;
+        /** What changed between two moments of the database — a backup id or "now" on each side: schema objects added, removed or changed (with a diff) and rows per table. `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/compare` */
+        compareDatabaseMoments: (args: {
+            orgId?: string;
+            projectId?: string;
+            fromMoment: JsonValue;
+            toMoment?: JsonValue;
+            includePlatform?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Replace the project's database with a backup (dedicated databases): a safety backup is taken first, the backup loads beside production in one transaction and is swapped in; undo within 7 days. Org owners and admins. `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/backups/{backup_id}/restore` */
+        restoreDatabaseBackup: (args: {
+            orgId?: string;
+            projectId?: string;
+            backupId: string;
+            confirm: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Database restores of the project: status, the backup used, the safety backup and until when it can be undone. `GET /api/v1/governance/tenants/{org_id}/databases/{project_id}/restores` */
+        listDatabaseRestores: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Put back the database exactly as it was right before a restore (within the undo window). `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/restores/{restore_id}/undo` */
+        undoDatabaseRestore: (args: {
+            orgId?: string;
+            projectId?: string;
+            restoreId: string;
+        }) => Promise<JsonValue>;
+        /** Point-in-time recovery of the project's database: whether it is on, the earliest and latest moment that can be restored, base backups and archived WAL. `GET /api/v1/governance/tenants/{org_id}/databases/{project_id}/backups/pitr` */
+        getPitrStatus: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Turn on point-in-time recovery (WAL archiving; Pro and higher). If the database needs one restart for it (a few seconds), it restarts only with restart=true; otherwise the answer says state=restart_required. `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/pitr/enable` */
+        enablePitr: (args?: {
+            orgId?: string;
+            projectId?: string;
+            restart?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Stop point-in-time recovery archiving (no restart). What was archived stays restorable until it leaves the plan's window. `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/pitr/disable` */
+        disablePitr: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Restore the project's database to a moment (ISO-8601 target_time). It is recovered in a new container beside production and checked; with confirm=true it is then swapped in (safety backup first, undo for 7 days). verify_only=true only checks the moment restores. Returns a job; poll get_restore_job. `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/restore` */
+        restoreDatabaseToTime: (args: {
+            orgId?: string;
+            projectId?: string;
+            targetTime: JsonValue;
+            confirm?: JsonValue;
+            verifyOnly?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** A database restore job (point-in-time or from a backup): status (running, done, verified, failed, undone), the step it is on, the moment, and until when it can be undone. `GET /api/v1/governance/tenants/{org_id}/databases/{project_id}/backups/pitr/jobs/{job_id}` */
+        getRestoreJob: (args: {
+            orgId?: string;
+            projectId?: string;
+            jobId: string;
+        }) => Promise<JsonValue>;
+        /** Production plus the project's environments (staging ones and API versions): database status, what each database started with (database, copy_state) and its own API URL; limit is how many the plan allows. `GET /api/v1/governance/tenants/{org_id}/projects/{project_id}/environments` */
+        listEnvironments: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Create a branch (kind=branch: a copy of the system to change, then deploy; plan env.branches) or an environment (kind=staging | version; plan env.staging_environments), each with its own database in the project's container. database: empty | schema (default: production's structure, no rows) | sample (plus up to sample_rows newest rows per table and every row they reference; plan env.branch_data, Pro and higher) | all (every row, up to env.branch_data_max_gb; Ultra and higher). Personal columns are masked unless mask=false (owners/admins, audited). Rows are copied as a job: poll get_environment_copy. protected (plan env.protection) and expires_in_days (deleted automatically) are optional. `POST /api/v1/governance/tenants/{org_id}/projects/{project_id}/environments` */
+        createEnvironment: (args: {
+            orgId?: string;
+            projectId?: string;
+            envId: JsonValue;
+            name: JsonValue;
+            kind?: JsonValue;
+            label?: JsonValue;
+            fromEnvId?: JsonValue;
+            database?: JsonValue;
+            sampleRows?: JsonValue;
+            includeTables?: JsonValue;
+            excludeTables?: JsonValue;
+            mask?: JsonValue;
+            maskAdd?: JsonValue;
+            maskSkip?: JsonValue;
+            protected?: JsonValue;
+            expiresInDays?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** What an environment's database started with and how its row copy is going: state copying | done | failed, tables and rows copied, masked columns, size, or why it failed. `GET /api/v1/governance/tenants/{org_id}/projects/{project_id}/environments/{env_id}/copy` */
+        getEnvironmentCopy: (args: {
+            orgId?: string;
+            projectId?: string;
+            envId: string;
+        }) => Promise<JsonValue>;
+        /** Delete an environment, its database (a backup is kept first), URL and Version history branch. Owners and admins; a protected environment is refused (ENVIRONMENT_PROTECTED). `DELETE /api/v1/governance/tenants/{org_id}/projects/{project_id}/environments/{env_id}` */
+        deleteEnvironment: (args: {
+            orgId?: string;
+            projectId?: string;
+            envId: string;
+        }) => Promise<JsonValue>;
+        /** The project's SQL statements (pg_stat_statements) by total time, average, calls, worst run or rows. `GET /api/v1/governance/tenants/{org_id}/databases/{project_id}/query-insights` */
+        queryInsights: (args?: {
+            orgId?: string;
+            projectId?: string;
+            sort?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Clear this database's query statistics. `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/query-insights/reset` */
+        resetQueryInsights: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Indexes that would speed up the slowest statements, tested as hypothetical indexes (hypopg). `GET /api/v1/governance/tenants/{org_id}/databases/{project_id}/index-advisor` */
+        indexAdvisor: (args?: {
+            orgId?: string;
+            projectId?: string;
+            queryid?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Index recommendations for one statement (only EXPLAINed, never run). `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/index-advisor/query` */
+        indexAdvisorForQuery: (args: {
+            orgId?: string;
+            projectId?: string;
+            query: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Build a recommended index with CREATE INDEX CONCURRENTLY (background; poll index_status). `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/index-advisor/apply` */
+        applyIndex: (args: {
+            orgId?: string;
+            projectId?: string;
+            schema?: JsonValue;
+            table: JsonValue;
+            columns: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Whether an index the advisor started is building, ready, failed or invalid. `GET /api/v1/governance/tenants/{org_id}/databases/{project_id}/index-advisor/indexes/{index_name}` */
+        indexStatus: (args: {
+            orgId?: string;
+            projectId?: string;
+            indexName: string;
+        }) => Promise<JsonValue>;
+        /** Change an environment (owners and admins): kind staging | version (with label, e.g. v2), protected (plan env.protection: no delete, reset or restore until turned off), expires_in_days (deleted automatically after that many days; 0 clears it). `PATCH /api/v1/governance/tenants/{org_id}/projects/{project_id}/environments/{env_id}` */
+        updateEnvironment: (args: {
+            orgId?: string;
+            projectId?: string;
+            envId: string;
+            kind?: JsonValue;
+            label?: JsonValue;
+            protected?: JsonValue;
+            expiresInDays?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Make an environment's database again from the one it started from (its parent environment, else production) with the same data option; sample/all rows are copied again with the same masking. A backup is taken first; functions and policies are kept. `POST /api/v1/governance/tenants/{org_id}/projects/{project_id}/environments/{env_id}/reset` */
+        resetEnvironment: (args: {
+            orgId?: string;
+            projectId?: string;
+            envId: string;
+            confirm: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Put an environment's database back as it was at `at` (point-in-time, within db.pitr_retention_days; production is not touched). Runs as a job: poll get_environment_restore. `POST /api/v1/governance/tenants/{org_id}/projects/{project_id}/environments/{env_id}/restore` */
+        restoreEnvironment: (args: {
+            orgId?: string;
+            projectId?: string;
+            envId: string;
+            at: JsonValue;
+            confirm: JsonValue;
+        }) => Promise<JsonValue>;
+        /** How an environment restore is going: status running | done | failed, phase, recovered_to, error. `GET /api/v1/governance/tenants/{org_id}/projects/{project_id}/environments/{env_id}/restore/{restore_id}` */
+        getEnvironmentRestore: (args: {
+            orgId?: string;
+            projectId?: string;
+            envId: string;
+            restoreId: string;
+        }) => Promise<JsonValue>;
+        /** Backup health: last good backup, failures since, recovery point (RPO) of daily backups and PITR, retention and on-demand limits with what was used. `GET /api/v1/governance/tenants/{org_id}/databases/{project_id}/backups/health` */
+        getBackupHealth: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Portable export bundles of the project (Postgres dump + migration metadata). `GET /api/v1/governance/tenants/{org_id}/databases/{project_id}/exports` */
+        listProjectExports: (args?: {
+            orgId?: string;
+            projectId?: string;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Create a portable export bundle (download it with download_project_export). `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/exports` */
+        triggerProjectExport: (args?: {
+            orgId?: string;
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** A compare job: running, failed (with error) or the full answer with status done. `GET /api/v1/governance/tenants/{org_id}/databases/{project_id}/compare/{compare_id}` */
+        getCompare: (args: {
+            orgId?: string;
+            projectId?: string;
+            compareId: string;
+        }) => Promise<JsonValue>;
+        /** Restore this project's backup (backup_id) or a moment (target_time) into an environment of the project (env_id) or another project (project_id) instead of replacing production. Owners/admins; confirm: true; counts as a rollback. `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/restore-into` */
+        restoreDatabaseInto: (args?: {
+            orgId?: string;
+            projectId?: string;
+            envId?: JsonValue;
+            targetProjectId?: JsonValue;
+            backupId?: JsonValue;
+            targetTime?: JsonValue;
+            confirm?: JsonValue;
+            reason?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Copy single tables from a backup or a moment into production as restored_<table>_<stamp> beside the live ones (nothing live changes). Owners/admins; counts as a rollback. `POST /api/v1/governance/tenants/{org_id}/databases/{project_id}/restore-tables` */
+        restoreDatabaseTables: (args: {
+            orgId?: string;
+            projectId?: string;
+            tables: JsonValue;
+            backupId?: JsonValue;
+            targetTime?: JsonValue;
+            reason?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    history: {
+        /** Create a Chrono commit. `POST /api/v1/chrono/commit` */
+        commit: (args: {
+            timeline?: JsonValue;
+            message: JsonValue;
+            author?: JsonValue;
+            eventType?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Converge source timeline into target timeline. Branches that record an environment are refused (409 USE_DEPLOY): deploy them with promote_environment. `POST /api/v1/chrono/timelines/converge` */
+        converge: (args: {
+            target: JsonValue;
+            source: JsonValue;
+            author: JsonValue;
+            message?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Name a point on a branch to go back to (timeline: main = production, or a branch's name; env_id: the environment checked out, '' = production). include_database also keeps a checkpoint of that branch's database (a backup taken now), so restoring brings the data back exactly. `POST /api/v1/chrono/snapshots/create` */
+        createSnapshot: (args?: {
+            message?: JsonValue;
+            timeline?: JsonValue;
+            envId?: JsonValue;
+            includeDatabase?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete a timeline. `DELETE /api/v1/chrono/timelines/{name}` */
+        deleteTimeline: (args: {
+            name: string;
+        }) => Promise<JsonValue>;
+        /** Move a history-only branch to a commit. main and branches that record an environment only move forward (409 USE_RESTORE): use restore. `POST /api/v1/chrono/timelines/{name}/jump` */
+        jumpTimeline: (args: {
+            name: string;
+            targetHex: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Snapshots with their branch (timeline, env_id) and database checkpoint (database: kind, backup_id, at) when one was kept. timeline lists one branch's. `GET /api/v1/chrono/snapshots` */
+        listSnapshots: (args?: {
+            timeline?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Branches: name, head_hex, kind (production | environment | history) and env_id for an environment's branch. `GET /api/v1/chrono/timelines` */
+        listTimelines: () => Promise<JsonValue>;
+        /** Go back to a snapshot on its branch (confirm=true; review restore_snapshot_plan first): policies, settings, functions and buckets are put back with your own permissions; include_schema rolls back migrations since then and include_database puts the database back from the snapshot's checkpoint (or the closest backup before it). `POST /api/v1/chrono/snapshots/{snapshot_id}/restore` */
+        restoreSnapshot: (args: {
+            snapshotId: string;
+            confirm?: JsonValue;
+            includeDatabase?: JsonValue;
+            includeSchema?: JsonValue;
+            envId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** What restoring a snapshot puts back on its branch, change by change, with who would gain or lose access (writes nothing). `POST /api/v1/chrono/snapshots/{snapshot_id}/restore-plan` */
+        restoreSnapshotPlan: (args: {
+            snapshotId: string;
+            envId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Forget a snapshot (its commit stays in the history; its database checkpoint expires like a manual backup). `DELETE /api/v1/chrono/snapshots/{snapshot_id}` */
+        deleteSnapshot: (args: {
+            snapshotId: string;
+        }) => Promise<JsonValue>;
+        /** Spawn a new timeline from a source chronon. `POST /api/v1/chrono/timelines/spawn` */
+        spawnTimeline: (args: {
+            name: JsonValue;
+            sourceHexId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Fetch timeline history chronons. `GET /api/v1/chrono/timelines/{name}/history` */
+        timelineHistory: (args: {
+            name: string;
+            limit?: JsonValue;
+            offset?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Return timeline graph topology. `GET /api/v1/chrono/timelines/topology` */
+        topology: (args?: {
+            timeline?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Calculate variance between two chronons. `POST /api/v1/chrono/variance` */
+        variance: (args: {
+            oldChrononHex: JsonValue;
+            newChrononHex: JsonValue;
+            domainFilter?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** What going back to `at` (a commit id or ISO time) on a branch means, change by change, for that branch's own environment (main = production): automated actions, manual ones, changes from other branches (left alone), the opt-in schema rollback and database restore, and the access preview. env_id is the environment you have checked out ('' = production); a mismatch is refused (ENV_MISMATCH). Writes nothing. `POST /api/v1/chrono/restore-plan` */
+        restorePlan: (args: {
+            at: JsonValue;
+            timeline?: JsonValue;
+            envId?: JsonValue;
+            only?: JsonValue;
+            includeDatabase?: JsonValue;
+            includeSchema?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Apply the restore plan with your own permissions, in the branch's own environment: configuration first, then the schema rollback (include_schema), then the database (include_database). Waits briefly for the new commits: new_head, or recording=true while they are still arriving (poll the branch until its head moves past head_before). `POST /api/v1/chrono/restore` */
+        restore: (args: {
+            at: JsonValue;
+            timeline?: JsonValue;
+            envId?: JsonValue;
+            only?: JsonValue;
+            includeDatabase?: JsonValue;
+            includeSchema?: JsonValue;
+            confirm: JsonValue;
+        }) => Promise<JsonValue>;
+        /** What one commit changed (or how it differs from compare_to), item by item: policy, table, function, settings, bucket, with a summary in words and each item's previous version. `GET /api/v1/chrono/commits/{hex_id}/changes` */
+        commitChanges: (args: {
+            hexId: string;
+            compareTo?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** What undoing exactly one commit puts back on the branch's environment (writes nothing), with the schema rollback dry run when the commit applied a migration. `POST /api/v1/chrono/commits/{hex_id}/undo-plan` */
+        undoPlan: (args: {
+            hexId: string;
+            timeline?: JsonValue;
+            envId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Undo one commit with your own permissions on the branch's environment; its migration's down SQL only with include_schema. `POST /api/v1/chrono/commits/{hex_id}/undo` */
+        undo: (args: {
+            hexId: string;
+            confirm: JsonValue;
+            timeline?: JsonValue;
+            envId?: JsonValue;
+            includeSchema?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Which Version history branch records which environment ({env_id, branch}). main is production's. `GET /api/v1/chrono/environments` */
+        listEnvironmentBranches: () => Promise<JsonValue>;
+        /** Give an environment its own Version history branch (spawned from main's head), for environments made before branches recorded them; returns the branch it has. `PUT /api/v1/chrono/environments/{env_id}` */
+        bindEnvironment: (args: {
+            envId: string;
+            name: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    knowledge: {
+        /** Knowledge bases (RAG) with documents, chunks, tokens, the embedding model and estimated cost. `GET /api/v1/data/rel/vector/knowledge` */
+        list: () => Promise<JsonValue>;
+        /** Create a knowledge base: name, description, access (team | app_users), user_uploads, chunk_tokens. `POST /api/v1/data/rel/vector/knowledge` */
+        create: (args: {
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Change a knowledge base's description, access or user_uploads. `PATCH /api/v1/data/rel/vector/knowledge/{name}` */
+        update: (args: {
+            name: string;
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Delete a knowledge base with all its documents. `DELETE /api/v1/data/rel/vector/knowledge/{name}` */
+        delete: (args: {
+            name: string;
+        }) => Promise<JsonValue>;
+        /** Documents the caller may read: title, source, chunks, tokens, status. `GET /api/v1/data/rel/vector/knowledge/{name}/documents` */
+        listDocuments: (args: {
+            name: string;
+            limit?: JsonValue;
+            offset?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Add or replace a document: text (+format), content_base64 + filename (PDF, DOCX, HTML, Markdown, TXT, CSV, JSON) or url; optional document_id, title, metadata. refresh_hours (url, team) fetches the page again on a schedule. `POST /api/v1/data/rel/vector/knowledge/{name}/documents` */
+        addDocument: (args: {
+            name: string;
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Remove a document (its owner or the team). `DELETE /api/v1/data/rel/vector/knowledge/{name}/documents/{document_id}` */
+        deleteDocument: (args: {
+            name: string;
+            documentId: string;
+        }) => Promise<JsonValue>;
+        /** Passages for a question with numbered citations: query, k, mode (vector | keyword | hybrid), metadata_filter, document_ids (up to 50), rerank. Only passages the caller may read. `POST /api/v1/data/rel/vector/knowledge/{name}/search` */
+        search: (args: {
+            name: string;
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** URL documents fetched again on a schedule (refresh_hours): next fetch, last error. `GET /api/v1/data/rel/vector/knowledge/{name}/sources` */
+        listSources: (args: {
+            name: string;
+        }) => Promise<JsonValue>;
+    };
+    mcp: {
+        /** AI assistants you connected over Sovaria's MCP server: the app, its organization and project, read-only or not, when it was connected and last used. `GET /api/v1/auth/mcp/connections` */
+        listConnections: () => Promise<JsonValue>;
+        /** Disconnect one of your AI assistants: its tokens stop working at once. `DELETE /api/v1/auth/mcp/connections/{grant_id}` */
+        disconnect: (args: {
+            grantId: string;
+        }) => Promise<JsonValue>;
+        /** Whether members may connect AI assistants to this organization, the MCP server URL, and (owners and admins) every member's connection. `GET /api/v1/org/{org_id}/mcp` */
+        orgSettings: (args?: {
+            orgId?: string;
+        }) => Promise<JsonValue>;
+        /** Allow or stop AI assistants for the organization (owners and admins). Turning it off ends every member's connection. `PUT /api/v1/org/{org_id}/mcp` */
+        setOrgAllowed: (args: {
+            orgId?: string;
+            allowed: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Disconnect a member's AI assistant from the organization (owners and admins). `DELETE /api/v1/org/{org_id}/mcp/connections/{grant_id}` */
+        orgDisconnect: (args: {
+            orgId?: string;
+            grantId: string;
+        }) => Promise<JsonValue>;
+    };
+    messaging: {
+        /** Message templates of the project (push and/or email content with {{ variables }}). `GET /api/v1/projects/{project_id}/messaging/templates` */
+        listTemplates: (args?: {
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** One message template. `GET /api/v1/projects/{project_id}/messaging/templates/{name}` */
+        getTemplate: (args: {
+            projectId?: string;
+            name: string;
+        }) => Promise<JsonValue>;
+        /** Create or replace a template: push {title, body, image?, data?}, email {subject, html?, text?}; category transactional or marketing (marketing skips opted-out users and adds an unsubscribe link). `PUT /api/v1/projects/{project_id}/messaging/templates/{name}` */
+        putTemplate: (args: {
+            projectId?: string;
+            name: string;
+            description?: JsonValue;
+            category?: JsonValue;
+            push?: JsonValue;
+            email?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete a message template. `DELETE /api/v1/projects/{project_id}/messaging/templates/{name}` */
+        deleteTemplate: (args: {
+            projectId?: string;
+            name: string;
+        }) => Promise<JsonValue>;
+        /** Saved audiences: read-only SQL queries returning user_id (other columns become per-user variables). `GET /api/v1/projects/{project_id}/messaging/audiences` */
+        listAudiences: (args?: {
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** One audience and its last count. `GET /api/v1/projects/{project_id}/messaging/audiences/{name}` */
+        getAudience: (args: {
+            projectId?: string;
+            name: string;
+        }) => Promise<JsonValue>;
+        /** Create or replace an audience: a SELECT on the project database returning user_id (e.g. select user_id, first_name from profiles where plan = 'pro'). `PUT /api/v1/projects/{project_id}/messaging/audiences/{name}` */
+        putAudience: (args: {
+            projectId?: string;
+            name: string;
+            sql: JsonValue;
+            description?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete an audience. `DELETE /api/v1/projects/{project_id}/messaging/audiences/{name}` */
+        deleteAudience: (args: {
+            projectId?: string;
+            name: string;
+        }) => Promise<JsonValue>;
+        /** Run a saved audience: how many app users it reaches, columns and a sample of 10. `POST /api/v1/projects/{project_id}/messaging/audiences/{name}/preview` */
+        previewAudience: (args: {
+            projectId?: string;
+            name: string;
+        }) => Promise<JsonValue>;
+        /** Try an audience query before saving it: app users reached, columns and a sample. `POST /api/v1/projects/{project_id}/messaging/audiences/preview` */
+        previewSql: (args: {
+            projectId?: string;
+            sql: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Send a template (or content {push, email}) to {user_ids | audience | sql | topic | all_users} on push and/or email, with variables; dry_run reports who would get it and renders a preview. send_at schedules it (timezone 'user' = that local time for each recipient). A durable job sends it; poll getSend. `POST /api/v1/projects/{project_id}/messaging/send` */
+        send: (args: {
+            projectId?: string;
+            template?: JsonValue;
+            content?: JsonValue;
+            to: JsonValue;
+            channels?: JsonValue;
+            variables?: JsonValue;
+            category?: JsonValue;
+            dryRun?: JsonValue;
+            sendAt?: JsonValue;
+            timezone?: JsonValue;
+            timezoneFallback?: JsonValue;
+            track?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Recent sends with status and per-channel counts. `GET /api/v1/projects/{project_id}/messaging/sends` */
+        listSends: (args?: {
+            projectId?: string;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One send: status (sending, done, failed) and counts per channel and outcome. `GET /api/v1/projects/{project_id}/messaging/sends/{send_id}` */
+        getSend: (args: {
+            projectId?: string;
+            sendId: string;
+        }) => Promise<JsonValue>;
+        /** Delivery log: per recipient and channel, sent / failed / no_device / no_email / opted_out with an error code (never content). `GET /api/v1/projects/{project_id}/messaging/deliveries` */
+        listDeliveries: (args?: {
+            projectId?: string;
+            sendId?: JsonValue;
+            userId?: JsonValue;
+            status?: JsonValue;
+            limit?: JsonValue;
+            offset?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Messages sent this month per channel and the plan's messaging limits. `GET /api/v1/projects/{project_id}/messaging/usage` */
+        usage: (args?: {
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Record an app user's marketing choice (channel push, email or all) from your own UI. `PUT /api/v1/projects/{project_id}/messaging/users/{user_id}/optouts` */
+        setUserOptout: (args: {
+            projectId?: string;
+            userId: string;
+            channel: JsonValue;
+            optedOut: JsonValue;
+        }) => Promise<JsonValue>;
+        /** The signed-in app user's marketing preferences per channel. `GET /api/v1/messaging/preferences` */
+        getPreferences: () => Promise<JsonValue>;
+        /** The signed-in app user turns marketing push/email on or off: { marketing: { email: false } }. `PUT /api/v1/messaging/preferences` */
+        setPreferences: (args: {
+            marketing: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Cancel a scheduled or running send (recipients not reached yet get nothing). `POST /api/v1/projects/{project_id}/messaging/sends/{send_id}/cancel` */
+        cancelSend: (args: {
+            projectId?: string;
+            sendId: string;
+        }) => Promise<JsonValue>;
+        /** In-app messages of the project with impressions, clicks and dismissals. `GET /api/v1/projects/{project_id}/messaging/in-app` */
+        listInApp: (args?: {
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Create or replace an in-app message: content {title, body, image, layout, buttons}, trigger (app_open, screen:x, event:x), audience, window, max impressions per user. `PUT /api/v1/projects/{project_id}/messaging/in-app/{name}` */
+        putInApp: (args: {
+            projectId?: string;
+            name: string;
+            content: JsonValue;
+            trigger?: JsonValue;
+            audience?: JsonValue;
+            status?: JsonValue;
+            startsAt?: JsonValue;
+            endsAt?: JsonValue;
+            maxImpressions?: JsonValue;
+            priority?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete an in-app message. `DELETE /api/v1/projects/{project_id}/messaging/in-app/{name}` */
+        deleteInApp: (args: {
+            projectId?: string;
+            name: string;
+        }) => Promise<JsonValue>;
+        /** The signed-in app user opened (or clicked) a message they were sent (push data sov_send). `POST /api/v1/messaging/events` */
+        trackEvent: (args: {
+            sendId: JsonValue;
+            channel?: JsonValue;
+            kind?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** In-app messages the signed-in app user should see now for a trigger. `GET /api/v1/messaging/in-app` */
+        myInApp: (args?: {
+            trigger?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Report an in-app message impression, click or dismissal. `POST /api/v1/messaging/in-app/{message_id}/events` */
+        inAppEvent: (args: {
+            messageId: string;
+            kind: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    mobile: {
+        /** Registered iOS/Android apps (bundle/package ids, redirect URIs). `GET /api/v1/projects/{project_id}/mobile/apps` */
+        listApps: (args?: {
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Register an app: platform, bundle_id+team_id (iOS) or package_name+sha256_cert_fingerprints (Android), redirect_uris. `POST /api/v1/projects/{project_id}/mobile/apps` */
+        createApp: (args: {
+            projectId?: string;
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Change a registered app (name, ids, fingerprints, redirect URIs). `PATCH /api/v1/projects/{project_id}/mobile/apps/{app_id}` */
+        updateApp: (args: {
+            projectId?: string;
+            appId: string;
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Remove a registered app. `DELETE /api/v1/projects/{project_id}/mobile/apps/{app_id}` */
+        deleteApp: (args: {
+            projectId?: string;
+            appId: string;
+        }) => Promise<JsonValue>;
+        /** An app user's signed-in devices and push tokens. `GET /api/v1/projects/{project_id}/users/{user_id}/devices` */
+        listUserDevices: (args: {
+            projectId?: string;
+            userId: string;
+        }) => Promise<JsonValue>;
+        /** Sign one of an app user's devices out (sessions and push tokens). `DELETE /api/v1/projects/{project_id}/users/{user_id}/devices/{device_id}` */
+        revokeUserDevice: (args: {
+            projectId?: string;
+            userId: string;
+            deviceId: string;
+        }) => Promise<JsonValue>;
+    };
+    observability: {
+        /** Requests, 4xx/5xx errors, latency (avg, p50, p95, p99) and bytes over time for the project, per gateway service. History by plan (obs.retention_days). `GET /api/v1/observability/metrics` */
+        metrics: (args?: {
+            hours?: JsonValue;
+            service?: JsonValue;
+            points?: JsonValue;
+            byService?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Recent requests, newest first (method, path, status, duration, service, trace_id, env_id). after = live tail, before = older page. `GET /api/v1/observability/logs` */
+        logs: (args?: {
+            limit?: JsonValue;
+            service?: JsonValue;
+            status?: JsonValue;
+            q?: JsonValue;
+            after?: JsonValue;
+            before?: JsonValue;
+            source?: JsonValue;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Latency (p50, p95, p99) and 4xx/5xx per route (method + path with ids collapsed), busiest first; env = comma-separated environment ids (main = none named), default all; route adds that route's series. `GET /api/v1/observability/routes` */
+        routes: (args?: {
+            hours?: JsonValue;
+            env?: JsonValue;
+            route?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** SLO alert rules with their state (ok, firing, no_data, paused), the plan limit (obs.alert_rules), the metric catalog and recent events. `GET /api/v1/observability/alerts` */
+        alertsList: () => Promise<JsonValue>;
+        /** Create an alert rule: metric latency_p95_ms, latency_p99_ms, error_rate (5xx %), function_failures or db_connections; threshold; window 5-60 min; optional route/function target; team email and/or a signed HTTPS webhook (signing_secret returned once). Owners and admins. `POST /api/v1/observability/alerts` */
+        alertsCreate: (args: {
+            metric: JsonValue;
+            threshold: JsonValue;
+            windowMinutes?: JsonValue;
+            name?: JsonValue;
+            target?: JsonValue;
+            env?: JsonValue;
+            minRequests?: JsonValue;
+            email?: JsonValue;
+            webhookUrl?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Change an alert rule (any create field) or pause/resume it ({enabled: false}). `PATCH /api/v1/observability/alerts/{rule_id}` */
+        alertsUpdate: (args: {
+            ruleId: string;
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Delete an alert rule. `DELETE /api/v1/observability/alerts/{rule_id}` */
+        alertsDelete: (args: {
+            ruleId: string;
+        }) => Promise<JsonValue>;
+        /** Measure the rule now (value, would_fire) and send an alert.test to its webhook. `POST /api/v1/observability/alerts/{rule_id}/test` */
+        alertsTest: (args: {
+            ruleId: string;
+        }) => Promise<JsonValue>;
+        /** Fired and resolved alerts, newest first. `GET /api/v1/observability/alerts/events` */
+        alertsEvents: (args?: {
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    org: {
+        /** `POST /api/v1/org/invites/accept` */
+        acceptOrgInvite: (args: {
+            token: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Add a user as a member of an org/project node. `POST /api/v1/org/{org_id}/member` */
+        addMember: (args: {
+            orgId?: string;
+            userId: JsonValue;
+            role: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Connect two DAPG nodes with a typed relationship. `POST /api/v1/edge` */
+        createEdge: (args: {
+            sourceNodeId: JsonValue;
+            targetNodeId: JsonValue;
+            relationType: JsonValue;
+            role?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/org/{org_id}/invites` */
+        createOrgInvite: (args: {
+            orgId?: string;
+            email: JsonValue;
+            role: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `DELETE /api/v1/org/{org_id}` */
+        deleteOrg: (args?: {
+            orgId?: string;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/apikeys/ensure-defaults` */
+        ensureDefaultApiKeys: () => Promise<JsonValue>;
+        /** List child nodes attached by a relation (e.g. OWNS, HAS_ENV). `GET /api/v1/org/{parent_id}/children` */
+        getChildren: (args: {
+            parentId: string;
+            relation?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Resolve a user's roles on a resource by walking the DAPG. `GET /api/v1/context/{user_id}/{resource_id}` */
+        getContext: (args: {
+            userId: string;
+            resourceId: string;
+        }) => Promise<JsonValue>;
+        /** Fetch a single graph node by ID. `GET /api/v1/org/{node_id}` */
+        getNode: (args: {
+            nodeId: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/org/{project_id}/ref` */
+        getProjectRef: (args?: {
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/project-settings` */
+        getProjectSettings: () => Promise<JsonValue>;
+        /** `GET /api/v1/roles/catalog` */
+        getRoleCatalog: () => Promise<JsonValue>;
+        /** `GET /api/v1/roles/matrix` */
+        getRoleMatrix: () => Promise<JsonValue>;
+        /** Whether the saved role matrix is enforced, and the plan's role allowance `GET /api/v1/roles/matrix/status` */
+        getRoleMatrixStatus: () => Promise<JsonValue>;
+        /** `GET /api/v1/apikeys` */
+        listApiKeys: () => Promise<JsonValue>;
+        /** List graph nodes; when provided, ``node_type`` filters by type. `GET /api/v1/org` */
+        listNodes: (args?: {
+            nodeType?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/org/{org_id}/members` */
+        listOrgMembers: (args?: {
+            orgId?: string;
+        }) => Promise<JsonValue>;
+        /** `DELETE /api/v1/org/{org_id}/member/{user_id}` */
+        removeOrgMember: (args: {
+            orgId?: string;
+            userId: string;
+        }) => Promise<JsonValue>;
+        /** `DELETE /api/v1/apikeys/{key_id}` */
+        revokeApiKey: (args: {
+            keyId: string;
+        }) => Promise<JsonValue>;
+        /** `PUT /api/v1/org/{org_id}/plan` */
+        setOrgPlan: (args: {
+            orgId?: string;
+            plan: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `PUT /api/v1/org/{org_id}/member/{user_id}` */
+        updateMemberRole: (args: {
+            orgId?: string;
+            userId: string;
+            role: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `PUT /api/v1/org/{org_id}` */
+        updateOrg: (args: {
+            orgId?: string;
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** `PUT /api/v1/project-settings` */
+        updateProjectSettings: (args: {
+            settings: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `PUT /api/v1/roles/matrix` */
+        updateRoleMatrix: (args: {
+            matrix: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Hand the organization and its billing to another admin (owner only). 409 ONE_OWNED_ORG when they already own one. `POST /api/v1/org/{org_id}/transfer-ownership` */
+        transferOrgOwnership: (args: {
+            orgId?: string;
+            newOwnerId: JsonValue;
+            reason?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    perf: {
+        /** Client performance: p50/p75/p95, count and web-vitals ratings per metric (or per page/screen with by=route). `GET /api/v1/perf/summary` */
+        summary: (args?: {
+            days?: JsonValue;
+            kind?: JsonValue;
+            release?: JsonValue;
+            platform?: JsonValue;
+            by?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One client metric's percentile over time. `GET /api/v1/perf/series` */
+        series: (args: {
+            kind: JsonValue;
+            name: JsonValue;
+            days?: JsonValue;
+            route?: JsonValue;
+            release?: JsonValue;
+            platform?: JsonValue;
+            q?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Raw client measurements (newest or slowest first), each with its trace id. `GET /api/v1/perf/samples` */
+        samples: (args?: {
+            kind?: JsonValue;
+            name?: JsonValue;
+            route?: JsonValue;
+            traceId?: JsonValue;
+            slowest?: JsonValue;
+            days?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Client network time per route next to the gateway's server time for the same route. `GET /api/v1/perf/network` */
+        network: (args?: {
+            days?: JsonValue;
+            env?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Client spans and the server trace for one trace id. `GET /api/v1/perf/traces/{trace_id}` */
+        trace: (args: {
+            traceId: string;
+        }) => Promise<JsonValue>;
+        /** Performance measurements accepted and dropped this month, and the plan's limits. `GET /api/v1/perf/usage` */
+        usage: () => Promise<JsonValue>;
+    };
+    platform: {
+        /** `POST /api/v1/auth/event-hooks` */
+        createEventHook: (args: {
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** `DELETE /api/v1/auth/event-hooks/{hook_id}` */
+        deleteEventHook: (args: {
+            hookId: string;
+        }) => Promise<JsonValue>;
+        /** `DELETE /api/v1/auth/github/connection-state` */
+        disconnectGithub: (args?: {
+            projectId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `GET /healthz` */
+        gatewayHealth: () => Promise<JsonValue>;
+        /** Return aggregate gateway health for downstream engines. `GET /api/v1/system/engines/health` */
+        getEnginesHealth: () => Promise<JsonValue>;
+        /** `GET /api/v1/error-traces/{trace_id}` */
+        getErrorTrace: (args: {
+            traceId: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/auth/github/connection-state` */
+        getGithubConnectionState: (args?: {
+            projectId?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/auth/event-hooks` */
+        listEventHooks: () => Promise<JsonValue>;
+        /** `PATCH /api/v1/error-traces/{trace_id}/resolved` */
+        resolveErrorTrace: (args: {
+            traceId: string;
+            resolved: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    policy: {
+        /** Return current audit-entry count. `GET /api/v1/audit/count` */
+        auditCount: () => Promise<JsonValue>;
+        /** Verify audit hash-chain integrity. `GET /api/v1/audit/verify` */
+        auditVerify: () => Promise<JsonValue>;
+        /** Create and compile a policy. `POST /api/v1/policies/` */
+        policyCreate: (args: {
+            policyId: JsonValue;
+            name: JsonValue;
+            splSource: JsonValue;
+            orgId: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete (deactivate) a policy. `DELETE /api/v1/policies/{policy_id}` */
+        policyDelete: (args: {
+            policyId: string;
+        }) => Promise<JsonValue>;
+        /** Evaluate a policy against an explicit debug context. `POST /api/v1/policies/{policy_id}/evaluate` */
+        policyEvaluate: (args: {
+            policyId: string;
+            context: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Get a single policy by ID. `GET /api/v1/policies/{policy_id}` */
+        policyGet: (args: {
+            policyId: string;
+        }) => Promise<JsonValue>;
+        /** Return version history for a policy. `GET /api/v1/policies/{policy_id}/history` */
+        policyHistory: (args: {
+            policyId: string;
+        }) => Promise<JsonValue>;
+        /** List active policies visible in current tenant scope. `GET /api/v1/policies/` */
+        policyList: () => Promise<JsonValue>;
+        /** Rollback a policy to a historical version. `POST /api/v1/policies/{policy_id}/rollback` */
+        policyRollback: (args: {
+            policyId: string;
+            version: JsonValue;
+        }) => Promise<JsonValue>;
+        /** List server-authoritative SPL templates. `GET /api/v1/policies/templates` */
+        policyTemplates: () => Promise<JsonValue>;
+    };
+    push: {
+        /** Which push providers are set up (never the keys). `GET /api/v1/projects/{project_id}/push/credentials` */
+        getCredentials: (args?: {
+            projectId?: string;
+        }) => Promise<JsonValue>;
+        /** Upload the Firebase service account JSON (encrypted, write-only). `PUT /api/v1/projects/{project_id}/push/credentials/fcm` */
+        setFcmCredentials: (args: {
+            projectId?: string;
+            serviceAccount: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Upload the APNs .p8 key (encrypted, write-only). `PUT /api/v1/projects/{project_id}/push/credentials/apns` */
+        setApnsCredentials: (args: {
+            projectId?: string;
+            p8: JsonValue;
+            keyId: JsonValue;
+            teamId: JsonValue;
+            bundleId: JsonValue;
+            environment?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Remove FCM or APNs credentials. `DELETE /api/v1/projects/{project_id}/push/credentials/{provider}` */
+        deleteCredentials: (args: {
+            projectId?: string;
+            provider: string;
+        }) => Promise<JsonValue>;
+        /** Push devices registered in the project (tokens are never returned). `GET /api/v1/projects/{project_id}/push/devices` */
+        listDevices: (args?: {
+            projectId?: string;
+            userId?: JsonValue;
+            limit?: JsonValue;
+            before?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Send a push: to {user_ids|device_ids|topic}, notification {title, body, image}, data, badge, priority, ttl_seconds, dry_run. `POST /api/v1/projects/{project_id}/push/send` */
+        send: (args: {
+            projectId?: string;
+            message: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Recent sends (counts and error codes) and this month's total. `GET /api/v1/projects/{project_id}/push/sends` */
+        listSends: (args?: {
+            projectId?: string;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Register the signed-in app user's push token (FCM or APNs). `POST /api/v1/push/devices` */
+        registerDevice: (args: {
+            token: JsonValue;
+            platform: JsonValue;
+            provider?: JsonValue;
+            deviceId?: JsonValue;
+            appId?: JsonValue;
+            topics?: JsonValue;
+            locale?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** The signed-in app user's push tokens. `GET /api/v1/push/devices` */
+        myDevices: () => Promise<JsonValue>;
+        /** Subscribe a device to topics or unsubscribe it. `PATCH /api/v1/push/devices/{device_row_id}/topics` */
+        updateTopics: (args: {
+            deviceRowId: string;
+            subscribe?: JsonValue;
+            unsubscribe?: JsonValue;
+            replace?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Remove one of the signed-in user's push devices. `DELETE /api/v1/push/devices/{device_row_id}` */
+        deleteDevice: (args: {
+            deviceRowId: string;
+        }) => Promise<JsonValue>;
+        /** Drop a push token (sign-out, notifications turned off). `POST /api/v1/push/devices/unregister` */
+        unregisterToken: (args: {
+            token: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Create (or rotate) the project's web push VAPID keys; returns the public key. `POST /api/v1/projects/{project_id}/push/credentials/webpush` */
+        setWebpushCredentials: (args?: {
+            projectId?: string;
+            subject?: JsonValue;
+            rotate?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** The project's VAPID public key for browsers (pushManager.subscribe applicationServerKey). `GET /api/v1/push/webpush-key` */
+        webpushKey: () => Promise<JsonValue>;
+        /** Cancel a queued or running large push send. `POST /api/v1/projects/{project_id}/push/sends/{send_id}/cancel` */
+        cancelSend: (args: {
+            projectId?: string;
+            sendId: string;
+        }) => Promise<JsonValue>;
+    };
+    queues: {
+        /** Message queues of the project's environment with length and oldest message age, plus the plan's queue limits and usage. `GET /api/v1/queues` */
+        list: () => Promise<JsonValue>;
+        /** Create a queue: visibility_timeout_sec, max_reads + dead_letter_queue, retention_days, app_send (app users may send) and an optional consumer {function_name, enabled, batch_size, concurrency, visibility_timeout_sec, ack}. `POST /api/v1/queues` */
+        create: (args: {
+            name: JsonValue;
+            description?: JsonValue;
+            visibilityTimeoutSec?: JsonValue;
+            maxReads?: JsonValue;
+            deadLetterQueue?: JsonValue;
+            retentionDays?: JsonValue;
+            appSend?: JsonValue;
+            consumer?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One queue with its settings, consumer binding and metrics. `GET /api/v1/queues/{queue_name}` */
+        get: (args: {
+            queueName: string;
+        }) => Promise<JsonValue>;
+        /** Change a queue's settings or consumer binding (only the fields sent change). `PATCH /api/v1/queues/{queue_name}` */
+        update: (args: {
+            queueName: string;
+            settings: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Delete a queue and all its messages. `DELETE /api/v1/queues/{queue_name}` */
+        delete: (args: {
+            queueName: string;
+        }) => Promise<JsonValue>;
+        /** Send one JSON message (delay: seconds before it can be read); returns msg_id. `POST /api/v1/queues/{queue_name}/send` */
+        send: (args: {
+            queueName: string;
+            message: JsonValue;
+            delay?: JsonValue;
+            headers?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Send up to 100 messages at once; returns msg_ids in order. `POST /api/v1/queues/{queue_name}/send_batch` */
+        sendBatch: (args: {
+            queueName: string;
+            messages: JsonValue;
+            delay?: JsonValue;
+            headers?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Read up to qty visible messages and hide them for vt seconds (default: the queue's); archive or delete each when done, or it reappears. `POST /api/v1/queues/{queue_name}/read` */
+        read: (args: {
+            queueName: string;
+            qty?: JsonValue;
+            vt?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Read and delete up to qty messages at once (at-most-once). `POST /api/v1/queues/{queue_name}/pop` */
+        pop: (args: {
+            queueName: string;
+            qty?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Archive messages (kept for the retention period); returns the ids archived. `POST /api/v1/queues/{queue_name}/archive` */
+        archive: (args: {
+            queueName: string;
+            msgIds: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete messages; returns the ids deleted. `POST /api/v1/queues/{queue_name}/delete` */
+        deleteMessages: (args: {
+            queueName: string;
+            msgIds: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Hide a message for vt more seconds from now (0 = visible now). `POST /api/v1/queues/{queue_name}/set_vt` */
+        setVt: (args: {
+            queueName: string;
+            msgId: JsonValue;
+            vt: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete every waiting message (and the archive with include_archived); returns how many. `POST /api/v1/queues/{queue_name}/purge` */
+        purge: (args: {
+            queueName: string;
+            includeArchived?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Queue length, visible / in flight / delayed, oldest and newest message age, totals, archived and dead-lettered. `GET /api/v1/queues/{queue_name}/metrics` */
+        metrics: (args: {
+            queueName: string;
+        }) => Promise<JsonValue>;
+        /** Look at messages without reading them: state waiting, archived or dead. `GET /api/v1/queues/{queue_name}/messages` */
+        messages: (args: {
+            queueName: string;
+            state?: JsonValue;
+            limit?: JsonValue;
+            before?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    realtime: {
+        /** List active realtime channels. `GET /api/v1/rt/stream/channels` */
+        channels: () => Promise<JsonValue>;
+        /** Fetch presence for a realtime channel. `GET /api/v1/rt/stream/presence/{channel}` */
+        presence: (args: {
+            channel: string;
+        }) => Promise<JsonValue>;
+        /** Replay events for a realtime channel. `GET /api/v1/rt/stream/replay/{channel}` */
+        replay: (args: {
+            channel: string;
+            after?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Subscribe a client ID to a realtime channel. `POST /api/v1/rt/stream/subscribe` */
+        subscribe: (args: {
+            channel: JsonValue;
+            clientId: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Unsubscribe a client ID from a realtime channel. `POST /api/v1/rt/stream/unsubscribe` */
+        unsubscribe: (args: {
+            channel: JsonValue;
+            clientId: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    remoteConfig: {
+        /** Remote config draft of an environment: parameters, conditions, the published version and pending changes. `GET /api/v1/projects/{project_id}/config` */
+        getDraft: (args?: {
+            projectId?: string;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Create or change a parameter: type (bool|string|number|json), default, description, conditional [{condition, value}]. `PUT /api/v1/projects/{project_id}/config/params/{key}` */
+        putParam: (args: {
+            projectId?: string;
+            key: string;
+            type?: JsonValue;
+            defaultValue?: JsonValue;
+            description?: JsonValue;
+            conditional?: JsonValue;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete a parameter from the draft. `DELETE /api/v1/projects/{project_id}/config/params/{key}` */
+        deleteParam: (args: {
+            projectId?: string;
+            key: string;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Create or change a targeting condition: rules (attrs, semver, percent, users, audience), priority (lower wins first). `PUT /api/v1/projects/{project_id}/config/conditions/{name}` */
+        putCondition: (args: {
+            projectId?: string;
+            name: string;
+            rules: JsonValue;
+            priority?: JsonValue;
+            description?: JsonValue;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete a condition from the draft. `DELETE /api/v1/projects/{project_id}/config/conditions/{name}` */
+        deleteCondition: (args: {
+            projectId?: string;
+            name: string;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** The draft (or the published version) as a git-friendly template file. `GET /api/v1/projects/{project_id}/config/template` */
+        getTemplate: (args?: {
+            projectId?: string;
+            env?: JsonValue;
+            source?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Replace the draft from a template file {conditions, parameters}; prune removes what the file doesn't have. Nothing is published. `PUT /api/v1/projects/{project_id}/config/template` */
+        putTemplate: (args?: {
+            projectId?: string;
+            conditions?: JsonValue;
+            parameters?: JsonValue;
+            env?: JsonValue;
+            prune?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** What publishing the draft (or a given template) would change against the published version. `POST /api/v1/projects/{project_id}/config/diff` */
+        diff: (args?: {
+            projectId?: string;
+            template?: JsonValue;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** How many recently seen users would get different values if the draft (or template) were published. `POST /api/v1/projects/{project_id}/config/preview` */
+        preview: (args?: {
+            projectId?: string;
+            template?: JsonValue;
+            env?: JsonValue;
+            sample?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Publish the draft as the next immutable version (base_version: the version you reviewed; scheduled_at: publish later). `POST /api/v1/projects/{project_id}/config/publish` */
+        publish: (args?: {
+            projectId?: string;
+            message?: JsonValue;
+            baseVersion?: JsonValue;
+            scheduledAt?: JsonValue;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Published (and scheduled) versions, newest first. `GET /api/v1/projects/{project_id}/config/versions` */
+        listVersions: (args?: {
+            projectId?: string;
+            env?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One published version with its snapshot and template file. `GET /api/v1/projects/{project_id}/config/versions/{version}` */
+        getVersion: (args: {
+            projectId?: string;
+            version: string;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Publish an older version again as a new version. `POST /api/v1/projects/{project_id}/config/rollback/{version}` */
+        rollback: (args: {
+            projectId?: string;
+            version: string;
+            message?: JsonValue;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Cancel a scheduled publish. `DELETE /api/v1/projects/{project_id}/config/schedules/{schedule_id}` */
+        cancelSchedule: (args: {
+            projectId?: string;
+            scheduleId: string;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** The values one user or device would get (context: user_id, anon_id, platform, app_version, country, language, attrs). `POST /api/v1/projects/{project_id}/config/evaluate` */
+        evaluate: (args?: {
+            projectId?: string;
+            context?: JsonValue;
+            source?: JsonValue;
+            env?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    schedules: {
+        /** Cron schedules of the project's environment, newest first (optionally of one function). `GET /api/v1/fn/schedules` */
+        list: (args?: {
+            functionName?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Create a cron schedule: target_type function (function_name, payload), http (target: url, method, headers, body) or sql (target: sql, params); cron_expression in timezone (IANA), overlap allow|skip, max_attempts, timeout_sec. Payload/target values may be {"$secret": NAME}. `POST /api/v1/fn/schedules` */
+        create: (args: {
+            cronExpression: JsonValue;
+            functionName?: JsonValue;
+            payload?: JsonValue;
+            enabled?: JsonValue;
+            name?: JsonValue;
+            description?: JsonValue;
+            timezone?: JsonValue;
+            overlap?: JsonValue;
+            maxAttempts?: JsonValue;
+            timeoutSec?: JsonValue;
+            targetType?: JsonValue;
+            target?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One schedule: expression, timezone, readable summary, next and last run. `GET /api/v1/fn/schedules/{schedule_id}` */
+        get: (args: {
+            scheduleId: string;
+        }) => Promise<JsonValue>;
+        /** Change a schedule; only the fields sent change (payload null clears it; "[redacted]" values keep what is stored). `PATCH /api/v1/fn/schedules/{schedule_id}` */
+        update: (args: {
+            scheduleId: string;
+            changes: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Delete a schedule (its run history stays in the logs). `DELETE /api/v1/fn/schedules/{schedule_id}` */
+        delete: (args: {
+            scheduleId: string;
+        }) => Promise<JsonValue>;
+        /** Run history, newest first: status (incl. SKIPPED and MISSED slots), duration, error, attempts and the response preview of HTTP/SQL targets. `GET /api/v1/fn/schedules/{schedule_id}/runs` */
+        runs: (args: {
+            scheduleId: string;
+            limit?: JsonValue;
+            before?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Run a schedule now (its regular times don't change); returns the queued invocation id. `POST /api/v1/fn/schedules/{schedule_id}/run` */
+        run: (args: {
+            scheduleId: string;
+        }) => Promise<JsonValue>;
+        /** The next run times of a cron expression in a time zone, with a readable summary; nothing is saved. `POST /api/v1/fn/schedules/preview` */
+        preview: (args: {
+            cronExpression: JsonValue;
+            timezone?: JsonValue;
+            count?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    simulation: {
+        /** Compare two simulation runs of the project: regressions, improvements and new failures. `GET /api/v1/sim/runs/{target_run_id}/compare/{baseline_run_id}` */
+        compareRuns: (args: {
+            targetRunId: string;
+            baselineRunId: string;
+        }) => Promise<JsonValue>;
+        /** What a simulation would test (user types, resources, rules), redacted by what you may read; pass its manifest_id to a run. `POST /api/v1/sim/discover` */
+        discover: () => Promise<JsonValue>;
+        /** One simulation run with every case's result (history keeps no rule source or user ids). `GET /api/v1/sim/runs/{run_id}` */
+        getRun: (args: {
+            runId: string;
+        }) => Promise<JsonValue>;
+        /** The project's simulation runs, newest first; limit 1-100 (default 50) and offset page through them. `GET /api/v1/sim/runs` */
+        listRuns: (args?: {
+            limit?: JsonValue;
+            offset?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Real simulation runs used and allowed today (UTC) and this month; reading it uses nothing. `GET /api/v1/sim/quota` */
+        quota: () => Promise<JsonValue>;
+        /** Outcomes the team marked as intended for this project (shown green on every run, left out of findings). `GET /api/v1/sim/intended` */
+        listIntended: () => Promise<JsonValue>;
+        /** Mark an outcome as intended (role, action, resource, outcome ALLOW or DENY, optional note); needs policies.write. Marking the same role/action/resource again replaces it. `POST /api/v1/sim/intended` */
+        markIntended: (args: {
+            role: JsonValue;
+            action: JsonValue;
+            resource: JsonValue;
+            outcome: JsonValue;
+            note?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Remove an intended-outcome mark; matching cases show as measured again. Needs policies.write. `DELETE /api/v1/sim/intended/{mark_id}` */
+        unmarkIntended: (args: {
+            markId: string;
+        }) => Promise<JsonValue>;
+        /** Callers, gateway checks, sign-in, resources and connectors of the project (platform defences as one 'Platform protection' node). `GET /api/v1/sim/topology` */
+        topology: () => Promise<JsonValue>;
+        /** Everything the project has, read from every engine: tables in every schema it created, collections, buckets, secrets (names only), functions with their schedules, queues, workflows and triggers, sign-in providers, hooks, webhooks, channels, edge limits, backups, environments, domains, policies and plan headroom. Cached a minute; redacted by the caller's permissions. `GET /api/v1/sim/inventory` */
+        inventory: (args?: {
+            include?: JsonValue;
+            fresh?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** The checks catalogue: what is wrong or at risk (database, functions, storage, sign-in, edge, plan headroom, settings above the plan, realtime, backups, integrations, design), worst first, each with a fix. severity keeps that level and worse. `GET /api/v1/sim/checks` */
+        checks: (args?: {
+            severity?: JsonValue;
+            area?: JsonValue;
+            fresh?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** The architecture map: nodes by layer (clients, edge, identity, policies, services and data, async, external, resilience) with their status from the checks and the latest run, and the edges between them. `GET /api/v1/sim/graph` */
+        graph: (args?: {
+            fresh?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Every limit the project lives under, with its value and how it is counted. `GET /api/v1/sim/limits` */
+        limits: () => Promise<JsonValue>;
+        /** Run one integration flow under a programmed outcome: modelled (free, nothing sent) or sealed (real code path, recorded, one single-request check). `POST /api/v1/sim/integrations/run` */
+        integrationRun: (args: {
+            connectorId: JsonValue;
+            flowId: JsonValue;
+            outcome?: JsonValue;
+            mode?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Judge the 14 security drills from the project's configuration (optionally with a what-if draft that is never saved). `POST /api/v1/sim/drills/run` */
+        drillsRun: (args?: {
+            drillIds?: JsonValue;
+            overrides?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** What a run's sealed send points would have sent (secrets masked; message bodies need settings.manage). `GET /api/v1/sim/runs/{run_id}/artifacts` */
+        runArtifacts: (args: {
+            runId: string;
+        }) => Promise<JsonValue>;
+        /** A project snapshot for offline simulation (sov simulate offline): tables, row policies, functions, every case with the rules' verdict. `POST /api/v1/sim/snapshot` */
+        snapshot: (args?: {
+            includeRows?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    storage: {
+        /** `POST /api/v1/store/buckets` */
+        createBucket: (args: {
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+        /** `DELETE /api/v1/store/buckets/{name}` */
+        deleteBucket: (args: {
+            name: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/store/buckets/{name}` */
+        getBucket: (args: {
+            name: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/store/buckets` */
+        listBuckets: () => Promise<JsonValue>;
+        /** `POST /api/v1/store/objects/move` */
+        moveObject: (args: {
+            fromPath: JsonValue;
+            toPath: JsonValue;
+        }) => Promise<JsonValue>;
+        /** `PATCH /api/v1/store/buckets/{name}` */
+        updateBucket: (args: {
+            name: string;
+            body: JsonObject;
+        }) => Promise<JsonValue>;
+    };
+    templates: {
+        /** App templates (SaaS, marketplace, chat): what each creates, the tables it adds and its steps. Project team only. `GET /api/v1/templates` */
+        list: () => Promise<JsonValue>;
+        /** One app template, including the SQL its migration runs. `GET /api/v1/templates/{name}` */
+        get: (args: {
+            name: string;
+        }) => Promise<JsonValue>;
+        /** Apply a template to the project: its migration (tables + row-level security), buckets and their rules, realtime — each step with your own permissions, stopping at the first refusal. dry_run checks for tables that already exist and changes nothing. Needs database.admin. `POST /api/v1/governance/tenants/{org_id}/projects/{project_id}/templates/{name}/apply` */
+        apply: (args: {
+            orgId?: string;
+            projectId?: string;
+            name: string;
+            dryRun?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    traces: {
+        /** The project's recent refused (4xx) and failed (5xx) requests, each with who refused it, why and what to do (kind: denied, failed or all). Project team only. `GET /api/v1/request-traces` */
+        list: (args?: {
+            kind?: JsonValue;
+            before?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One request by its trace id (SovariaError.traceId, the X-Request-ID header): every hop — gateway checks, engine, SQL — and the explanation. `GET /api/v1/request-traces/{trace_id}` */
+        get: (args: {
+            traceId: string;
+        }) => Promise<JsonValue>;
+    };
+    triggers: {
+        /** Event triggers of the project's environment with the plan's trigger limits and the event sources. `GET /api/v1/fn/triggers` */
+        list: (args?: {
+            functionName?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Run a function when something happens: source db.document | db.row | auth.user | storage.object | realtime.message, event_types, resource (glob), subject_prefix, max_attempts. `POST /api/v1/fn/triggers` */
+        create: (args: {
+            functionName: JsonValue;
+            source: JsonValue;
+            eventTypes?: JsonValue;
+            resource?: JsonValue;
+            subjectPrefix?: JsonValue;
+            name?: JsonValue;
+            enabled?: JsonValue;
+            maxAttempts?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One event trigger. `GET /api/v1/fn/triggers/{trigger_id}` */
+        get: (args: {
+            triggerId: string;
+        }) => Promise<JsonValue>;
+        /** Change an event trigger (only the fields sent change). `PATCH /api/v1/fn/triggers/{trigger_id}` */
+        update: (args: {
+            triggerId: string;
+            changes: JsonObject;
+        }) => Promise<JsonValue>;
+        /** Delete an event trigger. `DELETE /api/v1/fn/triggers/{trigger_id}` */
+        delete: (args: {
+            triggerId: string;
+        }) => Promise<JsonValue>;
+        /** Queue one run with a sample event (counts as an invocation). `POST /api/v1/fn/triggers/{trigger_id}/test` */
+        test: (args: {
+            triggerId: string;
+        }) => Promise<JsonValue>;
+    };
+    vector: {
+        /** Delete an entire vector collection. `DELETE /api/v1/collections/{collection}` */
+        deleteCollection: (args: {
+            collection: string;
+        }) => Promise<JsonValue>;
+        /** Delete a record from a vector collection. `DELETE /api/v1/collections/{collection}/records/{record_id}` */
+        deleteRecord: (args: {
+            collection: string;
+            recordId: string;
+        }) => Promise<JsonValue>;
+        /** Generate embeddings for one or more texts. `POST /api/v1/embed` */
+        embed: (args: {
+            texts: JsonValue;
+        }) => Promise<JsonValue>;
+        /** List vector collections in the current project scope. `GET /api/v1/collections` */
+        listCollections: () => Promise<JsonValue>;
+        /** Embed and upsert documents into a vector collection. `POST /api/v1/vectors/upsert` */
+        upsert: (args: {
+            collection: JsonValue;
+            docs: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Collection settings. app_search: true lets the project's apps (anon key, signed-in users) search it; they can never write or list it. `PATCH /api/v1/collections/{collection}` */
+        setCollection: (args: {
+            collection: string;
+            appSearch?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Embed every stored text again with the project's current model (large collections need this after a model change). `POST /api/v1/collections/{collection}/reembed` */
+        reembedCollection: (args: {
+            collection: string;
+            force?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Search a SQL table: mode vector (nearest embeddings), keyword (full text) or hybrid (both, reciprocal rank fusion). text is embedded with the project's model when no vector is given. ef_search / probes tune recall, rerank reorders with the managed reranker, filter_in matches any of several values. Only rows the caller may read. `POST /api/v1/data/rel/vector/search` */
+        sqlSearch: (args: {
+            tableName: JsonValue;
+            columnName?: JsonValue;
+            vector?: JsonValue;
+            text?: JsonValue;
+            mode?: JsonValue;
+            textColumns?: JsonValue;
+            language?: JsonValue;
+            k?: JsonValue;
+            metric?: JsonValue;
+            select?: JsonValue;
+            filter?: JsonValue;
+            maxDistance?: JsonValue;
+            metadataFilter?: JsonValue;
+            metadataColumn?: JsonValue;
+            filterIn?: JsonValue;
+            efSearch?: JsonValue;
+            probes?: JsonValue;
+            rerank?: JsonValue;
+            rerankCandidates?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Tables whose vector column Sovaria keeps embedded, rows embedded and waiting, last error, and the project's model. `GET /api/v1/data/rel/vector/auto` */
+        sqlAutoStatus: () => Promise<JsonValue>;
+        /** Keep a vector column (created if missing) filled with embeddings of the source columns; edited rows are embedded again automatically. rebuild re-embeds the whole table. language sets the keyword index's text search configuration (e.g. english). `POST /api/v1/data/rel/vector/auto` */
+        sqlAutoEnable: (args: {
+            tableName: JsonValue;
+            columnName?: JsonValue;
+            sourceColumns: JsonValue;
+            rebuild?: JsonValue;
+            language?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Stop keeping a table's vectors up to date (the column and its vectors stay). `DELETE /api/v1/data/rel/vector/auto/{table_name}` */
+        sqlAutoDisable: (args: {
+            tableName: string;
+        }) => Promise<JsonValue>;
+        /** Embed waiting rows now instead of on the next background pass (up to limit per table). `POST /api/v1/data/rel/vector/auto/sync` */
+        sqlAutoSync: (args?: {
+            tableName?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** pgvector on the project database: available/enabled, vector columns, their indexes (method, metric, quantization, options, building/ready) and row estimates. Team only. `GET /api/v1/data/rel/vector/status` */
+        sqlStatus: () => Promise<JsonValue>;
+        /** Turn pgvector on (or off with enabled: false) for the project database. `POST /api/v1/data/rel/vector/enable` */
+        sqlEnable: (args?: {
+            enabled?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Create a documents table (id, content, metadata, embedding vector(n), optional owner_id with owner-only row policies) with an HNSW index. `POST /api/v1/data/rel/vector/tables` */
+        sqlCreateTable: (args: {
+            tableName: JsonValue;
+            dimensions: JsonValue;
+            ownerRows?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Add a vector(n) column to an existing table. `POST /api/v1/data/rel/vector/columns` */
+        sqlAddColumn: (args: {
+            tableName: JsonValue;
+            columnName?: JsonValue;
+            dimensions: JsonValue;
+        }) => Promise<JsonValue>;
+        /** HNSW (m, ef_construction) or IVFFlat (lists) index, cosine / l2 / inner_product; built CONCURRENTLY in the background by default; halfvec above 2,000 dimensions. `POST /api/v1/data/rel/vector/indexes` */
+        sqlCreateIndex: (args: {
+            tableName: JsonValue;
+            columnName?: JsonValue;
+            metric?: JsonValue;
+            method?: JsonValue;
+            m?: JsonValue;
+            efConstruction?: JsonValue;
+            lists?: JsonValue;
+            concurrently?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Insert rows whose vector column is a number array; embed: true embeds rows without a vector in the request (automatic-embeddings tables, small batches). `POST /api/v1/data/rel/vector/rows` */
+        sqlInsertRows: (args: {
+            tableName: JsonValue;
+            columnName?: JsonValue;
+            rows: JsonValue;
+            embed?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+    workflows: {
+        /** Start a durable workflow run of a function that uses context.step; key makes the start idempotent; max_attempts sets the tries per step (plan fn.trigger_max_attempts). `POST /api/v1/fn/workflows` */
+        start: (args: {
+            functionName: JsonValue;
+            input?: JsonValue;
+            key?: JsonValue;
+            maxAttempts?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Workflow runs, newest first, with the plan's workflow limits. `GET /api/v1/fn/workflows` */
+        list: (args?: {
+            functionName?: JsonValue;
+            status?: JsonValue;
+            before?: JsonValue;
+            limit?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** One run: status, input, output or error, and every finished step with its result. `GET /api/v1/fn/workflows/{run_id}` */
+        get: (args: {
+            runId: string;
+        }) => Promise<JsonValue>;
+        /** Wake step.waitForSignal(name) with data (kept until the run waits for it). `POST /api/v1/fn/workflows/{run_id}/signal` */
+        signal: (args: {
+            runId: string;
+            name: JsonValue;
+            data?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Stop an unfinished run for good. `POST /api/v1/fn/workflows/{run_id}/cancel` */
+        cancel: (args: {
+            runId: string;
+        }) => Promise<JsonValue>;
+        /** Resume a failed run from its failed step; latest moves it to the live function version. `POST /api/v1/fn/workflows/{run_id}/retry` */
+        retry: (args: {
+            runId: string;
+            latest?: JsonValue;
+        }) => Promise<JsonValue>;
+    };
+};
+export type GeneratedApi = ReturnType<typeof createGeneratedApi>;
+export {};