capacitor-plugin-cdv-purchase 13.18.0 → 13.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-plugin-cdv-purchase",
-  "version": "13.18.0",
+  "version": "13.20.0",
   "description": "In-App Purchases for Capacitor — iOS (StoreKit 2) and Android (Google Play Billing)",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -38,6 +38,7 @@
     "dist/",
     "types/",
     "www/",
+    "src/ts/platforms/iaptic-js/iaptic-js-types.d.ts",
     "android/",
     "!android/build",
     "ios/",

package/src/ts/platforms/iaptic-js/iaptic-js-types.d.ts

@@ -0,0 +1,451 @@
+declare namespace ModuleIapticJS {
+    /**
+     * Type of product that can be purchased:
+     *
+     * - subscription: A recurring subscription product
+     * - consumable: A product that can be purchased multiple times
+     * - non consumable: A product that can only be purchased once
+     * - paid subscription: An auto-renewing subscription
+     * - non renewing subscription: A subscription that does not auto-renew
+     * - application: The application itself
+     * - product: A generic product
+     *
+     * `'non_consumable'` is deprecated: the server never sends it. It is kept so existing
+     * code compiles, and will be removed in the next major version. Use `'non consumable'`.
+     */
+    export type ProductType = 'subscription' | 'consumable' | 'non consumable' | 'paid subscription' | 'non renewing subscription' | 'application' | 'product' | 'non_consumable';
+    /**
+     * Represents a pricing phase for an offer
+     * @remarks
+     * A pricing phase defines how much and when a customer will be charged.
+     * For example, a subscription might have an initial trial phase followed by a recurring payment phase.
+     */
+    export interface PricingPhase {
+        /** Price in micros (1/1,000,000 of the currency unit). For example, $1.99 = 1990000 micros */
+        priceMicros: number;
+        /** ISO 4217 currency code (e.g., 'USD', 'EUR', 'JPY') */
+        currency: string;
+        /**
+         * ISO 8601 duration string representing the billing period
+         * @example
+         * - 'P1M' = 1 month
+         * - 'P1Y' = 1 year
+         * - 'P7D' = 7 days
+         *
+         * Absent for one-time purchases.
+         */
+        billingPeriod: string;
+        /**
+         * Defines how the subscription recurs
+         * @remarks
+         * - INFINITE_RECURRING: Subscription continues until explicitly cancelled
+         * - NON_RECURRING: One-time purchase that does not auto-renew
+         * - FINITE_RECURRING: Subscription that renews a fixed number of times
+         */
+        recurrenceMode: 'INFINITE_RECURRING' | 'NON_RECURRING' | 'FINITE_RECURRING';
+        /**
+         * Defines when payment is collected
+         * @remarks
+         * - PayAsYouGo: Payment collected at the start of each billing period
+         * - UpFront: Full payment collected at time of purchase
+         * - FreeTrial: No payment during this phase
+         *
+         * `'PayUpFront'` is deprecated: the server never sends it. It is kept so existing
+         * code compiles, and will be removed in the next major version. Use `'UpFront'`.
+         */
+        paymentMode: 'PayAsYouGo' | 'UpFront' | 'FreeTrial' | 'PayUpFront';
+    }
+    /**
+     * Represents a purchase offer for a product
+     * @remarks
+     * An offer defines how a product can be purchased, including pricing and billing details
+     */
+    export interface Offer {
+        /** Unique identifier for the offer in the format 'platform:id' */
+        id: string;
+        /** Payment platform identifier (e.g., 'stripe', 'google', 'apple') */
+        platform: string;
+        /** Type of the offer */
+        offerType: 'Subscription' | 'Default' | 'Introductory';
+        /** Array of pricing phases that make up this offer's payment schedule */
+        pricingPhases: PricingPhase[];
+    }
+    /**
+     * Represents a product that can be purchased
+     */
+    export interface Product {
+        /** Type of the product (subscription, consumable, etc.) */
+        type: ProductType;
+        /** Unique identifier for the product */
+        id: string;
+        /** Display name of the product shown to customers */
+        title: string;
+        /** Optional detailed description of the product */
+        description?: string;
+        /** Available purchase offers for this product */
+        offers: Offer[];
+        /**
+         * Optional additional data associated with the product
+         * @remarks
+         * This can be used to store custom data needed by your application
+         */
+        metadata?: Record<string, any>;
+        /** Optional platform identifier (e.g., 'stripe') */
+        platform?: string;
+    }
+    /**
+     * Represents a purchased product
+     */
+    export interface Purchase {
+        /** Unique identifier for the purchase */
+        purchaseId: string;
+        /** Unique identifier for the transaction */
+        transactionId: string;
+        /** Unique identifier for the product */
+        productId: string;
+        /** Platform identifier (e.g., 'stripe') */
+        platform: 'stripe';
+        /** Date of the purchase (ISO 8601). Can be absent, check before use. */
+        purchaseDate: string;
+        /** Date of the last renewal (ISO 8601). Can be absent, check before use. */
+        lastRenewalDate: string;
+        /** Date of the expiration (ISO 8601). Absent for one-time purchases. */
+        expirationDate: string;
+        /**
+         * Intent of the renewal: 'Lapse' to let the subscription expire, 'Renew' to keep it
+         *
+         * `'Cancel'` is deprecated: the server never sends it. It is kept so existing
+         * code compiles, and will be removed in the next major version. Use `'Lapse'`.
+         */
+        renewalIntent: 'Lapse' | 'Renew' | 'Cancel';
+        /** Whether the purchase is a trial period */
+        isTrialPeriod: boolean;
+        /** Price in micros (1/1,000,000 of the currency unit) */
+        amountMicros: number;
+        /** Currency code (e.g., 'USD', 'EUR') */
+        currency: string;
+    }
+    /**
+     * Represents an order for a product
+     */
+    export interface Order {
+        /** Unique identifier for the offer */
+        offerId: string;
+        /** Username in the application */
+        applicationUsername: string;
+        /** URL to redirect to on success */
+        successUrl: string;
+        /** URL to redirect to on cancel */
+        cancelUrl: string;
+        /** Optional access token for the user */
+        accessToken?: string;
+    }
+    /** Plan change request */
+    export interface PlanChange {
+        /** Unique identifier for the purchase to replace */
+        purchaseId: string;
+        /** New offer to subscribe to */
+        offerId: string;
+        /** Optional access token for the user */
+        accessToken?: string;
+    }
+    /**
+     * Configuration options for creating an Iaptic adapter
+     * @remarks
+     * Currently only supports Stripe integration, but may support other platforms in the future
+     */
+    export interface Config {
+        /**
+         * Adapter type (currently only 'stripe' is supported)
+         * @remarks
+         * This field determines which payment platform will be used
+         */
+        type: 'stripe';
+        /**
+         * Your application name as configured on iaptic.com
+         * @remarks
+         * This must match exactly what you set up in the Iaptic dashboard
+         */
+        appName: string;
+        /**
+         * Your Iaptic public API key
+         * @remarks
+         * Can be found in your Iaptic dashboard under API settings
+         */
+        apiKey: string;
+        /**
+         * Stripe publishable key
+         */
+        stripePublicKey: string;
+        /**
+         * Optional custom Iaptic URL for private deployments
+         * @remarks
+         * Only needed if you're using a self-hosted version of Iaptic
+         */
+        customIapticUrl?: string;
+    }
+    
+    
+    /**
+     * Response from Iaptic's /stripe/products API
+     * @internal
+     */
+    export interface GetProductsResponse {
+        /** Whether the request was successful */
+        ok: boolean;
+        /** Array of available products */
+        products: Product[];
+    }
+    /**
+     * Response from Iaptic's /stripe/checkout API
+     * @internal
+     */
+    export interface PostCheckoutSessionResponse {
+        /** Whether the request was successful */
+        ok: boolean;
+        /** Stripe Checkout URL where the customer will be redirected */
+        url: string;
+        /** Access token for the customer */
+        accessToken: string;
+    }
+    /**
+     * Response from Iaptic's /stripe/purchases API
+     * @internal
+     */
+    export interface GetPurchasesResponse {
+        /** Whether the request was successful */
+        ok: boolean;
+        /** Array of customer's purchases */
+        purchases: Purchase[];
+        /** Optional new access token */
+        newAccessToken?: string;
+    }
+    /**
+     * Response from Iaptic's /stripe/change-plan API
+     * @internal
+     */
+    export interface ChangePlanResponse {
+        /** Whether the request was successful */
+        ok: boolean;
+        /** Updated purchase details */
+        purchase: Purchase;
+        /** Optional new access token */
+        newAccessToken?: string;
+    }
+    /**
+     * Main class for interacting with Iaptic's Stripe integration
+     * @remarks
+     * This class handles all Stripe-related operations including product listing,
+     * checkout sessions, and subscription management.
+     */
+    export class IapticStripe {
+        /**
+         * Creates a new IapticStripe instance
+         * @param config - Configuration options for the Stripe integration
+         * @throws Error if required configuration is missing
+         */
+        constructor(config: Config);
+        /**
+         * Gets a list of available products and their pricing
+         * @returns Promise resolving to an array of products
+         * @remarks
+         * Results are cached locally. Use refreshProducts() to force a fresh fetch.
+         */
+        getProducts(): Promise<Product[]>;
+        /**
+         * Forces a refresh of the products list from the server
+         * @returns Promise resolving to an array of products
+         */
+        refreshProducts(): Promise<Product[]>;
+        /**
+         * Gets the current access token if one exists
+         * @returns The current access token or undefined if none exists
+         */
+        getAccessToken(): string | undefined;
+        /**
+         * Creates a new order and redirects to Stripe Checkout
+         * @param params - Order parameters including product and URLs
+         * @throws Error if the checkout session creation fails
+         * @remarks
+         * This method will redirect the user to Stripe's checkout page on success
+         */
+        order(params: Order): Promise<void>;
+        /**
+         * Gets the customer's purchase history
+         * @param accessToken - Optional access token (uses stored token if not provided)
+         * @returns Promise resolving to an array of purchases
+         * @remarks
+         * This method will automatically schedule refresh operations for active subscriptions
+         */
+        getPurchases(accessToken?: string): Promise<Purchase[]>;
+        /**
+         * Redirects to Stripe Customer Portal for subscription management
+         * @param params - Portal parameters including return URL
+         * @throws Error if portal session creation fails
+         * @remarks
+         * This method will redirect the user to Stripe's customer portal on success
+         */
+        redirectToCustomerPortal(params: {
+            returnUrl?: string;
+            accessToken?: string;
+        }): Promise<void>;
+        /**
+         * Changes a subscription plan
+         * @param planChange - Plan change parameters
+         * @returns Promise resolving to the updated purchase details
+         * @remarks
+         * This method handles immediate plan changes without requiring customer portal access
+         */
+        changePlan(planChange: PlanChange): Promise<Purchase>;
+        /**
+         * Clears all stored data including access tokens and cached products
+         */
+        clearStoredData(): void;
+        onAccessTokenChange(callback: (accessToken: string) => void): void;
+    }
+    
+    
+    
+    /**
+     * Represents a scheduled refresh for a subscription
+     */
+    export interface ScheduledRefresh {
+        /** Unique identifier for the scheduled refresh */
+        id: string;
+        /** Unique identifier for the subscription */
+        subscriptionId: string;
+        /** Date and time of the scheduled refresh */
+        scheduledAt: number;
+        /** Whether the refresh has been completed */
+        completed: boolean;
+        /** Whether the refresh is currently in progress */
+        inProgress: boolean;
+        /** Reason for the scheduled refresh */
+        reason: string;
+    }
+    export class RefreshScheduler {
+        schedules: ScheduledRefresh[];
+        constructor(iapticStripe: IapticStripe);
+        scheduleRefresh(subscriptionId: string, date: Date, reason: string): void;
+        schedulePurchaseRefreshes(purchase: Purchase): void;
+        clearSchedules(): void;
+    }
+    
+    /**
+     * Utility functions for the Iaptic library
+     */
+    export class Utils {
+        /**
+         * Base64 encode a string with fallbacks for different environments
+         * @param str - String to encode
+         * @returns Base64 encoded string
+         * @remarks
+         * Handles non-ASCII characters and provides fallbacks for older browsers
+         * and Node.js environments
+         */
+        static base64Encode(str: string): string;
+        /**
+         * Get and parse a JSON item from localStorage
+         * @param key - Storage key
+         * @returns Parsed value or null if not found/invalid
+         * @internal
+         */
+        static storageGetJson<T>(key: string): T | null;
+        /**
+         * Get a string item from localStorage
+         * @param key - Storage key
+         * @returns String value or null if not found
+         * @internal
+         */
+        static storageGetString(key: string): string | null;
+        /**
+         * Store a JSON-serializable value in localStorage
+         * @param key - Storage key
+         * @param value - Value to store
+         * @returns true if successful, false if storage failed
+         * @internal
+         */
+        static storageSetJson(key: string, value: any): boolean;
+        /**
+         * Store a string value in localStorage
+         * @param key - Storage key
+         * @param value - String to store
+         * @returns true if successful, false if storage failed
+         * @internal
+         */
+        static storageSetString(key: string, value: string): boolean;
+        /**
+         * Remove an item from localStorage
+         * @param key - Storage key
+         * @returns true if successful, false if removal failed
+         * @internal
+         */
+        static storageRemove(key: string): boolean;
+        /**
+         * Build a URL with query parameters
+         * @param baseUrl - Base URL without query parameters
+         * @param params - Object containing query parameters
+         * @returns Complete URL with encoded query parameters
+         * @remarks
+         * Handles URL encoding and removes undefined/null parameters
+         * @internal
+         */
+        static buildUrl(baseUrl: string, params: Record<string, string>): string;
+        /**
+         * Format a currency amount from micros with proper localization
+         * @param amountMicros - Amount in micros (1/1,000,000 of currency unit)
+         * @param currency - ISO 4217 currency code (e.g., 'USD', 'EUR')
+         * @returns Formatted currency string
+         * @example
+         * ```ts
+         * Utils.formatCurrency(1990000, 'USD') // Returns "$1.99"
+         * Utils.formatCurrency(1000000, 'EUR') // Returns "€1"
+         * ```
+         */
+        static formatCurrency(amountMicros: number, currency: string): string;
+        /**
+         * Format an ISO 8601 period string into human-readable English
+         * @param period - ISO 8601 duration string
+         * @returns Human-readable period string
+         * @example
+         * ```ts
+         * Utils.formatBillingPeriodEN('P1M') // Returns "Monthly"
+         * Utils.formatBillingPeriodEN('P3M') // Returns "Every 3 months"
+         * Utils.formatBillingPeriodEN('P1Y') // Returns "Yearly"
+         * ```
+         */
+        static formatBillingPeriodEN(period: string): string;
+    }
+    
+    /**
+     * Creates an Iaptic adapter for the specified payment platform
+     * @param config - Configuration options for the adapter
+     * @returns An initialized adapter instance
+     * @throws Error if the specified adapter type is not supported
+     * @example
+     * ```ts
+     * const iaptic = createAdapter({
+     *   type: 'stripe',
+     *   appName: 'my-app',
+     *   apiKey: '1234567890'
+     * });
+     * ```
+     */
+    export function createAdapter(config: Config): IapticStripe;
+}
+
+/**
+ * Global IapticJS object available in browser environments
+ */
+interface Window {
+    IapticJS: {
+        /** Current version of the IapticJS library */
+        version: string;
+        /** Function to create a new Iaptic adapter */
+        createAdapter: typeof ModuleIapticJS.createAdapter;
+        /** Stripe adapter class */
+        IapticStripe: typeof ModuleIapticJS.IapticStripe;
+        /** Utility functions */
+        Utils: typeof ModuleIapticJS.Utils;
+    };
+}

package/www/store.d.ts

@@ -366,6 +366,18 @@ declare namespace CdvPurchase {
             /** List of verified receipts */
             verifiedReceipts: VerifiedReceipt[];
             constructor(controller: ValidatorController, log: Logger);
+            /** Maximum number of validation attempts for a receipt when failures are temporary */
+            maxAttempts: number;
+            /** Number of failed attempts in a row, per receipt */
+            private failedAttempts;
+            /** Backoff for retrying temporary failures (created on first use, it listens to the "online" event) */
+            private retry?;
+            /**
+             * Schedule a new validation if the failure is temporary and attempts remain.
+             *
+             * @return true if a retry was scheduled
+             */
+            private scheduleRetry;
             numRequests: number;
             numResponses: number;
             incrRequestsCounter(): void;
@@ -393,6 +405,20 @@ declare namespace CdvPurchase {
             private removeExpiredCache;
             private runValidatorRequest;
         }
+        /**
+         * True if a validation error is temporary (validator or store unreachable,
+         * server error, timeout, no network) rather than a definitive answer about
+         * the receipt.
+         *
+         * Error responses from the validator come in two shapes:
+         * - HTTP 200 with `{ ok: false, status, code }` in the body (iaptic does this,
+         *   so a store outage is `status: 502, code: 6778002` in the body);
+         * - a failed HTTP request, reported by the plugin as `code: COMMUNICATION`
+         *   with the transport status: 5xx, 408 (timeout), 417 (unreadable response,
+         *   e.g. a captive portal page), 0 or negative (no network, as reported by
+         *   XMLHttpRequest or cordova-plugin-advanced-http).
+         */
+        function isTransientError(payload: Validator.Response.ErrorPayload): boolean;
     }
 }
 declare namespace CdvPurchase {
@@ -905,8 +931,8 @@ declare namespace CdvPurchase {
     }
     /**
      * Persist a subset of {@link VerifiedPurchase} to device storage so that
-     * `store.owned()` works when the device is offline or has just restarted
-     * without connectivity.
+     * `offline.isOwned()` can answer "is this product owned?" when the device
+     * is offline or has just restarted without connectivity.
      *
      * Phase 1 — unsigned cache. No JWT, no crypto, no server changes.
      *
@@ -1046,7 +1072,7 @@ declare namespace CdvPurchase {
     /**
      * Current release number of the plugin.
      */
-    const PLUGIN_VERSION = "13.18.0";
+    const PLUGIN_VERSION = "13.20.0";
     /**
      * Entry class of the plugin.
      */
@@ -2181,7 +2207,23 @@ declare namespace CdvPurchase {
         lastRenewalDate?: Date;
         /** Time when the subscription is set to expire following this transaction */
         expirationDate?: Date;
-        /** True when the transaction has been acknowledged to the platform. */
+        /**
+         * True when the transaction has been acknowledged to the platform.
+         *
+         * - Google Play: the purchase was acknowledged (or consumed).
+         * - Apple App Store (StoreKit 2, Capacitor build only): the transaction was finished. StoreKit 2 re-reports
+         *   finished non-consumables and non-renewing subscriptions as `approved` at every
+         *   app launch; check this flag in your `approved()` handler to skip delivering them again.
+         *
+         * Undefined when the platform doesn't report it (including StoreKit 1 and the Cordova
+         * `cordova-plugin-purchase-storekit2` plugin).
+         *
+         * @example
+         * store.when().approved(transaction => {
+         *   if (transaction.isAcknowledged) return transaction.finish(); // already delivered
+         *   deliver(transaction).then(() => transaction.finish());
+         * });
+         */
         isAcknowledged?: boolean;
         /** True when the transaction is still pending payment. */
         isPending?: boolean;
@@ -3015,7 +3057,7 @@ declare namespace CdvPurchase {
             /** Extended callbacks with SK2 fields (same as SK2BridgeCallbacks) */
             interface CapacitorBridgeCallbacks extends Bridge.BridgeCallbacks {
                 purchased: (transactionIdentifier: string, productId: string, originalTransactionIdentifier?: string, transactionDate?: string, discountId?: string, expirationDate?: string, jwsRepresentation?: string, quantity?: number) => void;
-                restored: (transactionIdentifier: string, productId: string, originalTransactionIdentifier?: string, transactionDate?: string, discountId?: string, expirationDate?: string, jwsRepresentation?: string, quantity?: number) => void;
+                restored: (transactionIdentifier: string, productId: string, originalTransactionIdentifier?: string, transactionDate?: string, discountId?: string, expirationDate?: string, jwsRepresentation?: string, quantity?: number, isFinished?: boolean) => void;
             }
             class CapacitorNativeBridge implements Bridge.BridgeInterface {
                 appStoreReceipt: ApplicationReceipt | null;
@@ -3279,8 +3321,14 @@ declare namespace CdvPurchase {
                 deferred: (productId: string) => void;
                 /** Called when a transaction is in "finished" state */
                 finished: (transactionIdentifier: string, productId: string) => void;
-                /** Called when a transaction is in "restored" state */
-                restored: (transactionIdentifier: string, productId: string, originalTransactionIdentifier?: string, transactionDate?: string, discountId?: string, expirationDate?: string, jwsRepresentation?: string, quantity?: number) => void;
+                /**
+                 * Called when a transaction is in "restored" state.
+                 *
+                 * `isFinished` is set by StoreKit 2 bridges when known: true when the app
+                 * already finished the transaction (e.g. a finished entitlement re-emitted
+                 * at launch), false when it is still unfinished.
+                 */
+                restored: (transactionIdentifier: string, productId: string, originalTransactionIdentifier?: string, transactionDate?: string, discountId?: string, expirationDate?: string, jwsRepresentation?: string, quantity?: number, isFinished?: boolean) => void;
                 /** Called when the application receipt is refreshed */
                 receiptsRefreshed: (receipt: ApplicationReceipt) => void;
                 /** Called when a call to "restore" failed */
@@ -6635,6 +6683,9 @@ declare namespace CdvPurchase {
                      *
                      * It might be present when the server had to fallback to a backup validation solution. */
                     warning?: string;
+                    /** Present when the server answered from its last successful validation of this
+                     * receipt because the store couldn't be reached, instead of asking the store. */
+                    cache?: ValidatorCacheInfo;
                     /** Date and time the receipt was validated.
                      *
                      * It will provide the client with a more reliable clock time
@@ -6642,6 +6693,15 @@ declare namespace CdvPurchase {
                     date?: ISODate;
                 };
             }
+            /** Marker added by the validator to an answer that wasn't confirmed by the store just now. */
+            interface ValidatorCacheInfo {
+                /** Where the answer comes from. `last-verified`: the last answer the store confirmed for this exact receipt. */
+                source: 'last-verified' | (string & {});
+                /** Why the cache was used. `store_unreachable`: the store (Apple, Google, ...) couldn't be reached. */
+                reason: 'store_unreachable' | (string & {});
+                /** When the store last confirmed this receipt (ISO 8601). */
+                lastConfirmedAt: ISODate;
+            }
             type NativeTransaction = ({
                 type: 'braintree';
                 data: Braintree.TransactionObject;
@@ -6714,6 +6774,39 @@ declare namespace CdvPurchase {
     interface UnverifiedReceipt {
         receipt: Receipt;
         payload: Validator.Response.ErrorPayload;
+        /**
+         * True when validation failed without a definitive answer about the
+         * receipt: the validator (or the store behind it) couldn't be
+         * reached, timed out, answered with a server error, or responded with
+         * data the plugin couldn't process. The receipt may well be valid.
+         *
+         * Don't revoke access on a transient failure: keep what your app (or
+         * your server) last knew, and validate again later.
+         *
+         * The plugin already retried a few times (with backoff) before firing
+         * a transient failure. This matches the plugin's own retry decision:
+         * since v13.20.0, `BAD_RESPONSE` (the validator's answer was
+         * malformed) and `VERIFICATION_FAILED` (the plugin failed while
+         * processing the validator's answer) are reported as transient (they
+         * used to be `transient: false`).
+         *
+         * False when the validator gave a definitive answer (e.g. invalid
+         * receipt, expired subscription, authentication error).
+         *
+         * Transient:
+         * - HTTP 5xx, from the transport or as `payload.status` in the response body
+         * - `CONNECTION_FAILED` (6778002) from the validator
+         * - request timeout, no network, unreadable response
+         * - `BAD_RESPONSE`: the validator's answer was malformed
+         * - `VERIFICATION_FAILED`: the plugin failed while processing the
+         *   validator's answer
+         *
+         * Definitive: everything else (HTTP 400 `INVALID_PAYLOAD`, 401/403, 410,
+         * 419 expired, ...).
+         *
+         * Set by the plugin on every `unverified` event since v13.19.0.
+         */
+        transient?: boolean;
     }
     /** Receipt data as validated by the receipt validation server */
     class VerifiedReceipt {
@@ -6746,6 +6839,17 @@ declare namespace CdvPurchase {
          * When a warning is present, you should threat the content of this receipt accordingly.
          */
         warning?: string;
+        /**
+         * Set when the validator answered from its last successful validation of this receipt,
+         * because the store (Apple, Google, ...) couldn't be reached.
+         *
+         * `undefined` means the store confirmed this receipt during the validation.
+         * The content is the last one confirmed by the store, `cache.lastConfirmedAt` tells when.
+         *
+         * Receipts with a `cache` are as valid as the others (no purchase is owned past its `expiryDate`),
+         * but you might prefer to validate again later, or tell your users.
+         */
+        cache?: Validator.Response.ValidatorCacheInfo;
         /**
          * Id of the product that have been validated. Used internally.
          */