@billdog.io/react-native 1.0.0-beta.2

package/dist/AdvancedPaywallCache.js

@@ -0,0 +1,344 @@
+"use strict";
+/**
+ * Phase 4: Advanced Caching Features for React Native
+ * - Cache compression (reduce storage by 60%)
+ * - Multi-level caching (memory + disk)
+ * - Intelligent prefetching
+ * - Analytics tracking
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdvancedPaywallCache = exports.DEFAULT_ADVANCED_CONFIG = void 0;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const react_native_fs_1 = __importDefault(require("react-native-fs"));
+const pako_1 = require("pako");
+exports.DEFAULT_ADVANCED_CONFIG = {
+    enabled: true,
+    maxCacheAge: 604800000, // 7 days
+    compressionEnabled: true,
+    memoryCache: true,
+    maxMemoryEntries: 20,
+    intelligentPrefetch: true,
+    analyticsEnabled: true,
+};
+class AdvancedPaywallCache {
+    constructor(config = {}) {
+        this.memoryCache = new Map();
+        this.accessPatterns = new Map();
+        this.analytics = {
+            hits: 0,
+            misses: 0,
+            memoryHits: 0,
+            diskHits: 0,
+            compressionSavings: 0,
+            averageRetrievalTime: 0,
+            prefetchSuccessRate: 0,
+        };
+        this.config = { ...exports.DEFAULT_ADVANCED_CONFIG, ...config };
+        this.cacheDir = `${react_native_fs_1.default.CachesDirectoryPath}/billdog_paywalls_advanced`;
+        react_native_fs_1.default.mkdir(this.cacheDir).catch(() => {
+            // Directory might already exist
+        });
+        this.loadAnalytics();
+        this.loadAccessPatterns();
+    }
+    // MARK: - Compression
+    compressData(data) {
+        if (!this.config.compressionEnabled) {
+            return { compressed: data, originalSize: data.length, compressedSize: data.length };
+        }
+        const originalSize = Buffer.from(data).length;
+        try {
+            const compressed = (0, pako_1.deflate)(data);
+            const compressedStr = Buffer.from(compressed).toString('base64');
+            const compressedSize = compressedStr.length;
+            const savings = originalSize - compressedSize;
+            this.analytics.compressionSavings += savings;
+            const savingsPercent = Math.round((1 - compressedSize / originalSize) * 100);
+            console.log(`[AdvancedCache] Compressed ${originalSize}B → ${compressedSize}B (${savingsPercent}% savings)`);
+            return { compressed: compressedStr, originalSize, compressedSize };
+        }
+        catch (error) {
+            console.error('[AdvancedCache] Compression failed:', error);
+            return { compressed: data, originalSize, compressedSize: originalSize };
+        }
+    }
+    decompressData(compressed) {
+        if (!this.config.compressionEnabled)
+            return compressed;
+        try {
+            const buffer = Buffer.from(compressed, 'base64');
+            const decompressed = (0, pako_1.inflate)(buffer, { to: 'string' });
+            return decompressed;
+        }
+        catch (error) {
+            console.error('[AdvancedCache] Decompression failed:', error);
+            return compressed;
+        }
+    }
+    // MARK: - Multi-Level Caching
+    async get(identifier) {
+        if (!this.config.enabled)
+            return null;
+        const startTime = Date.now();
+        // Level 1: Memory cache
+        if (this.config.memoryCache && this.memoryCache.has(identifier)) {
+            const cached = this.memoryCache.get(identifier);
+            if (Date.now() <= cached.expiresAt) {
+                this.analytics.hits++;
+                this.analytics.memoryHits++;
+                this.trackAccess(identifier);
+                this.updateAverageRetrievalTime(Date.now() - startTime);
+                console.log(`[AdvancedCache] MEMORY HIT: ${identifier} (${Date.now() - startTime}ms)`);
+                return cached;
+            }
+            else {
+                this.memoryCache.delete(identifier);
+            }
+        }
+        // Level 2: Disk cache
+        const diskCached = await this.getDiskCached(identifier);
+        if (diskCached) {
+            this.analytics.hits++;
+            this.analytics.diskHits++;
+            this.trackAccess(identifier);
+            // Add to memory cache
+            if (this.config.memoryCache) {
+                this.addToMemoryCache(identifier, diskCached);
+            }
+            this.updateAverageRetrievalTime(Date.now() - startTime);
+            console.log(`[AdvancedCache] DISK HIT: ${identifier} (${Date.now() - startTime}ms)`);
+            // Intelligent prefetch
+            if (this.config.intelligentPrefetch) {
+                this.schedulePrefetch(identifier);
+            }
+            return diskCached;
+        }
+        this.analytics.misses++;
+        console.log(`[AdvancedCache] MISS: ${identifier}`);
+        return null;
+    }
+    async getDiskCached(identifier) {
+        try {
+            const key = `paywall:${identifier}`;
+            const cachedJson = await async_storage_1.default.getItem(key);
+            if (!cachedJson)
+                return null;
+            const isCompressed = (await async_storage_1.default.getItem(`${key}:compressed`)) === 'true';
+            const dataToUse = isCompressed ? this.decompressData(cachedJson) : cachedJson;
+            const cached = JSON.parse(dataToUse);
+            // Check expiration
+            if (Date.now() > cached.expiresAt) {
+                await this.delete(identifier);
+                return null;
+            }
+            return cached;
+        }
+        catch (error) {
+            console.error(`[AdvancedCache] ERROR reading disk cache:`, error);
+            return null;
+        }
+    }
+    async set(identifier, paywall) {
+        if (!this.config.enabled)
+            return;
+        // Add to memory cache (uncompressed)
+        if (this.config.memoryCache) {
+            this.addToMemoryCache(identifier, paywall);
+        }
+        // Compress and save to disk
+        try {
+            const jsonString = JSON.stringify(paywall);
+            if (this.config.compressionEnabled) {
+                const { compressed, originalSize, compressedSize } = this.compressData(jsonString);
+                const key = `paywall:${identifier}`;
+                await async_storage_1.default.multiSet([
+                    [key, compressed],
+                    [`${key}:compressed`, 'true'],
+                    [`${key}:originalSize`, originalSize.toString()],
+                    [`${key}:compressedSize`, compressedSize.toString()],
+                ]);
+                console.log(`[AdvancedCache] CACHED: ${identifier} (compressed)`);
+            }
+            else {
+                await async_storage_1.default.setItem(`paywall:${identifier}`, jsonString);
+                console.log(`[AdvancedCache] CACHED: ${identifier}`);
+            }
+            this.trackAccess(identifier);
+            this.saveAnalytics();
+        }
+        catch (error) {
+            console.error(`[AdvancedCache] ERROR writing cache:`, error);
+        }
+    }
+    addToMemoryCache(identifier, data) {
+        // LRU eviction
+        if (this.memoryCache.size >= this.config.maxMemoryEntries) {
+            const oldestKey = this.findLeastRecentlyUsed();
+            if (oldestKey) {
+                this.memoryCache.delete(oldestKey);
+                console.log(`[AdvancedCache] Memory evicted: ${oldestKey}`);
+            }
+        }
+        this.memoryCache.set(identifier, data);
+    }
+    findLeastRecentlyUsed() {
+        let oldestKey = null;
+        let oldestTime = Date.now();
+        this.accessPatterns.forEach((pattern, key) => {
+            if (pattern.lastAccessed < oldestTime) {
+                oldestTime = pattern.lastAccessed;
+                oldestKey = key;
+            }
+        });
+        return oldestKey;
+    }
+    // MARK: - Intelligent Prefetching
+    trackAccess(identifier) {
+        const pattern = this.accessPatterns.get(identifier) || {
+            identifier,
+            lastAccessed: 0,
+            accessCount: 0,
+            relatedPaywalls: [],
+        };
+        pattern.lastAccessed = Date.now();
+        pattern.accessCount++;
+        this.accessPatterns.set(identifier, pattern);
+        // Save periodically
+        if (pattern.accessCount % 10 === 0) {
+            this.saveAccessPatterns();
+        }
+    }
+    async schedulePrefetch(identifier) {
+        if (!this.config.intelligentPrefetch)
+            return;
+        const pattern = this.accessPatterns.get(identifier);
+        if (!pattern || pattern.relatedPaywalls.length === 0)
+            return;
+        // Prefetch top 2 related paywalls
+        const toPrefetch = pattern.relatedPaywalls.slice(0, 2);
+        for (const relatedId of toPrefetch) {
+            if (!this.memoryCache.has(relatedId)) {
+                console.log(`[AdvancedCache] Prefetching: ${relatedId}`);
+                // Prefetch would trigger actual fetch here
+            }
+        }
+    }
+    learnRelationship(fromId, toId) {
+        const pattern = this.accessPatterns.get(fromId);
+        if (pattern) {
+            if (!pattern.relatedPaywalls.includes(toId)) {
+                pattern.relatedPaywalls.push(toId);
+                // Keep only top 5
+                if (pattern.relatedPaywalls.length > 5) {
+                    pattern.relatedPaywalls.shift();
+                }
+                this.saveAccessPatterns();
+            }
+        }
+    }
+    // MARK: - Analytics
+    updateAverageRetrievalTime(time) {
+        const totalRequests = this.analytics.hits + this.analytics.misses;
+        this.analytics.averageRetrievalTime =
+            (this.analytics.averageRetrievalTime * (totalRequests - 1) + time) / totalRequests;
+    }
+    async saveAnalytics() {
+        try {
+            await async_storage_1.default.setItem('billdog:cache:analytics', JSON.stringify(this.analytics));
+        }
+        catch (error) {
+            console.error('[AdvancedCache] Failed to save analytics:', error);
+        }
+    }
+    async loadAnalytics() {
+        try {
+            const stored = await async_storage_1.default.getItem('billdog:cache:analytics');
+            if (stored) {
+                this.analytics = JSON.parse(stored);
+            }
+        }
+        catch (error) {
+            console.error('[AdvancedCache] Failed to load analytics:', error);
+        }
+    }
+    getAnalytics() {
+        const total = this.analytics.hits + this.analytics.misses;
+        const hitRate = total > 0 ? (this.analytics.hits / total) * 100 : 0;
+        const memoryHitRate = this.analytics.hits > 0 ? (this.analytics.memoryHits / this.analytics.hits) * 100 : 0;
+        return {
+            ...this.analytics,
+            hitRate: Math.round(hitRate * 100) / 100,
+            memoryHitRate: Math.round(memoryHitRate * 100) / 100,
+            memorySize: this.memoryCache.size,
+        };
+    }
+    resetAnalytics() {
+        this.analytics = {
+            hits: 0,
+            misses: 0,
+            memoryHits: 0,
+            diskHits: 0,
+            compressionSavings: 0,
+            averageRetrievalTime: 0,
+            prefetchSuccessRate: 0,
+        };
+        this.saveAnalytics();
+    }
+    // MARK: - Persistence
+    async saveAccessPatterns() {
+        try {
+            const patternsObj = Object.fromEntries(this.accessPatterns);
+            await async_storage_1.default.setItem('billdog:cache:patterns', JSON.stringify(patternsObj));
+        }
+        catch (error) {
+            console.error('[AdvancedCache] Failed to save patterns:', error);
+        }
+    }
+    async loadAccessPatterns() {
+        try {
+            const stored = await async_storage_1.default.getItem('billdog:cache:patterns');
+            if (stored) {
+                const patternsObj = JSON.parse(stored);
+                this.accessPatterns = new Map(Object.entries(patternsObj));
+            }
+        }
+        catch (error) {
+            console.error('[AdvancedCache] Failed to load patterns:', error);
+        }
+    }
+    // MARK: - Cleanup
+    async delete(identifier) {
+        this.memoryCache.delete(identifier);
+        const key = `paywall:${identifier}`;
+        await async_storage_1.default.multiRemove([key, `${key}:compressed`, `${key}:originalSize`, `${key}:compressedSize`]);
+        console.log(`[AdvancedCache] DELETED: ${identifier}`);
+    }
+    async clearAll() {
+        this.memoryCache.clear();
+        this.accessPatterns.clear();
+        // Clear AsyncStorage
+        const keys = await async_storage_1.default.getAllKeys();
+        const paywallKeys = keys.filter((key) => key.startsWith('paywall:') || key.includes(':cache:'));
+        await async_storage_1.default.multiRemove(paywallKeys);
+        console.log('[AdvancedCache] All caches cleared (memory + disk)');
+    }
+    async getStats() {
+        try {
+            const keys = await async_storage_1.default.getAllKeys();
+            const paywallCount = keys.filter((key) => key.startsWith('paywall:') && !key.includes(':')).length;
+            return {
+                paywallCount,
+                memoryCount: this.memoryCache.size,
+                compressionSavings: this.analytics.compressionSavings,
+            };
+        }
+        catch (error) {
+            console.error('[AdvancedCache] Error getting stats:', error);
+            return { paywallCount: 0, memoryCount: 0, compressionSavings: 0 };
+        }
+    }
+}
+exports.AdvancedPaywallCache = AdvancedPaywallCache;

package/dist/BillDog.d.ts

@@ -0,0 +1,255 @@
+/**
+ * BillDog — top-level RN facade.
+ *
+ * Spec:     PUR-063, PUR-064, PUR-080..085, PUR-121, PUR-122, PUR-140..146,
+ *           PUR-224, PUR-350, PUR-360, PUR-362, PUR-363, PUR-364
+ *           (.lovable/purchase-conformance-spec.md)
+ * Standard: mem://architecture/react-native/sdk-unified-standard
+ *           mem://architecture/customer-info-cache-standard
+ *           mem://architecture/entitlements-authoritative-standard
+ *           mem://architecture/purchase-conformance-standard
+ *
+ * Slice J (PUR-364) propagates the v1.4 purchase parity surface to the RN
+ * bridge with iOS/Android wire parity:
+ *  - `purchase(params)` — typed PurchaseParams, returns canonical PurchaseResult
+ *  - `purchase(custom)` — Superwall-style non-StoreKit products via host controller
+ *  - `setPurchaseController(...)` — JS-side controller for EXTERNAL/CUSTOM flows
+ *  - `setProxyURL` / `getProxyURL` — self-hosted proxy
+ *  - `canMakePayments`, `presentCodeRedemptionSheet`,
+ *    `checkTrialOrIntroDiscountEligibility`, `onStorefrontChange`
+ *  - 14-provider attribution matrix + `collectDeviceIdentifiers`
+ *
+ * Every method gracefully falls back when `NativeModules.BillDog` is null so
+ * consumer apps compile against the contract before the native bridge is wired
+ * in their host project. The facade NEVER throws across the public boundary —
+ * store/network errors are surfaced as typed result unions.
+ */
+import type { RestoreResult } from './models/RestoreResult';
+import type { CacheFetchPolicy } from './models/CacheFetchPolicy';
+import { type CustomerInfo } from './models/CustomerInfo';
+import type { EntitlementInfo } from './models/EntitlementInfo';
+import type { PurchaseParams } from './models/PurchaseParams';
+import { PurchaseParams as PurchaseParamsNS } from './models/PurchaseParams';
+import type { PurchaseResult } from './models/PurchaseResult';
+import type { CustomProduct } from './models/CustomProduct';
+import type { PlacementResult, PresentationResult, PaywallPresentationHandler } from './models/Placement';
+import type { BillDogDelegate } from './models/Delegate';
+/**
+ * PUR-142/224: multi-subscriber CustomerInfo emitter with replay-1 semantics.
+ * New subscribers immediately receive the most recent cached value (if any).
+ */
+type CustomerInfoListener = (info: CustomerInfo) => void;
+declare class CustomerInfoEmitter {
+    private listeners;
+    private lastValue;
+    addListener(fn: CustomerInfoListener): {
+        remove: () => void;
+    };
+    emit(info: CustomerInfo): void;
+    get latest(): CustomerInfo | null;
+}
+/**
+ * PUR-364: Storefront country observer (iOS-only on the producer side; the
+ * RN bridge surfaces a no-op on Android until Play exposes a country API).
+ */
+type StorefrontListener = (storefront: {
+    countryCode: string;
+}) => void;
+/**
+ * PUR-364: JS-side PurchaseController contract — mirrors iOS/Android.
+ * Implementations MUST map user cancellation to `{type:'cancelled'}` and
+ * Ask-to-Buy / Android PENDING to `{type:'pending'}` — never `failed`.
+ */
+export interface PurchaseController {
+    purchase(productId: string): Promise<PurchaseResult>;
+    restorePurchases(): Promise<RestoreResult>;
+}
+/** SDK version constant — Android parity (BillDog.kt:51). */
+export declare const SDK_VERSION = "1.0.0-beta.2";
+export declare const BillDog: {
+    /** SDK version constant — re-exposed on the singleton for ergonomic access. */
+    SDK_VERSION: string;
+    /**
+     * Purchase a product with typed `PurchaseParams`. Returns canonical
+     * `PurchaseResult` — NEVER throws across the public boundary.
+     *
+     * If a host `PurchaseController` is registered (see `setPurchaseController`),
+     * the controller drives the transaction and the receipt is stamped
+     * `source = EXTERNAL`. Otherwise the bundled native controller is used
+     * (`source = INTERNAL`).
+     */
+    purchase(params: PurchaseParams): Promise<PurchaseResult>;
+    /**
+     * PUR-363: Purchase a Superwall-style non-StoreKit / non-Play product.
+     * Routing is ONLY through a host-provided PurchaseController.
+     */
+    purchaseCustom(product: CustomProduct): Promise<PurchaseResult>;
+    /** Get the currently-registered host PurchaseController, or null. */
+    getPurchaseController(): PurchaseController | null;
+    /** Flush pending analytics events to the backend. */
+    flushAnalytics(): Promise<void>;
+    /** PUR-364: Register a host PurchaseController. Pass `null` to detach. */
+    setPurchaseController(controller: PurchaseController | null): void;
+    /**
+     * Restore previous purchases (PUR-080).
+     *
+     *  - `{type:'restored', items: []}`         — nothing to restore
+     *  - `{type:'restored', items: [...]}`      — items resurfaced
+     *  - `{type:'failed', error: BillDogError}` — global failure
+     */
+    restore(): Promise<RestoreResult>;
+    getCustomerInfo(policy?: CacheFetchPolicy): Promise<CustomerInfo | null>;
+    customerInfoEmitter: CustomerInfoEmitter;
+    /**
+     * PUR-121: resolve entitlements unlocked by a [productId] from the local
+     * `productEntitlementMapping`. Used for instant gating.
+     */
+    entitlementsForProduct(productId: string): EntitlementInfo[];
+    /** PUR-201: Can the device transact at all? (parental controls, MDM) */
+    canMakePayments(): Promise<boolean>;
+    /** PUR-330: Present the App Store promo code redemption sheet (iOS-only). */
+    presentCodeRedemptionSheet(): Promise<void>;
+    /**
+     * PUR-037: Check trial / intro-discount eligibility for an array of product
+     * ids. Returns a map of `productId` -> `'eligible' | 'ineligible' | 'unknown'`.
+     */
+    checkTrialOrIntroDiscountEligibility(productIds: string[]): Promise<Record<string, "eligible" | "ineligible" | "unknown">>;
+    /** PUR-202: Subscribe to storefront country changes (iOS-only producer). */
+    onStorefrontChange(listener: StorefrontListener): {
+        remove: () => void;
+    };
+    setProxyURL(url: string | null): void;
+    setConsentRequired(required: boolean): void;
+    setConsent(purpose: "analytics" | "replay" | "messaging" | "survey", granted: boolean): void;
+    setConsentGiven(given: boolean): void;
+    consentHeaderValue(): Promise<string | null>;
+    getProxyURL(): string | null;
+    /**
+     * Set one or more attribution ids at once. Keys are the provider attribution
+     * keys (e.g. `mixpanelDistinctId`, `cleverTapId`, `iterableId`). Prefer the
+     * named convenience setters below unless batching.
+     */
+    setAttribution(data: Record<string, string>): void;
+    setCleverTapID: (id: string | null) => void;
+    setMixpanelDistinctID: (id: string | null) => void;
+    setOnesignalID: (id: string | null) => void;
+    setFBAnonymousID: (id: string | null) => void;
+    setAirshipChannelID: (id: string | null) => void;
+    setMoEngageAnonymousID: (id: string | null) => void;
+    setMparticleID: (id: string | null) => void;
+    setKochavaDeviceID: (id: string | null) => void;
+    setTenjinAnalyticsInstallationID: (id: string | null) => void;
+    setIterableUserID: (id: string | null) => void;
+    setSegmentAnonymousID: (id: string | null) => void;
+    setAdjustId: (id: string | null) => void;
+    setAppsflyerId: (id: string | null) => void;
+    setFirebaseAppInstanceId: (id: string | null) => void;
+    /** Collect IDFA / GAID after consent has been granted. */
+    collectDeviceIdentifiers(): void;
+    /**
+     * Log in an app user. Persists the user id, propagates to the native bridge
+     * (if wired) and the analytics module. Throws on blank ids — mirrors KMP/Unity.
+     */
+    logIn(appUserId: string): Promise<void>;
+    /** Log out the current user and return to anonymous state. */
+    logOut(): Promise<void>;
+    /**
+     * Identify a user with optional attributes. Behaves as `logIn` plus an
+     * analytics super-properties update for the supplied attributes.
+     */
+    identify(userId: string, attributes?: Record<string, any>): Promise<void>;
+    /** True when no app user is currently logged in. */
+    isAnonymous(): boolean;
+    /** Returns the currently logged-in app user id, or null when anonymous. */
+    getAppUserId(): string | null;
+    /**
+     * Mirrors Android `BillDog.isConfigured()` (BillDog.kt:325). Delegates to
+     * the configuration singleton so the apiKey-presence check lives in one place.
+     */
+    isConfigured(): boolean;
+    /**
+     * Cross-SDK parity stub matching KMP / Unity / Android. Toggles a local
+     * flag and forwards to the native bridge if wired; otherwise a documented
+     * no-op (sandbox is primarily controlled via API key prefix).
+     */
+    setSandboxMode(enabled: boolean): void;
+    /**
+     * Register a placement and run the canonical placement flow: fetch config →
+     * check entitlement → present paywall if needed. Returns a `PlacementResult`
+     * describing the outcome. Optional `handler` receives lifecycle callbacks
+     * mirroring Android's `PaywallPresentationHandler`.
+     *
+     * Returns `{ type: 'entitled' }` immediately if the user already holds the
+     * placement's required entitlement (no paywall shown). Returns
+     * `{ type: 'error', message }` on any failure — never throws across the
+     * public boundary.
+     */
+    register(placementId: string, params?: Record<string, unknown>, handler?: PaywallPresentationHandler): Promise<PlacementResult>;
+    /**
+     * Synchronous probe — does the current user have access to a placement?
+     * Returns `true` when the placement is unregistered or has no required
+     * entitlement (safe default matching Android's behaviour).
+     */
+    hasAccessForPlacement(placementId: string): boolean;
+    /** Open the IAM inbox / present a single message. */
+    showInAppMessages(placementId?: string): Promise<void>;
+    /** Route a deep link through the SDK. Returns true when handled. */
+    handleDeepLink(uri: string): Promise<boolean>;
+    getSelectedProductIndex(componentId: string): number | null;
+    setSelectedProductIndex(componentId: string, index: number): void;
+    /** Apply runtime theme overrides. Map of token name → value. */
+    updateTheme(overrides: Record<string, string>): void;
+    /** Set the SDK-wide interface style. Pass `null` to follow system. */
+    setInterfaceStyle(style: "light" | "dark" | null): void;
+    /**
+     * Open the platform-native subscription management UI. iOS routes to
+     * the App Store; Android routes to Play Store; web throws since no
+     * platform UI is available.
+     */
+    showManageSubscriptions(subscriptionId?: string): Promise<void>;
+    /** Clear all SDK caches (paywall configs, customer info, products). */
+    clearCache(): Promise<void>;
+    /** Invalidate the cached customer info — next read triggers a refetch. */
+    invalidateCustomerInfoCache(): Promise<void>;
+    /** Set typed attributes on the current user (targeting + analytics). */
+    setUserAttributes(attributes: Record<string, unknown>): Promise<void>;
+    /** Get the current user attributes (snapshot). */
+    getUserAttributes(): Promise<Record<string, unknown>>;
+    /** Notify BillDog that an externally-driven purchase has started. */
+    observePurchaseStart(productId: string): void;
+    /** Notify BillDog that an externally-driven purchase succeeded. */
+    observePurchaseResult(productId: string, orderId?: string): void;
+    /** Notify BillDog that an externally-driven purchase failed. */
+    observePurchaseError(productId: string, error: string): void;
+    /**
+     * Set the active delegate. Pass `null` to detach. All delegate callbacks
+     * are optional; the SDK fires the ones that are defined.
+     */
+    setDelegate(delegate: BillDogDelegate | null): void;
+    /** Internal — emit a typed lifecycle event to the delegate (if any). */
+    _emitDelegate<K extends keyof BillDogDelegate>(event: K, ...args: Parameters<NonNullable<BillDogDelegate[K]>>): void;
+    /**
+     * Evaluate what would happen if `register(placementId)` were called, without
+     * presenting a paywall. Returns one of `paywall`, `userSubscribed`,
+     * `noPaywall`, `holdout`, or `error`.
+     */
+    getPresentationResult(placementId: string): Promise<PresentationResult>;
+    /**
+     * Execute a server-side paywall tap action (Route B).
+     * Delegates to native SDK bridge `executeAction` if present; falls back to direct
+     * JavaScript fetch request to `execute-paywall-action` Edge Function if native is absent.
+     */
+    executeAction(paywallId: string | null, componentId: string, actionType: string, idempotencyKey?: string | null, metadata?: Record<string, any>): Promise<any>;
+};
+export { PurchaseParamsNS as PurchaseParams };
+export type { RestoreResult } from './models/RestoreResult';
+export type { RestoredItem, RestoreItemStatus } from './models/RestoredItem';
+export type { BillDogError } from './models/BillDogError';
+export type { CacheFetchPolicy } from './models/CacheFetchPolicy';
+export type { CustomerInfo } from './models/CustomerInfo';
+export type { EntitlementInfo, EntitlementState } from './models/EntitlementInfo';
+export type { PurchaseParams as PurchaseParamsType, GoogleReplacementMode } from './models/PurchaseParams';
+export type { PurchaseResult } from './models/PurchaseResult';
+export type { CustomProduct } from './models/CustomProduct';
+export type { PlacementResult, PresentationResult, PaywallLoadingState, SkipReason, PostPurchaseBehavior, PaywallPresentationHandler, } from './models/Placement';
+export type { BillDogDelegate } from './models/Delegate';