@aippy/runtime 0.4.1 → 0.4.2-beta.0

package/dist/{hooks-D5lkty5r.js → hooks-CMKwSLcQ.js}

@@ -15,7 +15,7 @@ async function v() {
   console.log("🔍 [useUserInfo] fetchUserInfoFromBridge started");
   const n = A();
   try {
-    const { getUserInfoAsync: o, getUserInfoFromParent: c, isInIframe: t } = await import("./bridge-CtB9L5kL.js").then((r) => r.b), { hasNativeBridge: f } = await import("./native-bridge-BnvipFJc.js"), i = f(), l = t();
+    const { getUserInfoAsync: o, getUserInfoFromParent: c, isInIframe: t } = await import("./bridge-K3HqQwdj.js").then((r) => r.d), { hasNativeBridge: f } = await import("./native-bridge-BnvipFJc.js"), i = f(), l = t();
     console.log("🔍 [useUserInfo] Environment check:", {
       hasNativeBridge: i,
       isInIframe: l,

package/dist/index/index.js

@@ -1,22 +1,24 @@
 import { D as r, g as s, m as o } from "../config-B0A7gHQM.js";
-import { _ as i, g as n, r as p } from "../bridge-CtB9L5kL.js";
-import { A as m, a as f, E as c, b as u, c as C } from "../errors-B3bDbQbD.js";
-import { S as g, V as I, c as d, a as E, g as S, s as x } from "../container-message-C3YXyTZj.js";
-import { A as U, C as _, R as T, a as D, p as v } from "../runtime-CmoG3v2m.js";
-import { CameraAPI as F, FileSystemAPI as P, GeolocationAPI as h, SensorsAPI as M, camera as O, fileSystem as b, geolocation as L, isMotionSupported as w, isOrientationSupported as H, requestMotionPermission as N, sensors as V, vibrate as B, watchMotion as k, watchOrientation as q } from "../device/index.js";
-import { P as G, a as z, c as K, b as W, g as X, i as Y, p as J, r as Q, s as Z } from "../app-version-checker-Bz7FrEZz.js";
+import { _ as i, g as n, r as p } from "../bridge-K3HqQwdj.js";
+import { A, a as f, E as c, b as g, c as l } from "../errors-B3bDbQbD.js";
+import { S as C, V as d, c as E, a as I, g as S, s as x } from "../container-message-gRiGPin4.js";
+import { A as U, C as _, R as M, a as D, p as T } from "../runtime-CmoG3v2m.js";
+import { CameraAPI as v, FileSystemAPI as y, GeolocationAPI as F, SensorsAPI as P, camera as O, fileSystem as V, geolocation as b, isMotionSupported as L, isOrientationSupported as w, requestMotionPermission as H, sensors as N, vibrate as k, watchMotion as B, watchOrientation as q } from "../device/index.js";
+import { P as j, a as z, c as K, b as W, g as X, i as Y, p as J, r as Q, s as Z } from "../app-version-checker-YVIFbytA.js";
 import { a as ee, P as ae, p as re, b as se } from "../pwa-C5nXU0DN.js";
 import { j as te } from "../url-c26cuIpu.js";
 import { a as ne, b as pe } from "../useTweaks-C7BEMpV3.js";
-import { c as me, b as fe, i as ce, p as ue, u as Ce, a as le } from "../useSound-z_eIn0KH.js";
-import { reportScore as Ie, sendEvent as de, updateScore as Ee } from "../leaderboard/index.js";
-import { D as xe, d as Re, e as Ue, c as _e, U as Te, a as De, b as ve, h as ye, g as Fe, l as Pe, n as he, p as Me, r as Oe, f as be, s as Le, v as we } from "../helper-WRpB-6MD.js";
-import { c as Ne, u as Ve } from "../hooks-D5lkty5r.js";
-import { hasNativeBridge as ke } from "../native-bridge-BnvipFJc.js";
+import { c as Ae, b as fe, i as ce, p as ge, u as le, a as ue } from "../useSound-z_eIn0KH.js";
+import { reportScore as de, sendEvent as Ee, updateScore as Ie } from "../leaderboard/index.js";
+import { D as xe, d as Re, e as Ue, c as _e, U as Me, V as De, a as Te, b as he, o as ve, i as ye, g as Fe, h as Pe, m as Oe, l as Ve, k as be, n as Le, p as we, r as He, f as Ne, j as ke, s as Be, v as qe } from "../helper-CJ3YV3nf.js";
+import { ministore as je } from "../ministore/index.js";
+import { c as Ke, u as We } from "../hooks-CMKwSLcQ.js";
+import { hasNativeBridge as Ye } from "../native-bridge-BnvipFJc.js";
+import { M as Qe } from "../recharge-o5P-y8eV.js";
 export {
   U as AippyRuntime,
-  m as AippyRuntimeError,
-  F as CameraAPI,
+  A as AippyRuntimeError,
+  v as CameraAPI,
   _ as Cancellable,
   xe as DEFAULT_BASE_URL,
   Re as DEFAULT_CHAT_MODEL,
@@ -25,73 +27,81 @@ export {
   _e as DEFAULT_UI_BASE_URL,
   f as ERROR_CODES,
   c as ERROR_PREFIX,
-  P as FileSystemAPI,
-  h as GeolocationAPI,
+  y as FileSystemAPI,
+  F as GeolocationAPI,
+  Qe as MinistoreError,
   ee as PWAUtils,
   ae as PerformanceMonitor,
-  G as PlatformDetector,
-  T as ReceiveChannel,
-  g as SDK_NAME,
-  M as SensorsAPI,
-  Te as UI_CHAT_ENDPOINT,
-  I as VERSION,
+  j as PlatformDetector,
+  M as ReceiveChannel,
+  C as SDK_NAME,
+  P as SensorsAPI,
+  Me as UI_CHAT_ENDPOINT,
+  d as VERSION,
+  De as ViggleGenerationError,
   i as _resetCachedApiBaseUrl,
-  De as aippyAIProvider,
-  ve as aippyChatConfig,
+  Te as aippyAIProvider,
+  he as aippyChatConfig,
   D as aippyRuntime,
   ne as aippyTweaks,
   pe as aippyTweaksRuntime,
   O as camera,
   z as checkFeatureSupport,
-  Ne as clearUserInfoCache,
+  Ke as clearUserInfoCache,
   K as compareVersions,
-  ye as createAIConfig,
-  d as createAippyHeaders,
-  E as createAippyHeadersAsync,
-  u as createCodeError,
-  C as createError,
-  me as createHiddenMediaElement,
-  b as fileSystem,
-  L as geolocation,
-  Fe as getAIConfigValue,
+  ve as createAIConfig,
+  E as createAippyHeaders,
+  I as createAippyHeadersAsync,
+  g as createCodeError,
+  l as createError,
+  Ae as createHiddenMediaElement,
+  ye as createViggleRequestId,
+  V as fileSystem,
+  Fe as generateCharacter3D,
+  Pe as generateMotion,
+  b as geolocation,
+  Oe as getAIConfigValue,
   n as getAuthTokenAsync,
   W as getAvailableFeatures,
   s as getConfigFromEnv,
   X as getFeatureVersionRequirements,
   S as getVersionInfo,
-  ke as hasNativeBridge,
+  Ye as hasNativeBridge,
   fe as isIOSDevice,
   Y as isInIframe,
   ce as isMediaStreamAudioSupported,
-  w as isMotionSupported,
-  H as isOrientationSupported,
+  L as isMotionSupported,
+  w as isOrientationSupported,
   te as joinUrl,
-  Pe as loadAIConfig,
+  Ve as listViggleModels,
+  be as loadAIConfig,
   o as mergeConfig,
-  he as normalizeError,
-  Me as parseAIConfig,
-  ue as patchAudioContext,
+  je as ministore,
+  Le as normalizeError,
+  we as parseAIConfig,
+  ge as patchAudioContext,
   re as performanceMonitor,
   J as platform,
-  v as processMotionData,
+  T as processMotionData,
   se as pwa,
-  Ie as reportScore,
-  N as requestMotionPermission,
+  de as reportScore,
+  H as requestMotionPermission,
   Q as requireFeatureSupport,
   p as resolveApiBaseUrl,
-  Oe as resolveOpenAIConfig,
-  be as resolveUIConfig,
-  Le as sendAIConfigToContainer,
-  de as sendEvent,
+  He as resolveOpenAIConfig,
+  Ne as resolveUIConfig,
+  ke as resumeViggleGeneration,
+  Be as sendAIConfigToContainer,
+  Ee as sendEvent,
   x as sendMessageToContainer,
-  V as sensors,
+  N as sensors,
   Z as showAlert,
-  Ee as updateScore,
-  Ce as useAudioContext,
-  le as useSound,
-  Ve as useUserInfo,
-  we as validateAIConfig,
-  B as vibrate,
-  k as watchMotion,
+  Ie as updateScore,
+  le as useAudioContext,
+  ue as useSound,
+  We as useUserInfo,
+  qe as validateAIConfig,
+  k as vibrate,
+  B as watchMotion,
   q as watchOrientation
 };

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export * from './tweaks';
 export * from './audio';
 export * from './leaderboard';
 export * from './ai';
+export * from './ministore';
 export * from './user';

package/dist/ministore/app-authorization.d.ts

@@ -0,0 +1,9 @@
+import { MinistoreAuthorization, MinistoreAuthorizationInput, MinistoreResult } from './types';
+export declare function usableAuthorization(data: MinistoreAuthorization, input: MinistoreAuthorizationInput): boolean;
+/** Native bridge plus the ministore app version floor. Silent: no upgrade banner. */
+export declare function isAuthorizationSupported(): boolean;
+/**
+ * Native records authorization only. No App login token, project ID or HTTP
+ * authorization writer is exposed to H5. Every bridge attempt gets its own ID.
+ */
+export declare function confirmInApp(input: MinistoreAuthorizationInput, signal?: AbortSignal): Promise<MinistoreResult<MinistoreAuthorization>>;

package/dist/ministore/authorization.d.ts

@@ -0,0 +1,6 @@
+import { MinistoreAuthorization, MinistoreAuthorizationInput, MinistoreRequestOptions, MinistoreResult } from './types';
+/**
+ * Ask the App to record authorization through wallet.authorize, then verify mall.
+ * Confirmation never purchases or consumes an entitlement.
+ */
+export declare function requestAuthorization(input: MinistoreAuthorizationInput, options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreAuthorization>>;

package/dist/ministore/consume.d.ts

@@ -0,0 +1,3 @@
+import { MinistoreConsumeInput, MinistoreRequestOptions, MinistoreResult, MinistoreSettlement } from './types';
+/** Consume the requested inventory/items; mall validates any automatic deficit purchase. */
+export declare function consume(input: MinistoreConsumeInput, options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreSettlement>>;

package/dist/ministore/errors.d.ts

@@ -0,0 +1,18 @@
+import { MinistoreErrorDetails, MinistoreErrorKind, MinistoreReason } from './types';
+export declare class MinistoreError extends Error {
+    readonly kind: MinistoreErrorKind;
+    readonly httpStatus?: number;
+    readonly code?: number | string;
+    readonly type?: string;
+    readonly reason?: MinistoreReason;
+    readonly appMessage?: string;
+    readonly traceId?: string;
+    readonly retryAfterMs?: number;
+    readonly bizOrderNo?: string;
+    readonly settlementUnknown: boolean;
+    readonly authorizationUnknown: boolean;
+    readonly cause?: unknown;
+    constructor(kind: MinistoreErrorKind, message: string, details?: MinistoreErrorDetails);
+}
+export declare function invalidInput(message: string): never;
+export declare function invalidResponse(): never;

package/dist/ministore/index.d.ts

@@ -0,0 +1,19 @@
+import { requestAuthorization } from './authorization';
+import { consume } from './consume';
+import { isPurchaseSupported, purchase } from './purchase';
+import { updateItem } from './update-item';
+import { getAuthorization, getGemBalance, listBenefits, listCatalog, listRecords } from './queries';
+export { MinistoreError } from './errors';
+export type { BenefitHolding, BenefitItem, BenefitRecord, BenefitState, CatalogDisplay, CatalogItem, MinistoreAuthMode, MinistoreAuthorization, MinistoreAuthorizationInput, MinistoreAuthorizationQuery, MinistoreBenefits, MinistoreCatalog, MinistoreConsumeInput, MinistoreErrorDetails, MinistoreErrorKind, MinistorePurchaseInput, MinistoreReason, MinistoreRecordsPage, MinistoreRecordsQuery, MinistoreRequestOptions, MinistoreResult, MinistoreSettlement, MinistoreUpdateItem, MinistoreUpdateItemInput, } from './types';
+export declare const ministore: {
+    getGemBalance: typeof getGemBalance;
+    getAuthorization: typeof getAuthorization;
+    requestAuthorization: typeof requestAuthorization;
+    listCatalog: typeof listCatalog;
+    listBenefits: typeof listBenefits;
+    isPurchaseSupported: typeof isPurchaseSupported;
+    purchase: typeof purchase;
+    consume: typeof consume;
+    updateItem: typeof updateItem;
+    listRecords: typeof listRecords;
+};

package/dist/ministore/index.js

@@ -0,0 +1,99 @@
+import { i as y, a as I, b as B, s as m, r as f, w as h, c as l, d, e as u, f as b, g, p as v, h as z, u as O, j as w, o as N, k as P, l as K, m as S, n as T, q as A, t as V, v as H } from "../recharge-o5P-y8eV.js";
+import { M as E } from "../recharge-o5P-y8eV.js";
+function p(e) {
+  if (e !== void 0)
+    return y(e, "bizOrderNo", 64), e;
+  if (typeof globalThis.crypto?.randomUUID == "function")
+    return globalThis.crypto.randomUUID();
+  I("This environment cannot create a secure bizOrderNo");
+}
+async function R(e, n = {}) {
+  B(e);
+  const t = p(e.bizOrderNo), s = m({
+    benefitKey: e.benefitKey,
+    bizOrderNo: t,
+    autoPurchase: e.autoPurchase === !0,
+    ...e.quantity === void 0 ? {} : { quantity: e.quantity },
+    ...e.itemIds === void 0 ? {} : { itemIds: e.itemIds },
+    ...e.itemValues === void 0 ? {} : { itemValues: e.itemValues }
+  }), a = f(n);
+  return h(
+    () => l(
+      "benefits/consume",
+      a.options,
+      { method: "POST", bizOrderNo: t, body: s },
+      (c) => d(c, (i) => ({
+        benefit: g(i.benefit),
+        charged: u(i.charged),
+        idempotentHit: b(i.idempotentHit),
+        bizOrderNo: t,
+        ..."walletBalance" in i ? { walletBalance: u(i.walletBalance, !0) } : {}
+      }))
+    ),
+    a,
+    t,
+    s.autoPurchase && s.itemIds === void 0
+  );
+}
+function U() {
+  return z();
+}
+async function M(e, n = {}) {
+  v(e);
+  const t = e.itemValues, s = e.quantity ?? t?.length ?? 1, a = p(e.bizOrderNo), o = m({
+    benefitKey: e.benefitKey,
+    quantity: s,
+    bizOrderNo: a,
+    ...t === void 0 ? {} : { itemValues: t }
+  }), c = f(n);
+  return h(() => l(
+    "benefits/purchase",
+    c.options,
+    {
+      method: "POST",
+      bizOrderNo: a,
+      body: o
+    },
+    (q) => d(q, (r) => ({
+      benefit: g(r.benefit),
+      charged: u(r.charged),
+      idempotentHit: b(r.idempotentHit),
+      bizOrderNo: a,
+      ..."walletBalance" in r ? { walletBalance: u(r.walletBalance, !0) } : {}
+    }))
+  ), c, a);
+}
+async function x(e, n = {}) {
+  return O(e), l(
+    "benefits/items/update",
+    n,
+    {
+      method: "POST",
+      body: {
+        benefitKey: e.benefitKey,
+        itemId: e.itemId,
+        value: e.value
+      }
+    },
+    (t) => d(t, (s) => {
+      const a = w(s.reason), o = N(s.item);
+      return o ? { item: o } : (a === "" && P(), {});
+    })
+  );
+}
+const j = {
+  getGemBalance: H,
+  getAuthorization: V,
+  requestAuthorization: A,
+  listCatalog: T,
+  listBenefits: S,
+  isPurchaseSupported: U,
+  purchase: M,
+  consume: R,
+  updateItem: x,
+  listRecords: K
+};
+export {
+  E as MinistoreError,
+  j as ministore
+};

package/dist/ministore/order.d.ts

@@ -0,0 +1 @@
+export declare function createBizOrderNo(value?: string): string;

package/dist/ministore/purchase.d.ts

@@ -0,0 +1,5 @@
+import { MinistorePurchaseInput, MinistoreRequestOptions, MinistoreResult, MinistoreSettlement } from './types';
+/** Native bridge and ministore app version floor; not backend readiness. */
+export declare function isPurchaseSupported(): boolean;
+/** Settle an explicit purchase; mall enforces its server-recorded authorization. */
+export declare function purchase(input: MinistorePurchaseInput, options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreSettlement>>;

package/dist/ministore/queries.d.ts

@@ -0,0 +1,14 @@
+import { MinistoreAuthorization, MinistoreAuthorizationQuery, MinistoreBenefits, MinistoreCatalog, MinistoreRecordsPage, MinistoreRecordsQuery, MinistoreRequestOptions, MinistoreResult } from './types';
+/**
+ * Read the user's GEM balance from the mall wallet.
+ * The mall wallet endpoint returns { balance: number, assetType: 'GEM' }.
+ * No account is a real zero; wallet failures are never replaced with a fake zero.
+ */
+export declare function getGemBalance(options?: MinistoreRequestOptions): Promise<number>;
+/** Read mall authorization state; this endpoint never writes authorization. */
+export declare function getAuthorization(query: MinistoreAuthorizationQuery, options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreAuthorization>>;
+export declare function listCatalog(options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreCatalog>>;
+/** Includes previously used benefits even when their current quantity is zero. */
+export declare function listBenefits(options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreBenefits>>;
+/** Filter successful project orders; full history requires a compatible mall service. */
+export declare function listRecords(query?: MinistoreRecordsQuery, options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreRecordsPage>>;

package/dist/ministore/recharge.d.ts

@@ -0,0 +1,12 @@
+import { MinistoreRequestOptions, MinistoreResult } from './types';
+interface Scope {
+    options: MinistoreRequestOptions;
+    check: () => void;
+    prepareContinuation: () => void;
+    available: () => boolean;
+}
+/** Bind continuation to the fresh credential identity of the original request. */
+export declare function rechargeScope(options: MinistoreRequestOptions): Scope;
+/** One recharge and one original-order continuation, never an authorization or retry loop. */
+export declare function withRecharge<T>(request: () => Promise<MinistoreResult<T>>, scope: Scope, bizOrderNo: string, enabled?: boolean): Promise<MinistoreResult<T>>;
+export {};

package/dist/ministore/transport.d.ts

@@ -0,0 +1,14 @@
+import { MinistoreRequestOptions } from './types';
+/** Internal per-operation guard; never a public option or a credential cache. */
+export declare const REQUEST_SCOPE_CHECK: unique symbol;
+interface RequestInit {
+    method: 'GET' | 'POST';
+    body?: unknown;
+    bizOrderNo?: string;
+}
+/** Validate before requesting credentials or opening native authorization UI. */
+export declare function ministoreApiBaseUrl(baseUrl?: string): string;
+/** Keep the same finite JSON contents across a recharge continuation. */
+export declare function snapshotRequestBody<T>(body: T): T;
+export declare function requestMinistore<T>(path: string, options: MinistoreRequestOptions, init: RequestInit, parse: (body: unknown) => T): Promise<T>;
+export {};

package/dist/ministore/types.d.ts

@@ -0,0 +1,177 @@
+export interface MinistoreRequestOptions {
+    /** Official HTTPS Aippy API origin with /aisdk/v1/; arbitrary proxies are rejected. */
+    baseUrl?: string;
+    /** Explicit App-Language. Omit to use the backend's default language. */
+    language?: string;
+    signal?: AbortSignal;
+}
+export type MinistoreReason = 'project_unresolved' | 'unknown_action' | 'inactive' | 'limit_reached' | 'limit_exceeded' | 'user_purchase_limit' | 'total_purchase_limit' | 'purchase_interval' | 'purchase_window_limit' | 'authorization_required' | 'not_consumable' | 'out_of_stock' | 'insufficient_balance' | 'payment_rejected' | 'idempotency_conflict' | (string & {});
+export type MinistoreResult<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    reason: MinistoreReason;
+    data: T;
+};
+export interface CatalogDisplay {
+    title: string;
+    subtitle: string;
+    iconUrl: string;
+}
+export type MinistoreAuthMode = 'none' | 'once' | 'every' | (string & {});
+export interface BenefitHolding {
+    orderId: string;
+    bizOrderNo: string;
+    value: unknown;
+    quantity: number;
+    createdAt: string;
+    source: 'PURCHASE' | 'FREE' | (string & {});
+}
+export interface BenefitItem {
+    itemId: string;
+    value: unknown;
+    orderId: string;
+    bizOrderNo: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface BenefitState {
+    benefitKey: string;
+    kind: 'fixed' | 'inventory' | 'item' | (string & {});
+    /** Entitlement snapshot; its shape is defined by the project. */
+    value: unknown;
+    quantity: number;
+    used: number;
+    display: CatalogDisplay;
+    holdings: BenefitHolding[];
+    items: BenefitItem[];
+}
+export interface CatalogItem extends Omit<BenefitState, 'holdings' | 'items'> {
+    price: number;
+    freeQuota: number;
+    /** Zero means no configured inventory limit. Fixed benefits follow server rules. */
+    maxQuantity: number;
+    consumable: boolean;
+    maxUserPurchase: number;
+    userPurchased: number;
+    maxTotalPurchase: number;
+    totalSold: number;
+    authMode: MinistoreAuthMode;
+    authRequired: boolean;
+    authorized: boolean;
+    authorizedAt: string;
+}
+export interface BenefitRecord {
+    id: string;
+    op: 'PURCHASE' | 'CONSUME' | (string & {});
+    benefitKey: string;
+    quantity: number;
+    charged: number;
+    projectName: string;
+    createdAt: string;
+    bizOrderNo: string;
+    value: unknown;
+}
+export interface MinistoreAuthorizationQuery {
+    benefitKey: string;
+    /** Required by mall for every-order authorization; optional for once. */
+    bizOrderNo?: string;
+}
+export interface MinistoreAuthorization {
+    benefitKey: string;
+    authMode: MinistoreAuthMode;
+    authorized: boolean;
+    authorizedAt: string;
+    bizOrderNo: string;
+    quantity: number;
+    amount: number;
+    expireAt: string;
+    used: boolean;
+}
+/** Native confirmation input. App login credentials and project IDs stay native. */
+export interface MinistoreAuthorizationInput {
+    operation: 'purchase' | 'consume';
+    benefitKey: string;
+    quantity: number;
+    /** Stable business order, distinct from the SDK-generated bridge requestId. */
+    bizOrderNo: string;
+    title: string;
+    buttonText: string;
+    content?: string;
+}
+export interface MinistoreCatalog {
+    enabled: boolean;
+    items: CatalogItem[];
+}
+export interface MinistoreBenefits {
+    benefits: BenefitState[];
+}
+export interface MinistoreRecordsPage {
+    records: BenefitRecord[];
+    nextCursor: string;
+}
+/** Full filters and zero-GEM history require a compatible aisdk/mall deployment. */
+export interface MinistoreRecordsQuery {
+    cursor?: string;
+    limit?: number;
+    /** Exact product key, merged with benefitKeys. */
+    benefitKey?: string;
+    /** Merged with benefitKey; at most 50 distinct keys after normalization. */
+    benefitKeys?: string[];
+    ops?: ('PURCHASE' | 'CONSUME')[];
+    /** Leave charge unrestricted, including zero-GEM consumption. */
+    charge?: 'CHARGED' | 'UNCHARGED';
+}
+export interface MinistoreConsumeInput {
+    benefitKey: string;
+    /** SDK-generated when omitted; retain one order per action for retries. */
+    bizOrderNo?: string;
+    /** Buy the inventory deficit if needed; ignored for explicit itemIds. */
+    autoPurchase?: boolean;
+    /** Consume this many inventory units; defaults to one. */
+    quantity?: number;
+    /** For item benefits, consume these exact item IDs instead of FIFO selection. */
+    itemIds?: string[];
+    /** For item benefits: replace each consumed item's value, or initialize
+     * automatically purchased deficit items. Mall validates the exact deficit. */
+    itemValues?: unknown[];
+}
+export interface MinistoreSettlement {
+    benefit: BenefitState;
+    charged: number;
+    walletBalance?: number;
+    idempotentHit: boolean;
+    bizOrderNo: string;
+}
+export interface MinistorePurchaseInput {
+    benefitKey: string;
+    quantity?: number;
+    /** For item benefits, the value of each purchased item. */
+    itemValues?: unknown[];
+    /** SDK-generated when omitted; retain one order per action for retries. */
+    bizOrderNo?: string;
+}
+export interface MinistoreUpdateItemInput {
+    benefitKey: string;
+    itemId: string;
+    value: unknown;
+}
+export interface MinistoreUpdateItem {
+    item?: BenefitItem;
+}
+export type MinistoreErrorKind = 'validation' | 'auth' | 'http' | 'network' | 'protocol' | 'unsupported' | 'abort' | 'authorization' | 'recharge';
+export interface MinistoreErrorDetails {
+    httpStatus?: number;
+    code?: number | string;
+    type?: string;
+    /** Native business refusal reason, distinct from transport type/code. */
+    reason?: MinistoreReason;
+    appMessage?: string;
+    traceId?: string;
+    retryAfterMs?: number;
+    bizOrderNo?: string;
+    settlementUnknown?: boolean;
+    authorizationUnknown?: boolean;
+    cause?: unknown;
+}

package/dist/ministore/update-item.d.ts

@@ -0,0 +1,3 @@
+import { MinistoreRequestOptions, MinistoreResult, MinistoreUpdateItem, MinistoreUpdateItemInput } from './types';
+/** Update one still-owned item; mall returns a business refusal in the envelope. */
+export declare function updateItem(input: MinistoreUpdateItemInput, options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreUpdateItem>>;

package/dist/ministore/validation.d.ts

@@ -0,0 +1,19 @@
+import { BenefitItem, BenefitState, MinistoreAuthorization, MinistoreConsumeInput, MinistorePurchaseInput, MinistoreResult, MinistoreUpdateItemInput } from './types';
+export declare function object(value: unknown): Record<string, unknown>;
+export declare function string(value: unknown): string;
+export declare function integer(value: unknown, signed?: boolean): number;
+export declare function boolean(value: unknown): boolean;
+export declare function array<T>(value: unknown, parse: (value: unknown) => T): T[];
+export declare function benefitSummary(value: unknown): Omit<BenefitState, 'holdings' | 'items'>;
+export declare function benefitItem(value: unknown): BenefitItem;
+export declare function optionalBenefitItem(value: unknown): BenefitItem | undefined;
+export declare function benefit(value: unknown): BenefitState;
+export declare function result<T>(value: unknown, parse: (body: Record<string, unknown>) => T): MinistoreResult<T>;
+export declare function authorization(body: Record<string, unknown>): MinistoreAuthorization;
+export declare function action(input: MinistoreConsumeInput): void;
+export declare function purchaseAction(input: MinistorePurchaseInput): void;
+export declare function updateItemAction(input: MinistoreUpdateItemInput): void;
+export declare function identity(value: unknown, name: string, maxLength?: number): asserts value is string;
+export declare function quantity(value: unknown): number;
+export declare function isCursor(value: string): boolean;
+export declare function isItemId(value: string): boolean;

package/dist/ministore.d.ts

@@ -0,0 +1,2 @@
+export * from './ministore/index'
+export {}