@receiz/sdk 97.1.0 → 97.3.0

package/README.md

@@ -228,6 +228,23 @@ const restored = await createReceizClient().appState.restoreByHost<{
 if (restored.ok && restored.data) renderStorefront(restored.data.storeStateRecord);
 ```
 
+For commerce storefronts, use the first-party public-store recipe so every app publishes the same `storeStateRecord` envelope:
+
+```ts
+await receiz.publicStore.publish({
+  tenantHost: "bjklock.receiz.app",
+  merchantReceizId: "bjklock.receiz.id",
+  title: "BJ Klock storefront",
+  state: storeStateRecord,
+}, { idempotencyKey: `storefront:${storeStateRecord.updatedKaiUpulse}` });
+
+const store = await createReceizClient().publicStore.resolve<StoreStateRecord>({
+  host: "bjklock.receiz.app",
+});
+
+if (store.ok && store.storeStateRecord) renderStorefront(store.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.
 
@@ -235,17 +252,21 @@ 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.
+`@receiz/sdk@97.3.0` adds dogfood-ready local-first recipes on top of the enterprise runtime 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";
+import { RECEIZ_OIDC_SCOPES_BY_RAIL, 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"],
+  scopes: [
+    ...RECEIZ_OIDC_SCOPES_BY_RAIL.customers,
+    ...RECEIZ_OIDC_SCOPES_BY_RAIL.merchants,
+    ...RECEIZ_OIDC_SCOPES_BY_RAIL.publicStore,
+  ],
 });
 if (!doctor.ok) console.table(doctor.fixes);
 
@@ -273,18 +294,85 @@ const restored = await createReceizClient().appState.resolve({
   host: "bjklock.receiz.app",
   requiredDataKey: "storeStateRecord",
 });
+
+const tenantSession = await receiz.customers.bootstrapSession({
+  tenantHost: "bjklock.receiz.app",
+  customerReceizId: "customer.receiz.id",
+  scopes: ["orders", "rewards", "assets"],
+}, { idempotencyKey: "customer-session:v1" });
+
+const hostedIdentity = receiz.identity.ensureTenantSession({
+  tenantHost: "bjklock.receiz.app",
+  returnTo: "https://bjklock.receiz.app/account",
+  fallback: "artifact_upload",
+});
+
+const profile = await receiz.profile.resolveLocalFirst({
+  memory,
+  local: admittedProfileTruth,
+  sync: (knownHead) => fetchVerifiedProfileAdditions(knownHead),
+});
+
+const walletLedger = await receiz.wallet.resolveLedger({
+  memory,
+  local: admittedWalletLedger,
+  sync: (knownHead) => fetchVerifiedWalletAdditions(knownHead),
+});
+
+const pitchDay = await receiz.sports.resolvePitchDayProof({
+  local: admittedPitchDayProof,
+});
 ```
 
 Additional typed surfaces:
 
+- `RECEIZ_OIDC_SCOPES_BY_RAIL` and `receizOidcScopesForRails()` for stable per-rail Connect/OIDC scopes
+- `receiz.runtime.localFirst()`, `profile.resolveLocalFirst()`, `wallet.resolveLedger()`, `sports.resolveCardMemory()`, `sports.resolvePitchDayProof()`
+- `receiz.proofMemory.syncAdditions()` for append-only sync after the known proof-memory head
+- `receiz.publicStore.publish()`, `publicStore.resolve()`, `publicStore.createRecord()`
+- `receiz.identity.ensureTenantSession({ tenantHost, returnTo, fallback })`
+- `receiz.customers.bootstrapSession()`, `customers.session()`, `customers.portal()`, `customers.orders()`, `customers.rewards()`, `customers.assets()`
+- `receiz.merchants.onboard()`, `merchants.profile()`, `merchants.capabilities()`
+- `receiz.commerce.refunds`, `subscriptions`, `shipping`, `tax`, `discounts`, `giftCards`, `accessPasses`, `inventory`, `fulfillment`, `payouts`
 - `receiz.media.upload(file, { tenantHost, purpose, idempotencyKey })`
+- `receiz.media.transform({ mediaId, resize, optimize, blurPlaceholder, altText, metadata })`
 - `receiz.domains.normalizeHost()`, `tenantUrl()`, `namespace()`, `objectId()`, `resolveTenant()`
-- `receiz.events.subscribe({ tenantHost, types, webhookUrl, idempotencyKey })`
+- `receiz.events.subscribe()`, `events.replay()`, `events.list()`, `events.ack()`
 - `receiz.proof.query({ namespace, tenantHost, type, customerReceizId })`
-- `receiz.jobs.enqueue({ tenantHost, kind, payload, idempotencyKey })`
+- `receiz.jobs.enqueue()`, `jobs.status()`, `jobs.cancel()`, `jobs.list()`
+- `receiz.permissions.grant()`, `permissions.revoke()`, `permissions.check()`, `permissions.roles()`
+- `receiz.audit.append()`, `audit.query()`, `audit.export()`
+- `receiz.risk.scorePayment()`, `scoreAccountRecovery()`, `velocity()`, `proofActivity()`
+- `receiz.compliance.exportOrders()`, `exportTaxes()`, `exportPayouts()`, `exportCustomers()`, `exportAudit()`
+- `receiz.portability.exportStore()`, `portability.importStore()`
+- `receiz.search.query()`, `products()`, `pages()`, `blog()`, `orders()`, `customers()`, `proofObjects()`
+- `receiz.notifications.send()`, `notifications.subscribe()`, `notifications.templates()`
+- `receiz.releases.pin()`, `releases.check()`, `releases.supported()`
 - `receiz.sandbox.seedStore()`, `sandbox.wallet()`, `sandbox.checkout()`
+- `receiz.offline.createQueue()`, `offline.createInMemoryStorage()`, `offline.createLocalStorage()`
 - CLI: `receiz doctor`, `receiz dev`, `receiz deploy-check`, `receiz seed-store`, `receiz simulate-checkout`
 
+React apps can import optional hooks and hosted component factories from `@receiz/sdk/react`:
+
+```ts
+import {
+  ReceizCheckoutButton,
+  ReceizIdentityButton,
+  ReceizMediaUploader,
+  useReceizAppState,
+  useReceizCheckout,
+} from "@receiz/sdk/react";
+
+const storefront = useReceizAppState({
+  resolve: {
+    host: "bjklock.receiz.app",
+    requiredDataKey: "storeStateRecord",
+  },
+});
+```
+
+The React subpath is UI convenience. The core SDK client remains the primitive boundary, and proof objects / local proof memory remain stronger than component state.
+
 ## Sports Card And Event Proof Integration
 
 ```ts

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.1.0";
+export declare const RECEIZ_SDK_VERSION = "97.3.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";
@@ -250,13 +250,23 @@ export type ReceizAppStateResolveInput = ReceizAppStateRestoreOptions & {
 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 ReceizCapabilityKey = "identity" | "wallet" | "payments" | "proofStore" | "media" | "domains" | "twin" | "commerce" | "rewards" | "customers" | "merchants" | "events" | "search" | "permissions" | "jobs" | "audit" | "risk" | "compliance" | "portability" | "notifications" | "offline" | "releases";
+export type ReceizRailScopeKey = ReceizCapabilityKey | "appState" | "publicStore";
+export declare const RECEIZ_OIDC_SCOPES_BY_RAIL: Record<ReceizRailScopeKey, readonly string[]>;
+export declare function receizOidcScopesForRails(...rails: ReceizRailScopeKey[]): string[];
 export type ReceizCapabilityStatus = "available" | "missing" | "unknown";
+export type ReceizCapabilityRequirements = {
+    tenantHost?: boolean;
+    accessToken?: boolean;
+    callbackUrl?: boolean;
+    scopes?: readonly string[];
+};
 export type ReceizCapability = {
     available: boolean;
     status: ReceizCapabilityStatus;
     reason?: string;
     fixUrl?: string;
+    requirements?: ReceizCapabilityRequirements;
     [key: string]: unknown;
 };
 export type ReceizCapabilities = {
@@ -371,6 +381,158 @@ export type ReceizJobRequest = {
     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 ReceizCustomerSessionBootstrapRequest = ReceizCustomerSessionRequest & {
+    includeWallet?: boolean;
+    includeCustomer?: boolean;
+    includePermissions?: boolean;
+};
+export type ReceizCustomerSessionBootstrapResponse = {
+    ok: true;
+    schema: "receiz.sdk.customer_session.bootstrap.v1";
+    tenantHost: string;
+    session: JsonObject | null;
+    wallet: JsonObject | null;
+    customer: JsonObject | null;
+    permissions: JsonObject | null;
+};
+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 ReceizTenantSessionFallback = "artifact_upload" | "connect";
+export type ReceizEnsureTenantSessionInput = {
+    tenantHost: string;
+    returnTo?: string;
+    fallback?: ReceizTenantSessionFallback;
+    clientId?: string;
+    redirectUri?: string;
+    codeChallenge?: string;
+    codeChallengeMethod?: "S256" | "plain";
+    state?: string;
+    scope?: string | string[];
+    usernameHint?: string;
+};
+export type ReceizEnsureTenantSessionResult = {
+    ok: true;
+    schema: "receiz.sdk.identity.tenant_session.ensure.v1";
+    tenantHost: string;
+    fallback: ReceizTenantSessionFallback;
+    url: string;
+    scope: string[];
+    returnTo?: string;
+};
+export type ReceizPublicStorePublishInput<TState extends JsonObject = JsonObject> = {
+    tenantHost: string;
+    merchantReceizId: string;
+    state: TState;
+    title?: string;
+    id?: string;
+    sourceUrl?: string;
+    namespace?: string;
+    projectionState?: string;
+    schema?: string;
+    platform?: string;
+    record?: JsonObject | null;
+    data?: JsonObject;
+    idempotencyKey?: string;
+    [key: string]: unknown;
+};
+export type ReceizPublicStoreResolveInput = {
+    host?: string;
+    tenantHost?: string;
+    url?: string;
+    id?: string;
+};
+export type ReceizPublicStoreResolveResult<TState extends JsonObject = JsonObject> = ReceizAppStateRestoreResult<{
+    storeStateRecord: TState;
+}> & {
+    state: TState | null;
+    storeStateRecord: TState | null;
+};
+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;
@@ -802,6 +964,59 @@ export type ReceizProofMemoryAdditionsQuery = {
     afterCreatedAt: string | null;
     limit?: number;
 };
+export type ReceizProofMemoryAdditionBatch = unknown[] | {
+    entries?: ReceizProofRegisterEntry[];
+    additions?: unknown[];
+    proofs?: unknown[];
+    records?: unknown[];
+    [key: string]: unknown;
+};
+export type ReceizProofMemorySyncFetcher = (query: ReceizProofMemoryAdditionsQuery) => Promise<ReceizProofMemoryAdditionBatch>;
+export type ReceizProofMemorySyncInput = {
+    memory: ReceizProofMemory;
+    fetchAdditions: ReceizProofMemorySyncFetcher;
+    limit?: number;
+};
+export type ReceizProofMemorySyncResult = {
+    ok: true;
+    schema: "receiz.sdk.proof_memory.sync.v1";
+    knownHead: ReceizProofMemoryAdditionsQuery;
+    admitted: number;
+    snapshot: ReceizProofRegisterSnapshot;
+};
+export type ReceizLocalFirstInput<TValue> = {
+    memory?: ReceizProofMemory;
+    local?: TValue | null;
+    remote?: () => Promise<TValue | null>;
+    sync?: ReceizProofMemorySyncFetcher;
+    limit?: number;
+};
+export type ReceizLocalFirstResult<TValue> = {
+    ok: true;
+    schema: "receiz.sdk.local_first.v1";
+    surface: string;
+    source: "local" | "remote" | "empty";
+    value: TValue | null;
+    local: TValue | null;
+    knownHead: ReceizProofMemoryAdditionsQuery | null;
+    snapshot: ReceizProofRegisterSnapshot | null;
+    sync: Promise<ReceizProofMemorySyncResult> | null;
+};
+export type ReceizRuntimeLocalFirstInput = {
+    ownerId?: string | null;
+    storage?: ReceizProofMemoryStorage;
+    seed?: unknown[];
+    sync?: ReceizProofMemorySyncFetcher;
+    limit?: number;
+};
+export type ReceizRuntimeLocalFirstResult = {
+    ok: true;
+    schema: "receiz.sdk.runtime.local_first.v1";
+    memory: ReceizProofMemory;
+    snapshot: ReceizProofRegisterSnapshot;
+    knownHead: ReceizProofMemoryAdditionsQuery;
+    sync: Promise<ReceizProofMemorySyncResult> | null;
+};
 export type ReceizInMemoryProofMemoryStorage = ReceizProofMemoryStorage & {
     readText(): string | null;
 };
@@ -1250,6 +1465,12 @@ export declare class ReceizClient {
         extractData: typeof extractReceizAppStateData;
         restoreProjection: typeof restoreReceizAppStateProjection;
     };
+    readonly publicStore: {
+        publish: <TState extends JsonObject = JsonObject>(input: ReceizPublicStorePublishInput<TState>, options?: ReceizIdempotencyOptions) => Promise<ReceizAppStateFeedResponse<JsonObject>>;
+        resolve: <TState extends JsonObject = JsonObject>(input: ReceizPublicStoreResolveInput) => Promise<ReceizPublicStoreResolveResult<TState>>;
+        createRecord: typeof createReceizPublicStoreStateRecord;
+        scopes: readonly string[];
+    };
     readonly sports: {
         conformance: () => Promise<JsonObject>;
         conformanceHistory: () => Promise<JsonObject>;
@@ -1259,6 +1480,8 @@ export declare class ReceizClient {
         badge: () => Promise<JsonObject>;
         eventProofUrl: (eventProofId: string) => string;
         assertCardManifest: typeof assertReceizSportsCardManifest;
+        resolveCardMemory: <TValue extends JsonObject = JsonObject>(input: ReceizLocalFirstInput<TValue>) => Promise<ReceizLocalFirstResult<TValue>>;
+        resolvePitchDayProof: <TValue extends JsonObject = JsonObject>(input: ReceizLocalFirstInput<TValue>) => Promise<ReceizLocalFirstResult<TValue>>;
     };
     readonly wallet: {
         publicLedger: (query?: {
@@ -1271,6 +1494,10 @@ export declare class ReceizClient {
             cursor?: string;
             since?: string;
         }) => Promise<ActionLedgerFeed>;
+        resolveLedger: <TValue extends JsonObject = JsonObject>(input: ReceizLocalFirstInput<TValue>) => Promise<ReceizLocalFirstResult<TValue>>;
+    };
+    readonly profile: {
+        resolveLocalFirst: <TValue extends JsonObject = JsonObject>(input: ReceizLocalFirstInput<TValue>) => Promise<ReceizLocalFirstResult<TValue>>;
     };
     readonly world: {
         publicSnapshot: () => Promise<ReceizWorldPublicSnapshotResponse>;
@@ -1334,9 +1561,68 @@ export declare class ReceizClient {
         }) => Promise<JsonObject>;
         bootstrap: (username: string) => Promise<JsonObject>;
         authorizeUrl: (options: ReceizAuthorizeUrlOptions) => string;
+        ensureTenantSession: (input: ReceizEnsureTenantSessionInput) => ReceizEnsureTenantSessionResult;
+    };
+    readonly customers: {
+        bootstrapSession: (body: ReceizCustomerSessionBootstrapRequest, options?: ReceizIdempotencyOptions) => Promise<ReceizCustomerSessionBootstrapResponse>;
+        bootstrap: (body: ReceizCustomerSessionBootstrapRequest, options?: ReceizIdempotencyOptions) => Promise<ReceizCustomerSessionBootstrapResponse>;
+        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>;
@@ -1344,6 +1630,7 @@ export declare class ReceizClient {
     };
     readonly media: {
         upload: (file: Blob, options?: ReceizMediaUploadOptions) => Promise<ReceizMediaUploadResponse>;
+        transform: (body: ReceizMediaTransformRequest, options?: ReceizIdempotencyOptions) => Promise<JsonObject>;
         objectUrl: (query: {
             bucket: string;
             path: string;
@@ -1368,12 +1655,73 @@ export declare class ReceizClient {
     };
     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;
@@ -1606,6 +1954,16 @@ export declare class ReceizClient {
         createLocalStorage: typeof createReceizLocalStorageProofMemoryStorage;
         assertSnapshot: typeof assertReceizProofRegisterSnapshot;
         additionsQuery: typeof receizProofMemoryAdditionsQuery;
+        syncAdditions: (input: ReceizProofMemorySyncInput) => Promise<ReceizProofMemorySyncResult>;
+    };
+    readonly runtime: {
+        localFirst: (input?: ReceizRuntimeLocalFirstInput) => Promise<ReceizRuntimeLocalFirstResult>;
+    };
+    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>;
@@ -1640,17 +1998,25 @@ export declare class ReceizClient {
     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>>;
+    publishPublicStore<TState extends JsonObject = JsonObject>(input: ReceizPublicStorePublishInput<TState>, options?: ReceizIdempotencyOptions): Promise<ReceizAppStateFeedResponse>;
+    resolvePublicStore<TState extends JsonObject = JsonObject>(input: ReceizPublicStoreResolveInput): Promise<ReceizPublicStoreResolveResult<TState>>;
+    syncProofMemoryAdditions(input: ReceizProofMemorySyncInput): Promise<ReceizProofMemorySyncResult>;
+    resolveLocalFirstSurface<TValue>(surface: string, input: ReceizLocalFirstInput<TValue>): Promise<ReceizLocalFirstResult<TValue>>;
+    runtimeLocalFirst(input?: ReceizRuntimeLocalFirstInput): Promise<ReceizRuntimeLocalFirstResult>;
+    bootstrapCustomerSession(body: ReceizCustomerSessionBootstrapRequest, options?: ReceizIdempotencyOptions): Promise<ReceizCustomerSessionBootstrapResponse>;
     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;
     continueReceizId(identity: ReceizDeviceIdentity, options?: ReceizIdContinueOptions): Promise<JsonObject>;
     authorizeUrl(options: ReceizAuthorizeUrlOptions): string;
+    ensureTenantSession(input: ReceizEnsureTenantSessionInput): ReceizEnsureTenantSessionResult;
     private delegatedVerifyArtifact;
     private delegatedSealArtifact;
     private connectTransfer;
@@ -1712,6 +2078,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;