@xkova/sdk 0.1.0-alpha.1

package/dist/resources/tokenization.js

@@ -0,0 +1,126 @@
+import { Resource } from './base.js';
+export class TokenizationResource extends Resource {
+    deployErc20(body, opts) {
+        return this.postJson('/tokenization/erc20', body, opts);
+    }
+    deployErc721(body, opts) {
+        return this.postJson('/tokenization/erc721', body, opts);
+    }
+    deployErc1155(body, opts) {
+        return this.postJson('/tokenization/erc1155', body, opts);
+    }
+    list(query = {}) {
+        return this.getJson('/tokenization/tokens', query);
+    }
+    retrieve(id) {
+        return this.getJson(`/tokenization/tokens/${this.enc(id)}`);
+    }
+    mint(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/mint`, body, opts);
+    }
+    burn(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/burn`, body, opts);
+    }
+    listAuthorities(query = {}) {
+        return this.getJson('/tokenization/authorities', query);
+    }
+    registerAuthority(body, opts) {
+        return this.postJson('/tokenization/authorities', body, opts);
+    }
+    getAuthority(id) {
+        return this.getJson(`/tokenization/authorities/${this.enc(id)}`);
+    }
+    submitAuthorityProof(id, body, opts) {
+        return this.postJson(`/tokenization/authorities/${this.enc(id)}/proof`, body, opts);
+    }
+    issueAuthorityProofChallenge(id, opts) {
+        return this.postJson(`/tokenization/authorities/${this.enc(id)}/proof-challenge`, undefined, opts);
+    }
+    createControlSafe(body, opts) {
+        return this.postJson('/tokenization/authorities/control-safes', body, opts);
+    }
+    accessListAdd(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/access-list/add`, body, opts);
+    }
+    accessListRemove(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/access-list/remove`, body, opts);
+    }
+    enableAccessRegistry(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/access-registry`, body, opts);
+    }
+    disableAccessRegistry(id, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/access-registry/disable`, undefined, opts);
+    }
+    listContracts(id) {
+        return this.getJson(`/tokenization/tokens/${this.enc(id)}/contracts`);
+    }
+    read(id, query) {
+        return this.getJson(`/tokenization/tokens/${this.enc(id)}/read`, query);
+    }
+    resumeDeploy(id, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/deploy/resume`, undefined, opts);
+    }
+    deprecate(id, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/deprecate`, undefined, opts);
+    }
+    relayGaslessTransfer(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/gasless/relay`, body, opts);
+    }
+    buildGaslessTransferRequest(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/gasless/transfer-request`, body, opts);
+    }
+    relayNftTransfer(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/nft-transfers`, body, opts);
+    }
+    buildNftTransferRequest(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/nft-transfers/build`, body, opts);
+    }
+    listOperations(id, query = {}) {
+        return this.getJson(`/tokenization/tokens/${this.enc(id)}/operations`, query);
+    }
+    getOperation(id, opId) {
+        return this.getJson(`/tokenization/tokens/${this.enc(id)}/operations/${this.enc(opId)}`);
+    }
+    submitModuleSignature(id, opId, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/operations/${this.enc(opId)}/module-signature`, body, opts);
+    }
+    submitOperationSignature(id, opId, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/operations/${this.enc(opId)}/signatures`, body, opts);
+    }
+    pause(id, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/pause`, undefined, opts);
+    }
+    unpause(id, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/unpause`, undefined, opts);
+    }
+    setMintPolicy(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/policies`, body, opts);
+    }
+    revokeMintPolicy(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/policies/revoke`, body, opts);
+    }
+    buildPolicyMint(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/policy-mint`, body, opts);
+    }
+    rawSafeTx(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/raw-safe-tx`, body, opts);
+    }
+    recover(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/recover`, body, opts);
+    }
+    grantRole(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/roles/grant`, body, opts);
+    }
+    revokeRole(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/roles/revoke`, body, opts);
+    }
+    disableForTreasury(id, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/treasury-disable`, undefined, opts);
+    }
+    enableForTreasury(id, body, opts) {
+        return this.postJson(`/tokenization/tokens/${this.enc(id)}/treasury-enable`, body, opts);
+    }
+    treasuryStatus(id) {
+        return this.getJson(`/tokenization/tokens/${this.enc(id)}/treasury-status`);
+    }
+}

package/dist/resources/transactions.d.ts

@@ -0,0 +1,8 @@
+import { Resource, type Query } from './base.js';
+export declare class TransactionsResource extends Resource {
+    list(query?: Query<'listTransactions'>): Promise<{
+        data: import("../generated/types.js").components["schemas"]["Transaction"][];
+        next_cursor: string | null;
+        has_more: boolean;
+    }>;
+}

package/dist/resources/transactions.js

@@ -0,0 +1,6 @@
+import { Resource } from './base.js';
+export class TransactionsResource extends Resource {
+    list(query = {}) {
+        return this.getJson('/transactions', query);
+    }
+}

package/dist/resources/wallets.d.ts

@@ -0,0 +1,56 @@
+import { Resource, type Query, type ReqBody } from './base.js';
+import type { XKOVAMutationOptions } from '../client.js';
+export declare class WalletsResource extends Resource {
+    retrieve(id: string): Promise<{
+        id: import("../generated/types.js").components["schemas"]["WalletId"];
+        tenant_id: string;
+        account_holder_id: import("../generated/types.js").components["schemas"]["AccountHolderId"];
+        address: string;
+        chain_id: string;
+        chain: import("../generated/types.js").components["schemas"]["ChainDescriptor"];
+        custody_model: "custodial" | "non_custodial";
+        provider: string;
+        state: "active" | "decommissioned";
+        monitoring_status: "pending_live" | "catching_up" | "ready" | "halted";
+        created_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    }>;
+    balance(id: string, query: Query<'getWalletBalance'>): Promise<{
+        chain_id: number;
+        wallet: string;
+        token: string;
+        balance: string;
+        last_updated_block: string;
+        last_updated_tx: string;
+    }>;
+    listHistory(id: string, query?: Query<'listWalletHistory'>): Promise<{
+        data: import("../generated/types.js").components["schemas"]["WalletTransactionSummary"][];
+        next_cursor?: string | null;
+        has_more: boolean;
+    }>;
+    listLedger(id: string, query?: Query<'listWalletLedger'>): Promise<{
+        data: unknown[];
+        next_cursor: string | null;
+        has_more: boolean;
+    } & {
+        data?: import("../generated/types.js").components["schemas"]["LedgerEntry"][];
+    }>;
+    decommission(id: string, opts?: XKOVAMutationOptions): Promise<{
+        id: import("../generated/types.js").components["schemas"]["WalletId"];
+        tenant_id: string;
+        account_holder_id: import("../generated/types.js").components["schemas"]["AccountHolderId"];
+        address: string;
+        chain_id: string;
+        chain: import("../generated/types.js").components["schemas"]["ChainDescriptor"];
+        custody_model: "custodial" | "non_custodial";
+        provider: string;
+        state: "active" | "decommissioned";
+        monitoring_status: "pending_live" | "catching_up" | "ready" | "halted";
+        created_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    }>;
+    generateReceiveQr(id: string, body?: ReqBody<'generateReceiveQr'>, opts?: XKOVAMutationOptions): Promise<{
+        uri?: string;
+        png_data_url?: string;
+    }>;
+}

package/dist/resources/wallets.js

@@ -0,0 +1,21 @@
+import { Resource } from './base.js';
+export class WalletsResource extends Resource {
+    retrieve(id) {
+        return this.getJson(`/wallets/${this.enc(id)}`);
+    }
+    balance(id, query) {
+        return this.getJson(`/wallets/${this.enc(id)}/balance`, query);
+    }
+    listHistory(id, query = {}) {
+        return this.getJson(`/wallets/${this.enc(id)}/history`, query);
+    }
+    listLedger(id, query = {}) {
+        return this.getJson(`/wallets/${this.enc(id)}/ledger`, query);
+    }
+    decommission(id, opts) {
+        return this.postJson(`/wallets/${this.enc(id)}/decommission`, undefined, opts);
+    }
+    generateReceiveQr(id, body = {}, opts) {
+        return this.postJson(`/wallets/${this.enc(id)}/qr`, body, opts);
+    }
+}

package/dist/resources/webhooks.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Verify incoming deliveries with `verifyWebhookSignature` from
+ * `@xkova/sdk/webhook` before processing them. It checks HMAC-SHA256 signatures.
+ */
+import { Resource, type ReqBody, type Query } from './base.js';
+import type { XKOVAMutationOptions } from '../client.js';
+export declare class WebhooksResource extends Resource {
+    list(query?: Query<'listWebhookEndpoints'>): Promise<{
+        data: unknown[];
+        next_cursor: string | null;
+        has_more: boolean;
+    } & {
+        data?: import("../generated/types.js").components["schemas"]["WebhookEndpoint"][];
+    }>;
+    create(body: ReqBody<'createWebhookEndpoint'>, opts?: XKOVAMutationOptions): Promise<{
+        id?: import("../generated/types.js").components["schemas"]["WebhookEndpointId"];
+        url?: string;
+        events?: string[];
+        hmac_secret_fingerprint?: string;
+        previous_hmac_secret_fingerprint?: string | null;
+        previous_secret_retired_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        enabled?: boolean;
+        created_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    } & {
+        secret?: string;
+    }>;
+    retrieve(id: string): Promise<{
+        id?: import("../generated/types.js").components["schemas"]["WebhookEndpointId"];
+        url?: string;
+        events?: string[];
+        hmac_secret_fingerprint?: string;
+        previous_hmac_secret_fingerprint?: string | null;
+        previous_secret_retired_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        enabled?: boolean;
+        created_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    }>;
+    update(id: string, body: ReqBody<'updateWebhookEndpoint'>, opts?: XKOVAMutationOptions): Promise<{
+        id?: import("../generated/types.js").components["schemas"]["WebhookEndpointId"];
+        url?: string;
+        events?: string[];
+        hmac_secret_fingerprint?: string;
+        previous_hmac_secret_fingerprint?: string | null;
+        previous_secret_retired_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        enabled?: boolean;
+        created_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    }>;
+    delete(id: string, opts?: XKOVAMutationOptions): Promise<void>;
+    rotateSecret(id: string, opts?: XKOVAMutationOptions): Promise<{
+        id?: import("../generated/types.js").components["schemas"]["WebhookEndpointId"];
+        url?: string;
+        events?: string[];
+        hmac_secret_fingerprint?: string;
+        previous_hmac_secret_fingerprint?: string | null;
+        previous_secret_retired_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        enabled?: boolean;
+        created_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    } & {
+        secret?: string;
+    }>;
+    test(id: string, opts?: XKOVAMutationOptions): Promise<{
+        delivered: boolean;
+        status_code: number | null;
+        duration_ms: number;
+        error: string | null;
+    }>;
+    listEventTypes(): Promise<{
+        data?: import("../generated/types.js").components["schemas"]["WebhookEventType"][];
+    }>;
+    listDeliveries(query?: Query<'listWebhookDeliveries'>): Promise<{
+        data: unknown[];
+        next_cursor: string | null;
+        has_more: boolean;
+    } & {
+        data?: import("../generated/types.js").components["schemas"]["WebhookDelivery"][];
+    }>;
+    retrieveDelivery(id: string): Promise<{
+        id?: import("../generated/types.js").components["schemas"]["WebhookDeliveryId"];
+        webhook_endpoint_id?: import("../generated/types.js").components["schemas"]["WebhookEndpointId"];
+        event?: string;
+        payload?: import("../generated/types.js").components["schemas"]["WebhookEventEnvelope"];
+        attempt_count?: number;
+        status?: "pending" | "delivered" | "failed" | "dlq";
+        last_status_code?: number | null;
+        last_response_body?: string | null;
+        next_retry_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        delivered_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        correlation_id?: import("../generated/types.js").components["schemas"]["CorrelationId"];
+        created_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    }>;
+    replayDelivery(id: string, opts?: XKOVAMutationOptions): Promise<{
+        id?: import("../generated/types.js").components["schemas"]["WebhookDeliveryId"];
+        webhook_endpoint_id?: import("../generated/types.js").components["schemas"]["WebhookEndpointId"];
+        event?: string;
+        payload?: import("../generated/types.js").components["schemas"]["WebhookEventEnvelope"];
+        attempt_count?: number;
+        status?: "pending" | "delivered" | "failed" | "dlq";
+        last_status_code?: number | null;
+        last_response_body?: string | null;
+        next_retry_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        delivered_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        correlation_id?: import("../generated/types.js").components["schemas"]["CorrelationId"];
+        created_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    }>;
+    bulkReplayDeliveries(body: ReqBody<'bulkReplayWebhookDeliveries'>, opts?: XKOVAMutationOptions): Promise<{
+        data: import("../generated/types.js").components["schemas"]["WebhookDelivery"][];
+        replayed_count: number;
+        skipped_count: number;
+    }>;
+}

package/dist/resources/webhooks.js

@@ -0,0 +1,43 @@
+/**
+ * Verify incoming deliveries with `verifyWebhookSignature` from
+ * `@xkova/sdk/webhook` before processing them. It checks HMAC-SHA256 signatures.
+ */
+import { Resource } from './base.js';
+export class WebhooksResource extends Resource {
+    list(query = {}) {
+        return this.getJson('/webhook-endpoints', query);
+    }
+    create(body, opts) {
+        return this.postJson('/webhook-endpoints', body, opts);
+    }
+    retrieve(id) {
+        return this.getJson(`/webhook-endpoints/${this.enc(id)}`);
+    }
+    update(id, body, opts) {
+        return this.patchJson(`/webhook-endpoints/${this.enc(id)}`, body, opts);
+    }
+    delete(id, opts) {
+        return this.deleteJson(`/webhook-endpoints/${this.enc(id)}`, opts);
+    }
+    rotateSecret(id, opts) {
+        return this.postJson(`/webhook-endpoints/${this.enc(id)}/rotate`, undefined, opts);
+    }
+    test(id, opts) {
+        return this.postJson(`/webhook-endpoints/${this.enc(id)}/test`, undefined, opts);
+    }
+    listEventTypes() {
+        return this.getJson('/webhook-event-types');
+    }
+    listDeliveries(query = {}) {
+        return this.getJson('/webhook-deliveries', query);
+    }
+    retrieveDelivery(id) {
+        return this.getJson(`/webhook-deliveries/${this.enc(id)}`);
+    }
+    replayDelivery(id, opts) {
+        return this.postJson(`/webhook-deliveries/${this.enc(id)}/replay`, undefined, opts);
+    }
+    bulkReplayDeliveries(body, opts) {
+        return this.postJson('/webhook-deliveries/bulk-replay', body, opts);
+    }
+}

package/dist/resources/workflows.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Workflow helpers call resource methods and poll their results. Member
+ * signing requires a separate authorization through `@xkova/sdk/member-bff`.
+ */
+import type { XKOVAClient, XKOVAMutationOptions } from '../client.js';
+import type { Ok, ReqBody } from './base.js';
+export interface PollOptions {
+    /** Max poll attempts before giving up (default 30). */
+    attempts?: number;
+    /** Delay between attempts in ms (default 2000). */
+    intervalMs?: number;
+    /** Cancels polling and any pending interval. */
+    signal?: AbortSignal;
+}
+export declare class WorkflowClient {
+    private readonly client;
+    constructor(client: XKOVAClient);
+    /**
+     * Deploy a token and wait for on-chain confirmation.
+     * The deploy poller auto-registers the token on the payment router.
+     */
+    tokenDeploy(standard: 'erc20', body: ReqBody<'deployCustomerErc20'>, opts?: XKOVAMutationOptions & {
+        poll?: PollOptions;
+    }): Promise<Ok<'getCustomerToken'>>;
+    tokenDeploy(standard: 'erc721', body: ReqBody<'deployCustomerErc721'>, opts?: XKOVAMutationOptions & {
+        poll?: PollOptions;
+    }): Promise<Ok<'getCustomerToken'>>;
+    tokenDeploy(standard: 'erc1155', body: ReqBody<'deployCustomerErc1155'>, opts?: XKOVAMutationOptions & {
+        poll?: PollOptions;
+    }): Promise<Ok<'getCustomerToken'>>;
+    /** Mint to a holder and wait for confirmation. */
+    tokenMint(tokenId: string, body: ReqBody<'mintCustomerToken'>, opts?: XKOVAMutationOptions & {
+        poll?: PollOptions;
+    }): Promise<Ok<'getCustomerToken'>>;
+    /**
+     * Off-ramp: resolve the burn address and create the request. The member then
+     * burns stablecoin to the returned address out-of-band; poll
+     * `client.ramps.getOffRamp(id)` for settlement.
+     */
+    offRampInitiate(chainRef: string, body: ReqBody<'createOffRampRequest'>, opts?: XKOVAMutationOptions): Promise<{
+        request: Ok<'createOffRampRequest'>;
+        burnAddress: Ok<'getOffRampBurnAddress'>;
+    }>;
+}

package/dist/resources/workflows.js

@@ -0,0 +1,70 @@
+const DEFAULT_POLL = { attempts: 30, intervalMs: 2000 };
+const SUCCESS = new Set(['confirmed', 'completed', 'settled', 'succeeded', 'deployed', 'active']);
+const FAILURE = new Set(['failed', 'reverted', 'cancelled', 'canceled', 'expired', 'rejected']);
+export class WorkflowClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async tokenDeploy(standard, body, opts = {}) {
+        const t = this.client.tokenization;
+        const deployed = standard === 'erc20'
+            ? await t.deployErc20(body, opts)
+            : standard === 'erc721'
+                ? await t.deployErc721(body, opts)
+                : await t.deployErc1155(body, opts);
+        const tokenId = readString(deployed, 'customer_token_id');
+        return pollEntity(() => t.retrieve(tokenId), pollOptions(opts.poll, opts.signal), 'token');
+    }
+    /** Mint to a holder and wait for confirmation. */
+    async tokenMint(tokenId, body, opts = {}) {
+        await this.client.tokenization.mint(tokenId, body, opts);
+        return pollEntity(() => this.client.tokenization.retrieve(tokenId), pollOptions(opts.poll, opts.signal), 'token');
+    }
+    /**
+     * Off-ramp: resolve the burn address and create the request. The member then
+     * burns stablecoin to the returned address out-of-band; poll
+     * `client.ramps.getOffRamp(id)` for settlement.
+     */
+    async offRampInitiate(chainRef, body, opts = {}) {
+        const burnAddress = await this.client.ramps.offRampBurnAddress({ chain_ref: chainRef });
+        const request = await this.client.ramps.createOffRamp(body, opts);
+        return { request, burnAddress };
+    }
+}
+function pollOptions(poll, signal) {
+    return { ...poll, ...(signal !== undefined && { signal }) };
+}
+function readString(obj, key) {
+    const v = obj?.[key];
+    if (typeof v !== 'string' || v.length === 0) {
+        throw new Error(`expected string field "${key}" on response`);
+    }
+    return v;
+}
+async function pollEntity(fetchOne, poll, label) {
+    const { attempts, intervalMs, signal } = { ...DEFAULT_POLL, ...poll };
+    let last;
+    for (let i = 0; i < attempts; i++) {
+        signal?.throwIfAborted();
+        last = await fetchOne();
+        const status = String(last?.['status'] ?? '');
+        if (SUCCESS.has(status))
+            return last;
+        if (FAILURE.has(status)) {
+            throw new Error(`${label} reached terminal failure status: ${status}`);
+        }
+        await sleep(intervalMs, signal);
+    }
+    throw new Error(`${label} did not reach a terminal status after ${attempts} attempts`);
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        signal?.throwIfAborted();
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        }, { once: true });
+    });
+}

package/dist/resources/workspace-tokens.d.ts

@@ -0,0 +1,6 @@
+import { Resource } from './base.js';
+export declare class WorkspaceTokensResource extends Resource {
+    list(): Promise<{
+        data: import("../generated/types.js").components["schemas"]["WorkspaceToken"][];
+    }>;
+}

package/dist/resources/workspace-tokens.js

@@ -0,0 +1,6 @@
+import { Resource } from './base.js';
+export class WorkspaceTokensResource extends Resource {
+    list() {
+        return this.getJson('/workspace-tokens');
+    }
+}

package/dist/resources/workspaces.d.ts

@@ -0,0 +1,25 @@
+import { Resource, type ReqBody } from './base.js';
+import type { XKOVAMutationOptions } from '../client.js';
+export declare class WorkspacesResource extends Resource {
+    list(): Promise<{
+        data: import("../generated/types.js").components["schemas"]["Workspace"][];
+    }>;
+    retrieve(id: string): Promise<{
+        id: string;
+        tenant_id: string;
+        type: "sandbox" | "production";
+        name?: string | null;
+        status: "pending_setup" | "active" | "archived";
+        created_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    }>;
+    update(id: string, body: ReqBody<'updateWorkspace'>, opts?: XKOVAMutationOptions): Promise<{
+        id: string;
+        tenant_id: string;
+        type: "sandbox" | "production";
+        name?: string | null;
+        status: "pending_setup" | "active" | "archived";
+        created_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    }>;
+}

package/dist/resources/workspaces.js

@@ -0,0 +1,12 @@
+import { Resource } from './base.js';
+export class WorkspacesResource extends Resource {
+    list() {
+        return this.getJson('/workspaces');
+    }
+    retrieve(id) {
+        return this.getJson(`/workspaces/${this.enc(id)}`);
+    }
+    update(id, body, opts) {
+        return this.patchJson(`/workspaces/${this.enc(id)}`, body, opts);
+    }
+}

package/dist/retry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Retries are explicit because a failed response can hide a successful write.
+ * For mutations, keep the input and idempotency key unchanged across attempts.
+ */
+export interface RetryPolicy<E = unknown> {
+    /** Hard cap on attempts including the first. */
+    maxAttempts: number;
+    /** Delays between attempts. The last repeats if needed; an empty list means no delay. */
+    delaysMs: readonly number[];
+    /** Multiplicative jitter factor; default 0.25. Set to 0 for deterministic tests. */
+    jitter?: number;
+    /** Decide whether an error is worth retrying. Default: every error retries. */
+    isRetryable?: (err: E) => boolean;
+    /** Runs after a retryable failure, before the next attempt. */
+    onAttempt?: (attempt: number, err: E) => void;
+    /** Hook for logging/metrics when retries are exhausted. */
+    onExhausted?: (err: E) => void;
+    /** Override the timer to avoid real delays in tests. */
+    sleep?: (ms: number) => Promise<void>;
+}
+export declare function withRetry<T, E = unknown>(fn: () => Promise<T>, policy: RetryPolicy<E>): Promise<T>;

package/dist/retry.js

@@ -0,0 +1,44 @@
+/**
+ * Retries are explicit because a failed response can hide a successful write.
+ * For mutations, keep the input and idempotency key unchanged across attempts.
+ */
+export async function withRetry(fn, policy) {
+    if (policy.maxAttempts < 1) {
+        throw new Error('withRetry: maxAttempts must be >= 1');
+    }
+    const sleep = policy.sleep ?? defaultSleep;
+    const isRetryable = policy.isRetryable ?? (() => true);
+    const jitter = policy.jitter ?? 0.25;
+    let lastErr;
+    for (let attempt = 1; attempt <= policy.maxAttempts; attempt += 1) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            if (!isRetryable(lastErr))
+                throw err;
+            if (attempt === policy.maxAttempts)
+                break;
+            policy.onAttempt?.(attempt, lastErr);
+            const baseDelay = pickDelay(policy.delaysMs, attempt - 1);
+            await sleep(applyJitter(baseDelay, jitter));
+        }
+    }
+    policy.onExhausted?.(lastErr);
+    throw lastErr;
+}
+function pickDelay(delays, idx) {
+    if (delays.length === 0)
+        return 0;
+    return delays[Math.min(idx, delays.length - 1)] ?? 0;
+}
+function applyJitter(baseMs, factor) {
+    if (factor <= 0)
+        return baseMs;
+    const delta = baseMs * factor;
+    return Math.max(0, baseMs + (Math.random() * 2 - 1) * delta);
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}