@sovaria/sdk 0.0.0-stage → 0.4.0

package/dist/generated.d.ts

@@ -0,0 +1,1227 @@
+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): {
+    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>;
+    };
+    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>;
+    };
+    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>;
+    };
+    crashes: {
+        /** App crash issues of the project (grouped reports from sov.crashes), newest first, with the plan's limits. `GET /api/v1/crashes/issues` */
+        listIssues: (args?: {
+            status?: JsonValue;
+            limit?: 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 accepted and dropped this month, and the plan's limits. `GET /api/v1/crashes/usage` */
+        usage: () => 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>;
+    };
+    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>;
+    };
+    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>;
+    };
+    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>;
+    };
+    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. `POST /api/v1/chrono/timelines/converge` */
+        converge: (args: {
+            target: JsonValue;
+            source: JsonValue;
+            author: JsonValue;
+            message?: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Create a system snapshot. `POST /api/v1/chrono/snapshots/create` */
+        createSnapshot: (args: {
+            message: JsonValue;
+        }) => Promise<JsonValue>;
+        /** Delete a timeline. `DELETE /api/v1/chrono/timelines/{name}` */
+        deleteTimeline: (args: {
+            name: string;
+        }) => Promise<JsonValue>;
+        /** Force-jump a timeline head. `POST /api/v1/chrono/timelines/{name}/jump` */
+        jumpTimeline: (args: {
+            name: string;
+            targetHex: JsonValue;
+        }) => Promise<JsonValue>;
+        /** List known snapshots. `GET /api/v1/chrono/snapshots` */
+        listSnapshots: () => Promise<JsonValue>;
+        /** List available timelines. `GET /api/v1/chrono/timelines` */
+        listTimelines: () => Promise<JsonValue>;
+        /** Restore a snapshot by id. `POST /api/v1/chrono/snapshots/{snapshot_id}/restore` */
+        restoreSnapshot: (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>;
+    };
+    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. Runs in the background; 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;
+        }) => 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>;
+    };
+    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>;
+    };
+    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>;
+        /** `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>;
+    };
+    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>;
+    };
+    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>;
+    };
+    simulation: {
+        /** `GET /api/v1/sim/runs/{target_run_id}/compare/{baseline_run_id}` */
+        compareRuns: (args: {
+            targetRunId: string;
+            baselineRunId: string;
+        }) => Promise<JsonValue>;
+        /** `POST /api/v1/sim/discover` */
+        discover: () => Promise<JsonValue>;
+        /** `GET /api/v1/sim/runs/{run_id}` */
+        getRun: (args: {
+            runId: string;
+        }) => Promise<JsonValue>;
+        /** `GET /api/v1/sim/runs` */
+        listRuns: (args?: {
+            limit?: JsonValue;
+            offset?: 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>;
+    };
+    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. 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;
+        }) => 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. `POST /api/v1/data/rel/vector/auto` */
+        sqlAutoEnable: (args: {
+            tableName: JsonValue;
+            columnName?: JsonValue;
+            sourceColumns: JsonValue;
+            rebuild?: 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>;
+    };
+    workflows: {
+        /** Start a durable workflow run of a function that uses context.step; key makes the start idempotent. `POST /api/v1/fn/workflows` */
+        start: (args: {
+            functionName: JsonValue;
+            input?: JsonValue;
+            key?: 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 {};