@receiz/sdk 97.0.0 → 97.2.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { buildReceizIdContinueRequest, createReceizIdIdentity, projectReceizIdentityAccount, readReceizIdentityArtifact, signReceizIdentityLoginProof, verifyReceizIdentityLoginProof, type ReceizDeviceIdentity, type ReceizIdContinueOptions } from "./identity.js";
 export * from "./identity.js";
-export declare const RECEIZ_SDK_VERSION = "97.0.0";
+export declare const RECEIZ_SDK_VERSION = "97.2.0";
 export declare const RECEIZ_DEFAULT_BASE_URL = "https://receiz.com";
 export declare const RECEIZ_WEBHOOK_SIGNATURE_HEADER = "x-receiz-signature";
 export declare const RECEIZ_WEBHOOK_TIMESTAMP_HEADER = "x-receiz-timestamp";
@@ -95,7 +95,7 @@ export type DocumentSealResponseMetadata = {
     proofBundle?: ReceizProofBundle | null;
     [key: string]: unknown;
 };
-export type PublicProofRecord = {
+export type PublicProofRecord<TData extends JsonObject = JsonObject> = {
     ok?: boolean;
     id?: string;
     sourceUrl?: string;
@@ -106,7 +106,7 @@ export type PublicProofRecord = {
     appObjectId?: string | null;
     createdAt?: string;
     record?: JsonObject | null;
-    data?: JsonObject | null;
+    data?: TData | null;
     proof?: JsonObject | null;
     [key: string]: unknown;
 };
@@ -122,14 +122,14 @@ export type PublicProofRegistryFeed = {
     signature?: string;
     [key: string]: unknown;
 };
-export type ReceizPublicProjectionRecord = PublicProofRecord & {
+export type ReceizPublicProjectionRecord<TData extends JsonObject = JsonObject> = PublicProofRecord<TData> & {
     schema?: string | null;
     state?: string | null;
     platform?: string | null;
     appNamespace?: string | null;
     appObjectId?: string | null;
     record?: JsonObject | null;
-    data?: JsonObject | null;
+    data?: TData | null;
 };
 export type ReceizAppStateRecord = {
     id: string;
@@ -170,24 +170,319 @@ export type ReceizAppStatePublishRecordOptions = {
     externalCreatorId?: string;
     signature?: string;
 };
-export type ReceizAppStateFeedResponse = {
+export type ReceizAppStateFeedOptions = {
+    schema?: string;
+    namespace?: string;
+    externalCreatorId?: string;
+};
+export type ReceizPublicStoreStateRecordInput = {
+    id?: string;
+    sourceUrl: string;
+    externalCreatorId?: string;
+    title?: string;
+    namespace?: string;
+    state?: string;
+    schema?: string;
+    platform?: string;
+    record?: JsonObject | null;
+    data: JsonObject;
+    [key: string]: unknown;
+};
+export type ReceizAppStateFeedResponse<TData extends JsonObject = JsonObject> = {
     ok: boolean;
     accepted?: number;
     rejected?: number;
-    records?: ReceizPublicProjectionRecord[];
+    records?: ReceizPublicProjectionRecord<TData>[];
     error?: string;
     [key: string]: unknown;
 };
-export type ReceizAppStateRecordResponse = {
+export type ReceizAppStateRecordResponse<TData extends JsonObject = JsonObject> = {
+    ok: boolean;
+    record: ReceizPublicProjectionRecord<TData> | null;
+    [key: string]: unknown;
+};
+export type ReceizAppStateCollectionResponse<TData extends JsonObject = JsonObject> = {
+    ok: boolean;
+    records: ReceizPublicProjectionRecord<TData>[];
+    [key: string]: unknown;
+};
+export type ReceizAppStateRestoreOptions = {
+    schema?: string;
+    state?: string;
+    requiredDataKey?: string;
+};
+export type ReceizAppStateRestoreResult<TData extends JsonObject = JsonObject> = {
+    ok: boolean;
+    record: ReceizPublicProjectionRecord<TData> | null;
+    data: TData | null;
+    error?: string;
+};
+export type ReceizAppStateTenantPublishInput = {
+    tenantHost: string;
+    creatorReceizId?: string;
+    externalCreatorId?: string;
+    title?: string;
+    schema?: string;
+    schemaVersion?: number;
+    platform?: string;
+    state: JsonObject;
+    record?: JsonObject | null;
+    data?: JsonObject;
+    sourceUrl?: string;
+    id?: string;
+    namespace?: string;
+    projectionState?: string;
+    visibility?: "public" | "private";
+    idempotencyKey?: string;
+    [key: string]: unknown;
+};
+export type ReceizAppStatePublishInput = ReceizAppStateFeed | ReceizAppStateTenantPublishInput;
+export type ReceizAppStateResolveInput = ReceizAppStateRestoreOptions & {
+    url?: string;
+    host?: string;
+    tenantHost?: string;
+    id?: string;
+    namespace?: string;
+    creatorReceizId?: string;
+    receizId?: string;
+    migrateTo?: number;
+};
+export type ReceizAppStateResolveResult<TData extends JsonObject = JsonObject> = ReceizAppStateRestoreResult<TData> & {
+    records?: ReceizPublicProjectionRecord<TData>[];
+};
+export type ReceizCapabilityKey = "identity" | "wallet" | "payments" | "proofStore" | "media" | "domains" | "twin" | "commerce" | "rewards" | "events" | "search" | "permissions" | "jobs" | "audit" | "risk" | "compliance" | "portability" | "notifications" | "offline" | "releases";
+export type ReceizCapabilityStatus = "available" | "missing" | "unknown";
+export type ReceizCapability = {
+    available: boolean;
+    status: ReceizCapabilityStatus;
+    reason?: string;
+    fixUrl?: string;
+    [key: string]: unknown;
+};
+export type ReceizCapabilities = {
+    ok: true;
+    schema: "receiz.sdk.capabilities.v1";
+    baseUrl: string;
+    tenantHost?: string;
+    scopes: string[];
+    capabilities: Record<ReceizCapabilityKey, ReceizCapability>;
+};
+export type ReceizCapabilitiesOptions = {
+    tenantHost?: string;
+    callbackUrl?: string;
+    scopes?: string[];
+};
+export type ReceizDoctorIssue = {
+    code: string;
+    message: string;
+    fixUrl?: string;
+};
+export type ReceizDoctorReport = {
     ok: boolean;
-    record: ReceizPublicProjectionRecord | null;
+    schema: "receiz.sdk.doctor.v1";
+    baseUrl: string;
+    tenantHost?: string;
+    capabilities: ReceizCapabilities["capabilities"];
+    missing: ReceizDoctorIssue[];
+    warnings: ReceizDoctorIssue[];
+    fixes: ReceizDoctorIssue[];
+};
+export type ReceizCommerceCartItem = {
+    id: string;
+    title?: string;
+    quantity: number;
+    amountUsd?: string;
+    amountUsdCents?: string;
+    [key: string]: unknown;
+};
+export type ReceizCommerceCart = {
+    items: ReceizCommerceCartItem[];
+    [key: string]: unknown;
+};
+export type ReceizOneClickCheckoutRequest = {
+    tenantHost: string;
+    orderId?: string;
+    amountUsd: string;
+    currency?: "usd";
+    walletFirst?: boolean;
+    cardFallback?: boolean;
+    customerReceizId?: string;
+    customerEmail?: string;
+    cart?: ReceizCommerceCart;
+    successUrl?: string;
+    cancelUrl?: string;
+    idempotencyKey?: string;
     [key: string]: unknown;
 };
-export type ReceizAppStateCollectionResponse = {
+export type ReceizOneClickCheckoutResponse = {
     ok: boolean;
-    records: ReceizPublicProjectionRecord[];
+    tenantHost: string;
+    orderId?: string;
+    funding: {
+        totalUsdCents: string;
+        walletAppliedUsdCents: string;
+        cardDeltaUsdCents: string;
+        walletFirst: boolean;
+        cardFallback: boolean;
+    };
+    wallet?: ConnectWalletResponse | null;
+    checkoutSession?: CheckoutSessionResponse | null;
+    proofObject?: JsonObject | null;
+    events: JsonObject[];
+    error?: string;
+    [key: string]: unknown;
+};
+export type ReceizMediaUploadOptions = {
+    tenantHost?: string;
+    purpose?: string;
+    filename?: string;
+    idempotencyKey?: string;
+    metadata?: JsonObject;
+};
+export type ReceizMediaUploadResponse = {
+    ok: boolean;
+    media?: JsonObject | null;
+    proof?: JsonObject | null;
+    error?: string;
+    [key: string]: unknown;
+};
+export type ReceizEventSubscribeRequest = {
+    tenantHost?: string;
+    types: string[];
+    webhookUrl?: string;
+    idempotencyKey?: string;
+    replayFrom?: string;
+    [key: string]: unknown;
+};
+export type ReceizProofQuery = {
+    namespace?: string;
+    tenantHost?: string;
+    type?: string;
+    customerReceizId?: string;
+    cursor?: string;
+    limit?: number;
+    [key: string]: unknown;
+};
+export type ReceizJobRequest = {
+    tenantHost?: string;
+    kind: string;
+    payload: JsonObject;
+    runAfter?: string;
+    idempotencyKey?: string;
     [key: string]: unknown;
 };
+export type ReceizIdempotencyOptions = {
+    idempotencyKey?: string;
+};
+export type ReceizTenantRuntimeRequest = JsonObject & {
+    tenantHost?: string;
+    idempotencyKey?: string;
+};
+export type ReceizCustomerSessionRequest = ReceizTenantRuntimeRequest & {
+    tenantHost: string;
+    customerReceizId?: string;
+    scopes?: string[];
+};
+export type ReceizMerchantOnboardRequest = ReceizTenantRuntimeRequest & {
+    tenantHost: string;
+    receizId?: string;
+    displayName?: string;
+    defaultStore?: JsonObject;
+};
+export type ReceizCommerceRuntimeRequest = ReceizTenantRuntimeRequest & {
+    tenantHost: string;
+};
+export type ReceizPermissionRole = "owner" | "admin" | "staff" | "fulfillment" | "support" | "customer" | string;
+export type ReceizPermissionGrantRequest = ReceizTenantRuntimeRequest & {
+    tenantHost: string;
+    actorReceizId: string;
+    role: ReceizPermissionRole;
+};
+export type ReceizPermissionCheckRequest = ReceizTenantRuntimeRequest & {
+    tenantHost: string;
+    actorReceizId: string;
+    permission: string;
+};
+export type ReceizAuditAppendRequest = ReceizTenantRuntimeRequest & {
+    tenantHost: string;
+    action: string;
+    actorReceizId?: string;
+};
+export type ReceizSearchRequest = ReceizTenantRuntimeRequest & {
+    tenantHost?: string;
+    query?: string;
+    cursor?: string;
+    limit?: number;
+};
+export type ReceizMediaTransformRequest = ReceizTenantRuntimeRequest & {
+    tenantHost?: string;
+    mediaId: string;
+    resize?: JsonObject;
+    optimize?: JsonObject;
+    blurPlaceholder?: boolean;
+    altText?: string;
+    metadata?: JsonObject;
+};
+export type ReceizReleasePinRequest = ReceizTenantRuntimeRequest & {
+    tenantHost: string;
+    rails: Record<string, string>;
+};
+export type ReceizOfflineProofQueueItem = {
+    id: string;
+    kind: "app_state.publish" | "connect.record" | "webhook.event" | string;
+    payload: JsonObject;
+    idempotencyKey?: string;
+    createdAt?: string;
+    attempts?: number;
+    lastError?: JsonObject | null;
+};
+export type ReceizOfflineProofQueueSnapshot = {
+    schema: "receiz.sdk.offline_proof_queue.v1";
+    ownerId?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    pending: ReceizOfflineProofQueueItem[];
+    settled: ReceizOfflineProofQueueItem[];
+    failed: ReceizOfflineProofQueueItem[];
+};
+export type ReceizOfflineProofQueueStorageValue = string | ReceizOfflineProofQueueSnapshot | null | undefined;
+export type ReceizOfflineProofQueueStorage = {
+    read(): ReceizOfflineProofQueueStorageValue | Promise<ReceizOfflineProofQueueStorageValue>;
+    write(snapshot: ReceizOfflineProofQueueSnapshot): void | Promise<void>;
+    remove?(): void | Promise<void>;
+};
+export type ReceizOfflineProofQueueOptions = {
+    ownerId?: string | null;
+    storage?: ReceizOfflineProofQueueStorage;
+    snapshot?: ReceizOfflineProofQueueSnapshot;
+};
+export type ReceizInMemoryOfflineProofQueueStorage = ReceizOfflineProofQueueStorage & {
+    readText(): string | null;
+};
+export type ReceizSandboxStoreOptions = {
+    tenantHost: string;
+    products?: number;
+    seed?: string;
+};
+export type ReceizSandboxStore = {
+    ok: true;
+    schema: "receiz.sdk.sandbox.store.v1";
+    tenantHost: string;
+    state: {
+        brand: string;
+        products: JsonObject[];
+        rewards: JsonObject[];
+    };
+};
+export type ReceizSandboxCheckoutOptions = {
+    amountUsd: string;
+    outcome?: "success" | "failure";
+};
+export type ReceizWebhookVerifyRequestOptions = {
+    secret: string;
+    toleranceSeconds?: number;
+    nowMs?: number;
+};
 export type WalletLedgerEvent = {
     id: string;
     kind: "transfer" | "note_mint" | "note_claim" | string;
@@ -986,10 +1281,19 @@ export declare function receizAppStateUrlFromHost(hostOrUrl: string): string;
 export declare function receizAppStateNamespaceFromUrl(sourceUrl: string): string;
 export declare function receizAppStateObjectIdFromUrl(sourceUrl: string, prefix?: string): string;
 export declare function createReceizAppStateRecord(input: ReceizAppStateRecordInput): ReceizAppStateRecord;
+export declare function createReceizAppStateFeed(records: Array<ReceizAppStateRecord | ReceizAppStateRecordInput>, options?: ReceizAppStateFeedOptions): ReceizAppStateFeed;
+export declare function createReceizPublicStoreStateRecord(input: ReceizPublicStoreStateRecordInput): ReceizAppStateRecord;
+export declare function createReceizTenantAppStateRecord(input: ReceizAppStateTenantPublishInput): ReceizAppStateRecord;
+export declare function normalizeReceizHost(hostOrUrl: string): string;
+export declare function verifyReceizWebhookRequest(request: Request, options: ReceizWebhookVerifyRequestOptions): Promise<boolean>;
+export declare function extractReceizAppStateData<TData extends JsonObject = JsonObject>(input: ReceizAppStateRecordResponse<TData> | ReceizPublicProjectionRecord<TData> | null | undefined, options?: ReceizAppStateRestoreOptions): TData | null;
+export declare function restoreReceizAppStateProjection<TData extends JsonObject = JsonObject>(input: ReceizAppStateRecordResponse<TData> | ReceizPublicProjectionRecord<TData> | null | undefined, options?: ReceizAppStateRestoreOptions): ReceizAppStateRestoreResult<TData>;
 export declare class ReceizClient {
     readonly baseUrl: string;
     private readonly accessToken;
     private readonly fetchImpl;
+    readonly doctor: (options?: ReceizCapabilitiesOptions) => Promise<ReceizDoctorReport>;
+    readonly capabilities: (options?: ReceizCapabilitiesOptions) => Promise<ReceizCapabilities>;
     readonly verification: {
         verifyArtifact: (file: Blob) => Promise<DocumentVerifyResponse>;
         sealArtifact: (file: Blob, options?: {
@@ -998,27 +1302,41 @@ export declare class ReceizClient {
         conformance: () => Promise<JsonObject>;
     };
     readonly publicProof: {
-        observe: (body: PublicProofObserveRequest) => Promise<PublicProofRecord>;
-        byUrl: (url: string) => Promise<PublicProofRecord>;
-        byId: (id: string) => Promise<PublicProofRecord>;
+        observe: (body: PublicProofObserveRequest) => Promise<PublicProofRecord<JsonObject>>;
+        byUrl: (url: string) => Promise<PublicProofRecord<JsonObject>>;
+        byId: (id: string) => Promise<PublicProofRecord<JsonObject>>;
         byCreator: (externalCreatorId: string) => Promise<{
             ok: boolean;
             records: PublicProofRecord[];
         }>;
         registryFeed: (feed: PublicProofRegistryFeed, options?: {
             signature?: string;
-        }) => Promise<ReceizAppStateFeedResponse>;
+        }) => Promise<ReceizAppStateFeedResponse<JsonObject>>;
     };
     readonly appState: {
-        publish: (feed: ReceizAppStateFeed, options?: {
+        publish: (input: ReceizAppStatePublishInput, options?: {
             signature?: string;
-        }) => Promise<ReceizAppStateFeedResponse>;
-        publishRecord: (record: ReceizAppStateRecord | ReceizAppStateRecordInput, options?: ReceizAppStatePublishRecordOptions) => Promise<ReceizAppStateFeedResponse>;
-        byUrl: (url: string) => Promise<ReceizAppStateRecordResponse>;
-        byHost: (host: string) => Promise<ReceizAppStateRecordResponse>;
-        byCreator: (receizId: string) => Promise<ReceizAppStateCollectionResponse>;
-        byNamespace: (namespace: string) => Promise<ReceizAppStateCollectionResponse>;
-        byId: (id: string) => Promise<ReceizAppStateRecordResponse>;
+            idempotencyKey?: string;
+        }) => Promise<ReceizAppStateFeedResponse<JsonObject>>;
+        publishRecord: (record: ReceizAppStateRecord | ReceizAppStateRecordInput, options?: ReceizAppStatePublishRecordOptions) => Promise<ReceizAppStateFeedResponse<JsonObject>>;
+        resolve: <TData extends JsonObject = JsonObject>(input: ReceizAppStateResolveInput) => Promise<ReceizAppStateResolveResult<TData>>;
+        byUrl: (url: string) => Promise<ReceizAppStateRecordResponse<JsonObject>>;
+        byHost: (host: string) => Promise<ReceizAppStateRecordResponse<JsonObject>>;
+        byCreator: (receizId: string) => Promise<ReceizAppStateCollectionResponse<JsonObject>>;
+        byNamespace: (namespace: string) => Promise<ReceizAppStateCollectionResponse<JsonObject>>;
+        byId: (id: string) => Promise<ReceizAppStateRecordResponse<JsonObject>>;
+        restoreByUrl: <TData extends JsonObject = JsonObject>(url: string, options?: ReceizAppStateRestoreOptions) => Promise<ReceizAppStateRestoreResult<TData>>;
+        restoreByHost: <TData extends JsonObject = JsonObject>(host: string, options?: ReceizAppStateRestoreOptions) => Promise<ReceizAppStateRestoreResult<TData>>;
+        restoreById: <TData extends JsonObject = JsonObject>(id: string, options?: ReceizAppStateRestoreOptions) => Promise<ReceizAppStateRestoreResult<TData>>;
+        createRecord: typeof createReceizAppStateRecord;
+        createTenantRecord: typeof createReceizTenantAppStateRecord;
+        createFeed: typeof createReceizAppStateFeed;
+        createPublicStoreRecord: typeof createReceizPublicStoreStateRecord;
+        urlFromHost: typeof receizAppStateUrlFromHost;
+        namespaceFromUrl: typeof receizAppStateNamespaceFromUrl;
+        objectIdFromUrl: typeof receizAppStateObjectIdFromUrl;
+        extractData: typeof extractReceizAppStateData;
+        restoreProjection: typeof restoreReceizAppStateProjection;
     };
     readonly sports: {
         conformance: () => Promise<JsonObject>;
@@ -1105,12 +1423,167 @@ export declare class ReceizClient {
         bootstrap: (username: string) => Promise<JsonObject>;
         authorizeUrl: (options: ReceizAuthorizeUrlOptions) => string;
     };
+    readonly customers: {
+        session: (body: ReceizCustomerSessionRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        portal: (body: ReceizTenantRuntimeRequest) => Promise<JsonObject>;
+        orders: (query?: ReceizSearchRequest) => Promise<JsonObject>;
+        rewards: (query?: ReceizSearchRequest) => Promise<JsonObject>;
+        assets: (query?: ReceizSearchRequest) => Promise<JsonObject>;
+    };
+    readonly merchants: {
+        onboard: (body: ReceizMerchantOnboardRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        profile: (query?: {
+            tenantHost?: string;
+        }) => Promise<JsonObject>;
+        capabilities: (query?: {
+            tenantHost?: string;
+        }) => Promise<JsonObject>;
+    };
+    readonly commerce: {
+        oneClickCheckout: (body: ReceizOneClickCheckoutRequest) => Promise<ReceizOneClickCheckoutResponse>;
+        refunds: {
+            create: (body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        };
+        subscriptions: {
+            create: (body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+            cancel: (subscriptionId: string, body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        };
+        shipping: {
+            quote: (body: ReceizCommerceRuntimeRequest) => Promise<JsonObject>;
+            update: (body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        };
+        tax: {
+            quote: (body: ReceizCommerceRuntimeRequest) => Promise<JsonObject>;
+        };
+        discounts: {
+            create: (body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+            redeem: (body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        };
+        giftCards: {
+            issue: (body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+            redeem: (body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        };
+        accessPasses: {
+            issue: (body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+            verify: (body: ReceizCommerceRuntimeRequest) => Promise<JsonObject>;
+        };
+        inventory: {
+            reserve: (body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+            adjust: (body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        };
+        fulfillment: {
+            update: (body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        };
+        payouts: {
+            create: (body: ReceizCommerceRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+            status: (query?: {
+                tenantHost?: string;
+                payoutId?: string;
+            }) => Promise<JsonObject>;
+        };
+    };
     readonly payments: {
         embeddedCheckout: (body: CheckoutRequest) => Promise<CheckoutSessionResponse>;
         embeddedNoteClaim: (body: JsonObject) => Promise<JsonObject>;
     };
+    readonly media: {
+        upload: (file: Blob, options?: ReceizMediaUploadOptions) => Promise<ReceizMediaUploadResponse>;
+        transform: (body: ReceizMediaTransformRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        objectUrl: (query: {
+            bucket: string;
+            path: string;
+        }) => string;
+    };
+    readonly domains: {
+        normalizeHost: typeof normalizeReceizHost;
+        tenantUrl: typeof receizAppStateUrlFromHost;
+        namespace: typeof receizAppStateNamespaceFromUrl;
+        objectId: typeof receizAppStateObjectIdFromUrl;
+        resolveTenant: <TData extends JsonObject = JsonObject>(host: string, options?: ReceizAppStateRestoreOptions) => Promise<ReceizAppStateRestoreResult<TData>>;
+        reserveSubdomain: (body: JsonObject, options?: {
+            idempotencyKey?: string;
+        }) => Promise<JsonObject>;
+        verifyCustomDomain: (body: JsonObject, options?: {
+            idempotencyKey?: string;
+        }) => Promise<JsonObject>;
+        status: (query?: {
+            host?: string;
+            domain?: string;
+        }) => Promise<JsonObject>;
+    };
+    readonly events: {
+        subscribe: (body: ReceizEventSubscribeRequest) => Promise<JsonObject>;
+        replay: (body: ReceizTenantRuntimeRequest) => Promise<JsonObject>;
+        list: (query?: ReceizSearchRequest) => Promise<JsonObject>;
+        ack: (eventId: string, body?: ReceizTenantRuntimeRequest) => Promise<JsonObject>;
+    };
+    readonly proof: {
+        query: (query: ReceizProofQuery) => Promise<JsonObject>;
+    };
+    readonly jobs: {
+        enqueue: (body: ReceizJobRequest) => Promise<JsonObject>;
+        status: (jobId: string) => Promise<JsonObject>;
+        cancel: (jobId: string, body?: ReceizTenantRuntimeRequest) => Promise<JsonObject>;
+        list: (query?: ReceizSearchRequest) => Promise<JsonObject>;
+    };
+    readonly permissions: {
+        grant: (body: ReceizPermissionGrantRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        revoke: (body: ReceizPermissionGrantRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        check: (body: ReceizPermissionCheckRequest) => Promise<JsonObject>;
+        roles: (query?: {
+            tenantHost?: string;
+        }) => Promise<JsonObject>;
+    };
+    readonly audit: {
+        append: (body: ReceizAuditAppendRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        query: (query?: ReceizSearchRequest) => Promise<JsonObject>;
+        export: (query?: ReceizSearchRequest) => Promise<JsonObject>;
+    };
+    readonly risk: {
+        scorePayment: (body: ReceizCommerceRuntimeRequest) => Promise<JsonObject>;
+        scoreAccountRecovery: (body: ReceizTenantRuntimeRequest) => Promise<JsonObject>;
+        velocity: (body: ReceizTenantRuntimeRequest) => Promise<JsonObject>;
+        proofActivity: (body: ReceizTenantRuntimeRequest) => Promise<JsonObject>;
+    };
+    readonly compliance: {
+        exportOrders: (query: ReceizSearchRequest) => Promise<JsonObject>;
+        exportTaxes: (query: ReceizSearchRequest) => Promise<JsonObject>;
+        exportPayouts: (query: ReceizSearchRequest) => Promise<JsonObject>;
+        exportCustomers: (query: ReceizSearchRequest) => Promise<JsonObject>;
+        exportAudit: (query: ReceizSearchRequest) => Promise<JsonObject>;
+    };
+    readonly portability: {
+        exportStore: (query: {
+            tenantHost: string;
+        }) => Promise<JsonObject>;
+        importStore: (body: ReceizTenantRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+    };
+    readonly search: {
+        query: (body: ReceizSearchRequest) => Promise<JsonObject>;
+        products: (body: ReceizSearchRequest) => Promise<JsonObject>;
+        pages: (body: ReceizSearchRequest) => Promise<JsonObject>;
+        blog: (body: ReceizSearchRequest) => Promise<JsonObject>;
+        orders: (body: ReceizSearchRequest) => Promise<JsonObject>;
+        customers: (body: ReceizSearchRequest) => Promise<JsonObject>;
+        proofObjects: (body: ReceizSearchRequest) => Promise<JsonObject>;
+    };
+    readonly notifications: {
+        send: (body: ReceizTenantRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        subscribe: (body: ReceizTenantRuntimeRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        templates: (query?: {
+            tenantHost?: string;
+        }) => Promise<JsonObject>;
+    };
+    readonly releases: {
+        pin: (body: ReceizReleasePinRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
+        check: (query?: {
+            tenantHost?: string;
+        }) => Promise<JsonObject>;
+        supported: () => Promise<JsonObject>;
+    };
     readonly webhooks: {
         sign: typeof createReceizWebhookSignature;
+        verify: typeof verifyReceizWebhookRequest;
         verifySignature: typeof verifyReceizWebhookSignature;
         signaturePayload: typeof buildReceizWebhookSignaturePayload;
         assertEvent: typeof assertReceizWebhookEvent;
@@ -1314,6 +1787,24 @@ export declare class ReceizClient {
         assetManifest: typeof projectReceizAssetManifest;
         sportsCardManifest: typeof projectReceizSportsCardManifest;
     };
+    readonly sandbox: {
+        seedStore: (options: ReceizSandboxStoreOptions) => ReceizSandboxStore;
+        wallet: (options?: {
+            balanceUsdCents?: string;
+            balancePhiMicro?: string;
+        }) => {
+            ok: boolean;
+            userId: string;
+            balanceUsdCents: string;
+            balancePhiMicro: string;
+        };
+        checkout: (options: ReceizSandboxCheckoutOptions) => {
+            ok: boolean;
+            checkoutSessionId: string;
+            status: string;
+            amountUsd: string;
+        };
+    };
     readonly proofMemory: {
         createRegister: typeof createReceizProofRegister;
         createMemory: typeof createReceizProofMemory;
@@ -1322,6 +1813,12 @@ export declare class ReceizClient {
         assertSnapshot: typeof assertReceizProofRegisterSnapshot;
         additionsQuery: typeof receizProofMemoryAdditionsQuery;
     };
+    readonly offline: {
+        createQueue: typeof createReceizOfflineProofQueue;
+        createInMemoryStorage: typeof createReceizInMemoryOfflineProofQueueStorage;
+        createLocalStorage: typeof createReceizLocalStorageOfflineProofQueueStorage;
+        assertSnapshot: typeof assertReceizOfflineProofQueueSnapshot;
+    };
     constructor(options?: ReceizClientOptions);
     request<T>(path: string, options?: RequestOptions): Promise<T>;
     verifyArtifact(file: Blob): Promise<DocumentVerifyResponse>;
@@ -1335,8 +1832,15 @@ export declare class ReceizClient {
     }): Promise<WalletLedgerFeed>;
     observePublicProof(body: PublicProofObserveRequest): Promise<PublicProofRecord>;
     readPublicProofByUrl(url: string): Promise<PublicProofRecord>;
+    inspectCapabilities(options?: ReceizCapabilitiesOptions): Promise<ReceizCapabilities>;
+    runDoctor(options?: ReceizCapabilitiesOptions): Promise<ReceizDoctorReport>;
     publishAppState(feed: ReceizAppStateFeed, options?: {
         signature?: string;
+        idempotencyKey?: string;
+    }): Promise<ReceizAppStateFeedResponse>;
+    publishAppStateInput(input: ReceizAppStatePublishInput, options?: {
+        signature?: string;
+        idempotencyKey?: string;
     }): Promise<ReceizAppStateFeedResponse>;
     publishAppStateRecord(record: ReceizAppStateRecord | ReceizAppStateRecordInput, options?: ReceizAppStatePublishRecordOptions): Promise<ReceizAppStateFeedResponse>;
     readAppStateByUrl(url: string): Promise<ReceizAppStateRecordResponse>;
@@ -1344,9 +1848,17 @@ export declare class ReceizClient {
     readAppStateByCreator(receizId: string): Promise<ReceizAppStateCollectionResponse>;
     readAppStateByNamespace(namespace: string): Promise<ReceizAppStateCollectionResponse>;
     readAppStateById(id: string): Promise<ReceizAppStateRecordResponse>;
+    restoreAppStateByUrl<TData extends JsonObject = JsonObject>(url: string, options?: ReceizAppStateRestoreOptions): Promise<ReceizAppStateRestoreResult<TData>>;
+    restoreAppStateByHost<TData extends JsonObject = JsonObject>(host: string, options?: ReceizAppStateRestoreOptions): Promise<ReceizAppStateRestoreResult<TData>>;
+    restoreAppStateById<TData extends JsonObject = JsonObject>(id: string, options?: ReceizAppStateRestoreOptions): Promise<ReceizAppStateRestoreResult<TData>>;
+    resolveAppState<TData extends JsonObject = JsonObject>(input: ReceizAppStateResolveInput): Promise<ReceizAppStateResolveResult<TData>>;
+    oneClickCheckout(body: ReceizOneClickCheckoutRequest): Promise<ReceizOneClickCheckoutResponse>;
+    uploadMedia(file: Blob, options?: ReceizMediaUploadOptions): Promise<ReceizMediaUploadResponse>;
+    eventSubscribe(body: ReceizEventSubscribeRequest): Promise<JsonObject>;
     sportsConformance(): Promise<JsonObject>;
     signalCircuitConformance(): Promise<JsonObject>;
     delegated<T>(path: string, options?: Omit<RequestOptions, "bearerToken">): Promise<T>;
+    private delegatedWrite;
     private delegatedBlob;
     private delegatedTwinMindImport;
     private streamJsonEvents;
@@ -1413,6 +1925,29 @@ export declare function createReceizProofMemory(options?: ReceizProofMemoryOptio
 export declare function createReceizInMemoryProofMemoryStorage(initialValue?: ReceizProofMemoryStorageValue): ReceizInMemoryProofMemoryStorage;
 export declare function createReceizLocalStorageProofMemoryStorage(key?: string, storage?: Pick<Storage, "getItem" | "setItem" | "removeItem"> | null | undefined): ReceizProofMemoryStorage;
 export declare function receizProofMemoryAdditionsQuery(value: ReceizProofRegister | ReceizProofRegisterSnapshot | ReceizProofMemory, limit?: number): ReceizProofMemoryAdditionsQuery;
+export declare function assertReceizOfflineProofQueueSnapshot(value: unknown): ReceizOfflineProofQueueSnapshot;
+export declare class ReceizOfflineProofQueue {
+    readonly ownerId: string | null;
+    readonly createdAt: string;
+    private pendingItems;
+    private settledItems;
+    private failedItems;
+    private readonly storage;
+    constructor(options?: ReceizOfflineProofQueueOptions);
+    enqueue(item: ReceizOfflineProofQueueItem): this;
+    snapshot(): ReceizOfflineProofQueueSnapshot;
+    flush(): Promise<ReceizOfflineProofQueueSnapshot>;
+    clear(): Promise<void>;
+    replay(client: ReceizClient): Promise<{
+        ok: boolean;
+        settled: number;
+        failed: number;
+    }>;
+    toJSON(): ReceizOfflineProofQueueSnapshot;
+}
+export declare function createReceizOfflineProofQueue(options?: ReceizOfflineProofQueueOptions): Promise<ReceizOfflineProofQueue>;
+export declare function createReceizInMemoryOfflineProofQueueStorage(initialValue?: ReceizOfflineProofQueueStorageValue): ReceizInMemoryOfflineProofQueueStorage;
+export declare function createReceizLocalStorageOfflineProofQueueStorage(key?: string, storage?: Pick<Storage, "getItem" | "setItem" | "removeItem"> | null | undefined): ReceizOfflineProofQueueStorage;
 export declare function buildReceizWebhookSignaturePayload(input: {
     timestamp: string;
     body: string | ArrayBuffer | Uint8Array | JsonObject;