@receiz/sdk 97.0.0 → 97.1.0

package/README.md

@@ -205,27 +205,86 @@ Receiz apps can publish durable public app-state projections without adding Supa
 import {
   RECEIZ_PUBLIC_STORE_STATE_PROJECTION_SCHEMA,
   createReceizClient,
+  createReceizPublicStoreStateRecord,
 } from "@receiz/sdk";
 
 const receiz = createReceizClient({ accessToken });
 
-await receiz.appState.publishRecord({
+await receiz.appState.publishRecord(createReceizPublicStoreStateRecord({
   sourceUrl: "bjklock.receiz.app",
   externalCreatorId: "bjklock.receiz.id",
   title: "BJ Klock storefront",
-  platform: "Receiz.app Commerce Cloud",
-  schema: RECEIZ_PUBLIC_STORE_STATE_PROJECTION_SCHEMA,
   data: { storeStateRecord },
+}));
+
+const restored = await createReceizClient().appState.restoreByHost<{
+  storeStateRecord: StoreStateRecord;
+}>("bjklock.receiz.app", {
+  schema: RECEIZ_PUBLIC_STORE_STATE_PROJECTION_SCHEMA,
+  state: "published",
+  requiredDataKey: "storeStateRecord",
 });
 
-const restored = await createReceizClient().appState.byHost("bjklock.receiz.app");
-renderStorefront(restored.record?.data?.storeStateRecord);
+if (restored.ok && restored.data) renderStorefront(restored.data.storeStateRecord);
 ```
 
 `receiz.appState.publish(feed)` remains available for batch writes. `receiz.publicProof.registryFeed(feed)` remains available and aliases the same publish path for existing integrations.
+Raw reads remain available through `byUrl()`, `byHost()`, `byCreator()`, `byNamespace()`, and `byId()` when an app needs the full public projection envelope instead of direct restored data.
 
 Full quickstart: `docs/app-state-public-projections.md`.
 
+## Receiz App Runtime Rails
+
+`@receiz/sdk@97.1.0` adds typed rails for Commerce Cloud style apps. These helpers compose existing Receiz primitives; they do not replace proof objects, local proof memory, Connect, or the public app-state projection rail.
+
+```ts
+import { createReceizClient } from "@receiz/sdk";
+
+const receiz = createReceizClient({ accessToken });
+
+const doctor = await receiz.doctor({
+  tenantHost: "bjklock.receiz.app",
+  callbackUrl: "https://bjklock.receiz.app/api/auth/receiz/callback",
+  scopes: ["openid", "profile", "receiz:record", "receiz:wallet.read"],
+});
+if (!doctor.ok) console.table(doctor.fixes);
+
+const caps = await receiz.capabilities({ tenantHost: "bjklock.receiz.app" });
+if (caps.capabilities.commerce.available) {
+  await receiz.commerce.oneClickCheckout({
+    tenantHost: "bjklock.receiz.app",
+    orderId: "order_123",
+    amountUsd: "42.00",
+    walletFirst: true,
+    cardFallback: true,
+    idempotencyKey: "order_123",
+  });
+}
+
+await receiz.appState.publish({
+  tenantHost: "bjklock.receiz.app",
+  creatorReceizId: "bjklock.receiz.id",
+  title: "BJ Klock storefront",
+  state: { storeStateRecord },
+  idempotencyKey: "storefront_state_1",
+});
+
+const restored = await createReceizClient().appState.resolve({
+  host: "bjklock.receiz.app",
+  requiredDataKey: "storeStateRecord",
+});
+```
+
+Additional typed surfaces:
+
+- `receiz.media.upload(file, { tenantHost, purpose, idempotencyKey })`
+- `receiz.domains.normalizeHost()`, `tenantUrl()`, `namespace()`, `objectId()`, `resolveTenant()`
+- `receiz.events.subscribe({ tenantHost, types, webhookUrl, idempotencyKey })`
+- `receiz.proof.query({ namespace, tenantHost, type, customerReceizId })`
+- `receiz.jobs.enqueue({ tenantHost, kind, payload, idempotencyKey })`
+- `receiz.sandbox.seedStore()`, `sandbox.wallet()`, `sandbox.checkout()`
+- CLI: `receiz doctor`, `receiz dev`, `receiz deploy-check`, `receiz seed-store`, `receiz simulate-checkout`
+
 ## Sports Card And Event Proof Integration
 
 ```ts

package/dist/cli.js

@@ -2,7 +2,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { assertReceizAssetManifest, assertReceizProofRegisterSnapshot, assertReceizSportsCardManifest, assertReceizWebhookEvent, createReceizInMemoryProofMemoryStorage, createReceizProofMemory, projectReceizAssetManifest, projectReceizSportsCardManifest, receizProofMemoryAdditionsQuery, } from "./index.js";
+import { RECEIZ_SDK_VERSION, assertReceizAssetManifest, assertReceizProofRegisterSnapshot, assertReceizSportsCardManifest, assertReceizWebhookEvent, createReceizClient, createReceizInMemoryProofMemoryStorage, createReceizProofMemory, projectReceizAssetManifest, projectReceizSportsCardManifest, receizProofMemoryAdditionsQuery, } from "./index.js";
 const moduleDir = dirname(fileURLToPath(import.meta.url));
 const packageRoot = moduleDir.endsWith(`${join("packages", "receiz-sdk", "dist")}`)
     ? dirname(moduleDir)
@@ -19,6 +19,27 @@ function printError(error, detail) {
 function readJsonFile(path) {
     return JSON.parse(readFileSync(resolve(path), "utf8"));
 }
+function optionValue(args, name) {
+    const index = args.indexOf(name);
+    if (index < 0)
+        return undefined;
+    const value = args[index + 1];
+    return value && !value.startsWith("--") ? value : undefined;
+}
+function optionNumber(args, name, fallback) {
+    const value = optionValue(args, name);
+    if (!value)
+        return fallback;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+function optionScopes(args) {
+    const raw = optionValue(args, "--scopes") ?? optionValue(args, "--scope") ?? "";
+    return raw
+        .split(/[,\s]+/)
+        .map((scope) => scope.trim())
+        .filter(Boolean);
+}
 async function inspectProofObject(path) {
     const value = readJsonFile(path);
     const storage = createReceizInMemoryProofMemoryStorage();
@@ -188,9 +209,14 @@ Usage:
   receiz inspect <path-to-proof-json>
   receiz conformance
   receiz init <target-dir>
+  receiz doctor --tenant-host <host> [--access-token <token>] [--callback-url <url>] [--scopes <csv>]
+  receiz dev
+  receiz deploy-check --tenant-host <host>
+  receiz seed-store --tenant-host <host> [--products <count>]
+  receiz simulate-checkout --amount-usd <amount>
 
 This CLI uses local Receiz SDK validators, projections, and durable proof memory.
-It does not make network or database calls for inspect or conformance.
+It does not make network or database calls for inspect, conformance, doctor, deploy-check, seed-store, or simulate-checkout.
 `);
 }
 async function main(argv) {
@@ -229,6 +255,84 @@ async function main(argv) {
         });
         return;
     }
+    if (command === "doctor") {
+        const clientOptions = {};
+        const accessToken = optionValue(args, "--access-token");
+        const baseUrl = optionValue(args, "--base-url");
+        if (accessToken)
+            clientOptions.accessToken = accessToken;
+        if (baseUrl)
+            clientOptions.baseUrl = baseUrl;
+        const client = createReceizClient(clientOptions);
+        const doctorOptions = {};
+        const tenantHost = optionValue(args, "--tenant-host");
+        const callbackUrl = optionValue(args, "--callback-url");
+        const scopes = optionScopes(args);
+        if (tenantHost)
+            doctorOptions.tenantHost = tenantHost;
+        if (callbackUrl)
+            doctorOptions.callbackUrl = callbackUrl;
+        if (scopes.length > 0)
+            doctorOptions.scopes = scopes;
+        const report = await client.doctor(doctorOptions);
+        printJson({
+            ...report,
+            schema: "receiz.sdk.cli.doctor.v1",
+            sdkVersion: RECEIZ_SDK_VERSION,
+        });
+        if (!report.ok)
+            process.exitCode = 1;
+        return;
+    }
+    if (command === "dev") {
+        printJson({
+            ok: true,
+            schema: "receiz.sdk.cli.dev.v1",
+            sdkVersion: RECEIZ_SDK_VERSION,
+            networkCalls: 0,
+            dbCalls: 0,
+            message: "Use the SDK sandbox helpers for deterministic local Receiz IDs, app state, wallet balances, checkout outcomes, webhooks, and proof objects.",
+            commands: ["receiz seed-store", "receiz simulate-checkout", "receiz doctor", "receiz inspect"],
+        });
+        return;
+    }
+    if (command === "deploy-check") {
+        const tenantHost = optionValue(args, "--tenant-host");
+        const checks = [
+            { code: "tenant_host_present", ok: Boolean(tenantHost), message: "tenantHost scopes app-state, domains, commerce, permissions, search, and jobs." },
+            { code: "sdk_version_pinned", ok: true, message: `@receiz/sdk ${RECEIZ_SDK_VERSION}` },
+            { code: "network_authority_required", ok: false, level: "info", message: "Deploy check is local. Production route availability is verified by receiz.doctor() and app capability probes." },
+        ];
+        printJson({
+            ok: checks.every((check) => check.ok || check.level === "info"),
+            schema: "receiz.sdk.cli.deploy_check.v1",
+            tenantHost: tenantHost ?? null,
+            checks,
+        });
+        return;
+    }
+    if (command === "seed-store") {
+        const tenantHost = optionValue(args, "--tenant-host");
+        if (!tenantHost) {
+            printError("missing_tenant_host", "Usage: receiz seed-store --tenant-host <host> [--products <count>]");
+            process.exitCode = 1;
+            return;
+        }
+        const client = createReceizClient();
+        printJson(client.sandbox.seedStore({ tenantHost, products: optionNumber(args, "--products", 3) }));
+        return;
+    }
+    if (command === "simulate-checkout") {
+        const amountUsd = optionValue(args, "--amount-usd");
+        if (!amountUsd) {
+            printError("missing_amount_usd", "Usage: receiz simulate-checkout --amount-usd <amount>");
+            process.exitCode = 1;
+            return;
+        }
+        const client = createReceizClient();
+        printJson(client.sandbox.checkout({ amountUsd, outcome: optionValue(args, "--outcome") === "failure" ? "failure" : "success" }));
+        return;
+    }
     printError("unknown_command", command);
     process.exitCode = 1;
 }

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.1.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,231 @@ 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 | null;
+    record: ReceizPublicProjectionRecord<TData> | null;
     [key: string]: unknown;
 };
-export type ReceizAppStateCollectionResponse = {
+export type ReceizAppStateCollectionResponse<TData extends JsonObject = JsonObject> = {
     ok: boolean;
-    records: ReceizPublicProjectionRecord[];
+    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";
+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;
+    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 ReceizOneClickCheckoutResponse = {
+    ok: boolean;
+    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 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 +1193,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 +1214,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 +1335,49 @@ export declare class ReceizClient {
         bootstrap: (username: string) => Promise<JsonObject>;
         authorizeUrl: (options: ReceizAuthorizeUrlOptions) => string;
     };
+    readonly commerce: {
+        oneClickCheckout: (body: ReceizOneClickCheckoutRequest) => Promise<ReceizOneClickCheckoutResponse>;
+    };
     readonly payments: {
         embeddedCheckout: (body: CheckoutRequest) => Promise<CheckoutSessionResponse>;
         embeddedNoteClaim: (body: JsonObject) => Promise<JsonObject>;
     };
+    readonly media: {
+        upload: (file: Blob, options?: ReceizMediaUploadOptions) => Promise<ReceizMediaUploadResponse>;
+        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>;
+    };
+    readonly proof: {
+        query: (query: ReceizProofQuery) => Promise<JsonObject>;
+    };
+    readonly jobs: {
+        enqueue: (body: ReceizJobRequest) => Promise<JsonObject>;
+    };
     readonly webhooks: {
         sign: typeof createReceizWebhookSignature;
+        verify: typeof verifyReceizWebhookRequest;
         verifySignature: typeof verifyReceizWebhookSignature;
         signaturePayload: typeof buildReceizWebhookSignaturePayload;
         assertEvent: typeof assertReceizWebhookEvent;
@@ -1314,6 +1581,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;
@@ -1335,8 +1620,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,6 +1636,13 @@ 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>;