@base44-preview/sdk 0.8.48-pr.145.de7eff3 → 0.8.48-pr.276.4f760f9

package/dist/iap/account-token.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The namespace every Base44 in-app purchase account token is derived under.
+ *
+ * A fixed, arbitrary version-4 UUID. It must never change: the native shell
+ * derives the same value independently, and Apple has already signed the
+ * results into transactions that will keep renewing.
+ */
+export declare const IAP_APP_ACCOUNT_TOKEN_NAMESPACE = "8f2b6a1e-4c5d-4e7a-9b3f-6d1a2c8e5f04";
+/**
+ * Derives the account token for a Base44 user id.
+ *
+ * @throws {TypeError} when the user id is empty.
+ */
+export declare function appAccountTokenFor(base44UserId: string): string;

package/dist/iap/account-token.js

@@ -0,0 +1,43 @@
+/**
+ * Mapping a Base44 user to the UUID Apple signs into their purchases.
+ *
+ * StoreKit accepts a UUID at purchase time (`appAccountToken`) and Apple
+ * returns the same value in every resulting transaction — including renewals
+ * years later. That signed round trip is the entire attribution mechanism: it
+ * is the only way to know whose purchase a transaction is, without trusting
+ * anything the client claims.
+ *
+ * The mapping is a deterministic version-5 UUID of the user id under a fixed
+ * namespace, so it is a pure function. The shell, the web app and the backend
+ * all derive the same UUID from the same user id with no lookup table to keep
+ * in sync, and nothing to migrate.
+ *
+ * Two consequences worth knowing:
+ *
+ * - The namespace is part of the contract. Changing it orphans every purchase
+ *   already attributed under the old one.
+ * - The mapping is one-way in practice. Recovering a user id means deriving
+ *   the UUID for a candidate user and comparing, not inverting the hash.
+ *
+ * @internal
+ */
+import { v5 as uuidv5 } from "uuid";
+/**
+ * The namespace every Base44 in-app purchase account token is derived under.
+ *
+ * A fixed, arbitrary version-4 UUID. It must never change: the native shell
+ * derives the same value independently, and Apple has already signed the
+ * results into transactions that will keep renewing.
+ */
+export const IAP_APP_ACCOUNT_TOKEN_NAMESPACE = "8f2b6a1e-4c5d-4e7a-9b3f-6d1a2c8e5f04";
+/**
+ * Derives the account token for a Base44 user id.
+ *
+ * @throws {TypeError} when the user id is empty.
+ */
+export function appAccountTokenFor(base44UserId) {
+    if (typeof base44UserId !== "string" || base44UserId.length === 0) {
+        throw new TypeError("a Base44 user id is required to derive an account token");
+    }
+    return uuidv5(base44UserId, IAP_APP_ACCOUNT_TOKEN_NAMESPACE);
+}

package/dist/iap/config.d.ts

@@ -0,0 +1,18 @@
+import type { IapConfig, IapProductConfig } from "./iap.types.js";
+import type { IapServerApiConfig } from "./server-api/server-api.types.js";
+/** A validated configuration, with every default filled in. */
+export interface ResolvedIapConfig {
+    readonly bundleId: string;
+    readonly appAppleId: number;
+    readonly products: Readonly<Record<string, IapProductConfig>>;
+    readonly testMode: boolean;
+    readonly allowLocalTesting: boolean;
+    readonly serverApi?: IapServerApiConfig;
+}
+/**
+ * Validates a configuration and fills in defaults.
+ *
+ * @throws {IapConfigError} `IAP_INVALID_CONFIG` for anything malformed, or
+ * `IAP_ONLINE_CHECKS_UNSUPPORTED` when online certificate checks are asked for.
+ */
+export declare function resolveConfig(config: IapConfig): ResolvedIapConfig;

package/dist/iap/config.js

@@ -0,0 +1,99 @@
+/**
+ * Configuration validation.
+ *
+ * Runs once, when the client is created, and refuses to build a client it
+ * cannot operate correctly. Failing at deploy time is the whole point: the
+ * alternative is discovering a missing `appAppleId` when Apple sends the first
+ * refund notification.
+ *
+ * @internal
+ */
+import { IapConfigError } from "./errors.js";
+const PRODUCT_TYPES = new Set([
+    "consumable",
+    "nonConsumable",
+    "nonRenewingSubscription",
+    "autoRenewableSubscription",
+]);
+function invalid(message) {
+    throw new IapConfigError("IAP_INVALID_CONFIG", message);
+}
+/**
+ * Validates a configuration and fills in defaults.
+ *
+ * @throws {IapConfigError} `IAP_INVALID_CONFIG` for anything malformed, or
+ * `IAP_ONLINE_CHECKS_UNSUPPORTED` when online certificate checks are asked for.
+ */
+export function resolveConfig(config) {
+    var _a;
+    if (!config || typeof config !== "object") {
+        invalid("an in-app purchase configuration object is required");
+    }
+    if (typeof config.bundleId !== "string" || config.bundleId.trim().length === 0) {
+        invalid("'bundleId' is required, e.g. \"com.example.app\"");
+    }
+    // A very common mix-up: passing the bundle id where the numeric id belongs.
+    if (typeof config.appAppleId === "string") {
+        invalid("'appAppleId' must be a number — the numeric App Store id from App Store " +
+            "Connect under App Information, not the bundle id");
+    }
+    if (typeof config.appAppleId !== "number" ||
+        !Number.isInteger(config.appAppleId) ||
+        config.appAppleId <= 0) {
+        invalid("'appAppleId' must be a positive integer, e.g. 1234567890");
+    }
+    if (!config.products || typeof config.products !== "object") {
+        invalid("'products' is required, keyed by product identifier");
+    }
+    for (const [productId, product] of Object.entries(config.products)) {
+        if (!product || typeof product !== "object") {
+            invalid(`product ${JSON.stringify(productId)} must be an object`);
+        }
+        if (!PRODUCT_TYPES.has(product.type)) {
+            invalid(`product ${JSON.stringify(productId)} has type ${JSON.stringify(product.type)}; expected one of ${[...PRODUCT_TYPES].join(", ")}`);
+        }
+        // Apple never expires a non-renewing subscription, so this number is the
+        // only thing that decides when access ends. Missing it would silently
+        // grant the product forever.
+        if (product.type === "nonRenewingSubscription") {
+            const days = product.nonRenewingDurationDays;
+            if (typeof days !== "number" || !Number.isFinite(days) || days <= 0) {
+                invalid(`product ${JSON.stringify(productId)} is a nonRenewingSubscription, so it ` +
+                    "needs 'nonRenewingDurationDays' — Apple does not expire these, so the " +
+                    "app decides how long they last");
+            }
+        }
+    }
+    // `null` is treated as absent, not as invalid: a secret that was never set
+    // arrives that way, and the right answer then is "the API is not configured"
+    // — which the call itself reports clearly — rather than refusing to start.
+    if (config.serverApi !== undefined && config.serverApi !== null) {
+        const api = config.serverApi;
+        if (typeof api !== "object") {
+            invalid("'serverApi' must be an object, or left out entirely");
+        }
+        for (const field of ["keyId", "issuerId", "privateKeyP8"]) {
+            if (typeof api[field] !== "string" || api[field].trim().length === 0) {
+                invalid(`'serverApi.${field}' is required when serverApi is supplied`);
+            }
+        }
+        if (!api.privateKeyP8.includes("PRIVATE KEY")) {
+            invalid("'serverApi.privateKeyP8' does not look like a .p8 file. Pass its whole " +
+                "contents, including the BEGIN and END lines.");
+        }
+    }
+    if (config.onlineChecks === true) {
+        throw new IapConfigError("IAP_ONLINE_CHECKS_UNSUPPORTED", "'onlineChecks' asks for certificate revocation lookups, which this version " +
+            "does not implement. Leave it unset. Certificate validity is evaluated at " +
+            "each payload's own signedDate, which is what Apple's own library does with " +
+            "online checks off.");
+    }
+    return {
+        bundleId: config.bundleId,
+        appAppleId: config.appAppleId,
+        products: { ...config.products },
+        testMode: config.testMode === true,
+        allowLocalTesting: config.allowLocalTesting === true,
+        serverApi: (_a = config.serverApi) !== null && _a !== void 0 ? _a : undefined,
+    };
+}

package/dist/iap/errors.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Error classes for the in-app purchase module.
+ *
+ * Each class carries a `code` from `errors.types.ts`. Nothing here imports the
+ * runtime helpers, so the runtime layer can throw these freely.
+ *
+ * @internal
+ */
+import type { IapApiErrorCode, IapConfigErrorCode, IapSetupErrorCode, IapStoreErrorCode, IapVerificationErrorCode } from "./errors.types.js";
+/** Base class, so a caller can catch every error this module raises at once. */
+export declare class IapError extends Error {
+    /** Stable machine-readable code. */
+    readonly code: string;
+    constructor(code: string, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * A signed Apple token was rejected.
+ *
+ * Deny by default: anything that raises this must be treated as "not
+ * entitled", never as "probably fine".
+ */
+export declare class IapVerificationError extends IapError {
+    readonly code: IapVerificationErrorCode;
+    constructor(code: IapVerificationErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** The module cannot start, or was asked for something its configuration does not allow. */
+export declare class IapConfigError extends IapError {
+    readonly code: IapConfigErrorCode;
+    constructor(code: IapConfigErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * The app's Base44 setup is not usable — an entity is missing, or its schema
+ * has drifted from what the SDK writes.
+ *
+ * This is loud on purpose. A silently dropped field means purchase data is
+ * being lost, which is worse than an outage.
+ */
+export declare class IapSetupError extends IapError {
+    readonly code: IapSetupErrorCode;
+    /** The entity the problem was found on. */
+    readonly entityName?: string;
+    /** Fields the entity dropped, when the code is `IAP_ENTITY_SCHEMA_DRIFT`. */
+    readonly missingFields?: string[];
+    constructor(code: IapSetupErrorCode, message: string, details?: {
+        entityName?: string;
+        missingFields?: string[];
+        cause?: unknown;
+    });
+}
+/** A read or write against the app's entities failed. */
+export declare class IapStoreError extends IapError {
+    readonly code: IapStoreErrorCode;
+    /** The entity being read or written. */
+    readonly entityName?: string;
+    constructor(code: IapStoreErrorCode, message: string, details?: {
+        entityName?: string;
+        cause?: unknown;
+    });
+}
+/** An App Store Server API call failed. */
+export declare class IapApiError extends IapError {
+    readonly code: IapApiErrorCode;
+    /** The HTTP status Apple returned. */
+    readonly httpStatus?: number;
+    /** Apple's own numeric error code from the response body, e.g. `4040010`. */
+    readonly appleErrorCode?: number;
+    /** Apple's own error message from the response body. */
+    readonly appleErrorMessage?: string;
+    /**
+     * When rate-limited: the value of Apple's `Retry-After` header.
+     *
+     * Apple sends an **absolute UNIX millisecond timestamp** here, not a delay.
+     * Compare it against `Date.now()`; do not use it as a duration.
+     */
+    readonly retryAfter?: number;
+    constructor(code: IapApiErrorCode, message: string, details?: {
+        httpStatus?: number;
+        appleErrorCode?: number;
+        appleErrorMessage?: string;
+        retryAfter?: number;
+        cause?: unknown;
+    });
+}

package/dist/iap/errors.js

@@ -0,0 +1,66 @@
+/** Base class, so a caller can catch every error this module raises at once. */
+export class IapError extends Error {
+    constructor(code, message, options) {
+        super(message);
+        this.name = "IapError";
+        this.code = code;
+        // `cause` is set by hand rather than passed to super: the emit target is
+        // es2018, whose Error constructor takes no options bag.
+        if (options && "cause" in options) {
+            this.cause = options.cause;
+        }
+    }
+}
+/**
+ * A signed Apple token was rejected.
+ *
+ * Deny by default: anything that raises this must be treated as "not
+ * entitled", never as "probably fine".
+ */
+export class IapVerificationError extends IapError {
+    constructor(code, message, options) {
+        super(code, message, options);
+        this.name = "IapVerificationError";
+    }
+}
+/** The module cannot start, or was asked for something its configuration does not allow. */
+export class IapConfigError extends IapError {
+    constructor(code, message, options) {
+        super(code, message, options);
+        this.name = "IapConfigError";
+    }
+}
+/**
+ * The app's Base44 setup is not usable — an entity is missing, or its schema
+ * has drifted from what the SDK writes.
+ *
+ * This is loud on purpose. A silently dropped field means purchase data is
+ * being lost, which is worse than an outage.
+ */
+export class IapSetupError extends IapError {
+    constructor(code, message, details) {
+        super(code, message, { cause: details === null || details === void 0 ? void 0 : details.cause });
+        this.name = "IapSetupError";
+        this.entityName = details === null || details === void 0 ? void 0 : details.entityName;
+        this.missingFields = details === null || details === void 0 ? void 0 : details.missingFields;
+    }
+}
+/** A read or write against the app's entities failed. */
+export class IapStoreError extends IapError {
+    constructor(code, message, details) {
+        super(code, message, { cause: details === null || details === void 0 ? void 0 : details.cause });
+        this.name = "IapStoreError";
+        this.entityName = details === null || details === void 0 ? void 0 : details.entityName;
+    }
+}
+/** An App Store Server API call failed. */
+export class IapApiError extends IapError {
+    constructor(code, message, details) {
+        super(code, message, { cause: details === null || details === void 0 ? void 0 : details.cause });
+        this.name = "IapApiError";
+        this.httpStatus = details === null || details === void 0 ? void 0 : details.httpStatus;
+        this.appleErrorCode = details === null || details === void 0 ? void 0 : details.appleErrorCode;
+        this.appleErrorMessage = details === null || details === void 0 ? void 0 : details.appleErrorMessage;
+        this.retryAfter = details === null || details === void 0 ? void 0 : details.retryAfter;
+    }
+}

package/dist/iap/errors.types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Error codes the in-app purchase module can raise.
+ *
+ * Every code is a stable string. Generated code and support tooling branch on
+ * these, so a code is never renamed — a new situation gets a new code.
+ */
+/**
+ * Why a signed Apple token was rejected.
+ *
+ * The first eight come straight from the verification algorithm Apple
+ * describes; the last two are this SDK's own.
+ */
+export type IapVerificationErrorCode = 
+/** The token is not three base64url segments separated by dots. */
+"INVALID_JWS_FORMAT"
+/** The JWS header named an algorithm other than `ES256`. */
+ | "UNSUPPORTED_ALG"
+/** The `x5c` header did not carry exactly three certificates. */
+ | "INVALID_CHAIN_LENGTH"
+/** A certificate failed to parse, was outside its validity window, or lacked a required marker. */
+ | "INVALID_CERTIFICATE"
+/** A certificate was revoked. Only reachable with online checks, which v1 does not support. */
+ | "CERTIFICATE_REVOKED"
+/** The signature did not verify against the leaf certificate's public key. */
+ | "INVALID_SIGNATURE"
+/** The payload's `bundleId`, or its `appAppleId` in production, did not match the configuration. */
+ | "INVALID_APP_IDENTIFIER"
+/** The payload's `environment` was not one this app accepts. */
+ | "INVALID_ENVIRONMENT"
+/** A transient failure. Retrying may succeed. */
+ | "RETRYABLE_VERIFICATION_FAILURE"
+/**
+ * The chain anchored at a root this SDK cannot verify against — an RSA root.
+ *
+ * Current App Store tokens chain to Apple Root CA - G3, which is ECDSA
+ * P-384. Apple Root CA - G2 and Apple Inc. Root are RSA and are pinned for
+ * completeness, but v1 verifies ECDSA signatures only. This is never
+ * downgraded to a pass.
+ */
+ | "UNSUPPORTED_CERT_ALGORITHM";
+/** Why the module refused to start, or could not use its configuration. */
+export type IapConfigErrorCode = 
+/** A required configuration field was missing or malformed. */
+"IAP_INVALID_CONFIG"
+/** `onlineChecks: true` was requested. Certificate revocation lookups are not implemented in v1. */
+ | "IAP_ONLINE_CHECKS_UNSUPPORTED"
+/** The runtime has no WebCrypto. Needs Deno, Node 18 or later, or a secure browser context. */
+ | "IAP_WEBCRYPTO_UNAVAILABLE"
+/** The runtime has no `fetch`. Needs Deno, Node 18 or later, or a browser. */
+ | "IAP_FETCH_UNAVAILABLE"
+/** An App Store Server API call was made without `serverApi` credentials configured. */
+ | "IAP_SERVER_API_NOT_CONFIGURED";
+/** Why the app's own Base44 setup is not usable for in-app purchases. */
+export type IapSetupErrorCode = 
+/** One of the four required entities does not exist in this app. */
+"IAP_ENTITY_MISSING"
+/** An entity exists but silently dropped a field the SDK wrote. Its schema has drifted. */
+ | "IAP_ENTITY_SCHEMA_DRIFT"
+/** The client was created without service-role credentials, so it cannot write. */
+ | "IAP_SERVICE_ROLE_REQUIRED";
+/** Why a read or write against the app's entities failed. */
+export type IapStoreErrorCode = 
+/** The write did not land. Callers must not report success to Apple or finish a transaction. */
+"IAP_WRITE_FAILED"
+/** The read did not complete. */
+ | "IAP_READ_FAILED";
+/** Why an App Store Server API call failed. */
+export type IapApiErrorCode = 
+/** Apple answered with an error status. Inspect `appleErrorCode` for which. */
+"IAP_API_ERROR"
+/** Apple rate-limited the call. `retryAfter` carries the absolute timestamp to retry after. */
+ | "IAP_API_RATE_LIMITED"
+/** The transaction id exists in neither the production nor the sandbox environment. */
+ | "IAP_API_TRANSACTION_NOT_FOUND";

package/dist/iap/errors.types.js

@@ -0,0 +1,7 @@
+/**
+ * Error codes the in-app purchase module can raise.
+ *
+ * Every code is a stable string. Generated code and support tooling branch on
+ * these, so a code is never renamed — a new situation gets a new code.
+ */
+export {};

package/dist/iap/events/emitter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Delivering events to the app's handlers.
+ *
+ * Two rules, both about not letting an app's own code break Apple's contract:
+ *
+ * 1. **A handler runs after the write, never before.** An event means the data
+ *    behind it is already stored.
+ * 2. **A handler can never change the outcome.** If one throws, the throw is
+ *    swallowed and reported; the HTTP response Apple sees is unaffected.
+ *
+ * Events are dispatched *synchronously* before the response is returned, not
+ * after it. A Base44 backend function has no way to run work once it has
+ * answered — there is no `waitUntil` — so anything deferred until after the
+ * response is simply lost when the isolate stops.
+ *
+ * @internal
+ */
+import type { IapEvent, IapEventHandler } from "./events.types.js";
+/** Reports a handler that threw. Defaults to a single console line. */
+export type IapHandlerFailureReporter = (event: IapEvent, error: unknown) => void;
+/** The event bus for one client. */
+export interface IapEmitter {
+    /** Registers a handler. Returns a function that removes it. */
+    onEvent(handler: IapEventHandler): () => void;
+    /** Delivers events to every handler, swallowing their failures. */
+    emit(events: readonly IapEvent[]): Promise<void>;
+}
+export declare function createEmitter(reportFailure?: IapHandlerFailureReporter): IapEmitter;

package/dist/iap/events/emitter.js

@@ -0,0 +1,33 @@
+function defaultReporter(event, error) {
+    // Deliberately one line and not re-thrown. A broken handler must not take
+    // the webhook down with it, and it must not be silent either.
+    console.error(`[base44 iap] an onEvent handler failed for ${event.type}:`, error instanceof Error ? error.message : error);
+}
+export function createEmitter(reportFailure = defaultReporter) {
+    const handlers = new Set();
+    return {
+        onEvent(handler) {
+            handlers.add(handler);
+            return () => {
+                handlers.delete(handler);
+            };
+        },
+        async emit(events) {
+            if (handlers.size === 0 || events.length === 0)
+                return;
+            // A snapshot, so a handler that registers another one during dispatch
+            // does not change what this round delivers.
+            const current = [...handlers];
+            for (const event of events) {
+                for (const handler of current) {
+                    try {
+                        await handler(event);
+                    }
+                    catch (error) {
+                        reportFailure(event, error);
+                    }
+                }
+            }
+        },
+    };
+}

package/dist/iap/events/events.types.d.ts

@@ -0,0 +1,124 @@
+/**
+ * What happened, in the app's own vocabulary.
+ *
+ * Apple's notification types describe *its* billing system. These describe
+ * what the app has to do about it, which is a much shorter list: something was
+ * bought, something was taken away, a subscription changed shape.
+ *
+ * Every ingestion path produces these, and `onEvent` handlers receive them
+ * after the write has landed — so a handler that sends an email or grants a
+ * bonus can trust that the data behind it is already stored.
+ */
+import type { IapEnvironment } from "../verify/verify.types.js";
+import type { IapRecordSource } from "../store/rows.types.js";
+/** The kinds of event this module emits. */
+export type IapEventType = 
+/** A one-time purchase completed. */
+"purchase.completed"
+/** Apple refunded a purchase. Take the content back. */
+ | "purchase.refunded"
+/** Apple declined a refund request. Nothing to do. */
+ | "purchase.refund_declined"
+/** A refund was reversed after a dispute. **Give the content back.** */
+ | "purchase.refund_reversed"
+/** A family member's shared access ended. */
+ | "purchase.revoked"
+/** Apple wants consumption data for a refund request, within a deadline. */
+ | "refund.consumption_requested"
+/** A subscription started, either new or after a lapse. */
+ | "subscription.started"
+/** A subscription renewed. */
+ | "subscription.renewed"
+/** The customer changed plan, effective immediately. */
+ | "subscription.plan_changed"
+/** The customer changed plan, effective at the next renewal. */
+ | "subscription.plan_change_scheduled"
+/** The customer undid a scheduled plan change. */
+ | "subscription.plan_change_cancelled"
+/** Automatic renewal was turned on or off. */
+ | "subscription.auto_renew_changed"
+/** A payment failed. Check `inGracePeriod` before withdrawing access. */
+ | "subscription.billing_issue"
+/** A billing grace period ended without a successful payment. */
+ | "subscription.grace_period_ended"
+/** A subscription ended. */
+ | "subscription.expired"
+/** The customer redeemed an offer. */
+ | "subscription.offer_redeemed"
+/** A price increase was announced or accepted. */
+ | "subscription.price_increase"
+/** Apple extended one subscriber's renewal date. */
+ | "subscription.renewal_extended"
+/** A mass renewal-date extension finished. */
+ | "subscription.mass_extension_result"
+/** A test notification arrived, confirming the webhook works. */
+ | "apple.test_received"
+/** A notification type this version stores but does not act on. */
+ | "apple.unhandled"
+/** A notification type Apple added after this version shipped. */
+ | "apple.unknown"
+/** A launch-time sync completed. */
+ | "sync.applied";
+/** Why a subscription started. */
+export type IapStartReason = "initial" | "resubscribe";
+/** Why a subscription renewed. */
+export type IapRenewReason = "renewal" | "billing_recovery";
+/** Why a subscription ended. */
+export type IapExpiryReason = "voluntary" | "billing" | "price_increase" | "product_unavailable" | "other";
+/**
+ * One thing that happened.
+ *
+ * The identifying fields are all optional because not every event has them: a
+ * mass-extension result concerns no single customer, and a purchase made
+ * before the customer logged in has no `appUserId` until a later sync attaches
+ * one.
+ */
+export interface IapEvent {
+    /** What happened. */
+    type: IapEventType;
+    /** The Base44 user this concerns, when it could be resolved. */
+    appUserId: string | null;
+    /** The subscription chain involved. */
+    originalTransactionId?: string;
+    /** The transaction involved. */
+    transactionId?: string;
+    /** The product involved. */
+    productId?: string;
+    /** Which App Store environment this came from. */
+    environment: IapEnvironment;
+    /** When Apple says it happened, in epoch milliseconds. */
+    occurredAt: number;
+    /** Apple's notification id, when this came from a notification. */
+    notificationUUID?: string;
+    /** Where this event came from. */
+    source: IapRecordSource;
+    /** Apple's own notification type, when there was one. */
+    notificationType?: string;
+    /** Apple's own notification subtype, when there was one. */
+    subtype?: string;
+    /** Why a subscription started. Only on `subscription.started`. */
+    startReason?: IapStartReason;
+    /** Why a subscription renewed. Only on `subscription.renewed`. */
+    renewReason?: IapRenewReason;
+    /** Why a subscription ended. Only on `subscription.expired`. */
+    expiryReason?: IapExpiryReason;
+    /** Whether automatic renewal is now on. Only on `subscription.auto_renew_changed`. */
+    autoRenewEnabled?: boolean;
+    /**
+     * Whether a billing grace period is running.
+     *
+     * Only on `subscription.billing_issue`. When true, Apple's requirement is to
+     * **keep providing full service** — the customer has not lapsed yet.
+     */
+    inGracePeriod?: boolean;
+    /** Where a price increase stands. Only on `subscription.price_increase`. */
+    priceIncreaseConsent?: "pending" | "accepted";
+    /** When Apple stops accepting consumption data. Only on `refund.consumption_requested`. */
+    deadlineAt?: number;
+    /** How many entitlements a sync disagreed with the server about. Only on `sync.applied`. */
+    mismatches?: number;
+    /** The decoded payload behind this event, for anything the fields above omit. */
+    payload?: unknown;
+}
+/** A function called after an event's data has been stored. */
+export type IapEventHandler = (event: IapEvent) => void | Promise<void>;

package/dist/iap/events/events.types.js

@@ -0,0 +1 @@
+export {};