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

package/dist/VariableResolver.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Client-side variable resolver for React Native
+ * Resolves ${variable} and {{variable}} placeholders at runtime
+ * Supports localization integration for localized variables
+ */
+import { LocalizationResolver } from './LocalizationResolver';
+import { PaywallConfiguration, PaywallComponent } from './types';
+import { PackageInput, TrialEligibilityInput } from './ProductVariableProvider';
+export interface DeviceInfo {
+    osName?: string;
+    osVersion?: string;
+    platform?: string;
+    deviceModel?: string;
+    screenWidth?: number;
+    screenHeight?: number;
+    locale?: string;
+    timezone?: string;
+    interfaceStyle?: 'light' | 'dark' | 'unspecified';
+    batteryLevel?: number;
+    isLowPowerMode?: boolean;
+    networkType?: string;
+    carrierName?: string;
+}
+export declare class VariableResolver {
+    private allVariables;
+    private localizationResolver?;
+    private variableLocalizations?;
+    private currentLocale?;
+    constructor(configVariables?: Record<string, string> | null, runtimeVariables?: Record<string, any>, localizationResolver?: LocalizationResolver, variableLocalizations?: Record<string, Record<string, string>>, currentLocale?: string);
+    /**
+     * Resolve a single string with variables
+     */
+    resolve(text?: string | null): string;
+    /**
+     * Resolve a variable path to its raw (un-stringified) value.
+     * Flat-key-first (grammar §4): a literal key matching the whole path wins.
+     * Returns undefined when unresolved.
+     */
+    private resolveRawValue;
+    /**
+     * Resolve nested variable paths like "offering.monthly"
+     */
+    private resolveVariablePath;
+    /**
+     * Resolve all text properties in a component
+     * Applies localization for LOCALIZABLE_PROPERTIES (matching Android/iOS parity)
+     */
+    resolveComponent(component: PaywallComponent): PaywallComponent;
+    /**
+     * Resolve all components in a configuration
+     */
+    resolveConfiguration(config: PaywallConfiguration): PaywallConfiguration;
+    /**
+     * Build device variable map from DeviceInfo — single source of truth.
+     * Used by withDeviceInfo(), withFullContext(), withProducts().
+     * Maps RN DeviceInfo field names to canonical SDK key names.
+     */
+    static buildDeviceVariables(deviceInfo: DeviceInfo): Record<string, any>;
+    /**
+     * Create resolver with offering variables injected
+     */
+    static withOfferings(config: PaywallConfiguration, offerings: Record<string, string>): VariableResolver;
+    /**
+     * Create resolver with device info variables
+     * Maps device info to namespaced variables (device.*)
+     */
+    static withDeviceInfo(config: PaywallConfiguration, deviceInfo: DeviceInfo): VariableResolver;
+    /**
+     * Create resolver with localization support
+     */
+    static withLocalization(config: PaywallConfiguration, locale?: string): VariableResolver;
+    /**
+     * Create resolver with full context (offerings, device info, localization)
+     */
+    static withFullContext(config: PaywallConfiguration, offerings: Record<string, string>, deviceInfo: DeviceInfo): VariableResolver;
+    /**
+     * Create resolver with user eligibility variables
+     * Enables {{user.isEligibleForIntro}}, {{user.hasUsedTrial}}, etc.
+     */
+    static withEligibility(config: PaywallConfiguration, isEligibleForIntro?: boolean, hasUsedTrial?: boolean, isEligibleForPromo?: boolean): VariableResolver;
+    /**
+     * Create resolver with product/package variables
+     * Enables {{product.price}}, {{selectedProduct.*}}, {{products.N.*}},
+     * {{primary.*}}, {{monthly.*}}, etc. (40+ variable keys per package)
+     *
+     * Delegates to ProductVariableProvider for full parity with Android.
+     */
+    static withProducts(config: PaywallConfiguration, packages: PackageInput[], selectedIndex?: number, trialEligibility?: Record<string, TrialEligibilityInput>, deviceInfo?: DeviceInfo): VariableResolver;
+    /**
+     * Create resolver with an Offering's packages
+     * Convenience wrapper around withProducts
+     */
+    static withOffering(config: PaywallConfiguration, offering: {
+        packages: PackageInput[];
+    }, selectedIndex?: number, trialEligibility?: Record<string, TrialEligibilityInput>, deviceInfo?: DeviceInfo): VariableResolver;
+    /**
+     * Build the FULL render-time variable bag (device + product/offer/user) — the
+     * React-Native analog of iOS/Android `VariableResolver.withOffering(...).variables`.
+     * Fed to `processFullComponent` so Dynamic Values conditions on
+     * `products.*` / `selectedProduct.*` / `offer.*` / `user.*` actually resolve on
+     * RN (previously the render bag was device + `config.variables` only, so every
+     * product/user DV condition silently rendered `default`).
+     *
+     * `selectedIndex` is 0 for now — parity with the native Phase-2 render pass,
+     * which is not yet selection-reactive (Phase 2b). `appUserId`/`customerInfo` are
+     * passed in by the caller (`BillDog.getAppUserId()` + `customerInfoEmitter.latest`,
+     * both sync) to avoid a VariableResolver→BillDog import cycle.
+     */
+    static buildRenderVariables(config: PaywallConfiguration, deviceInfo: DeviceInfo, opts?: {
+        selectedIndex?: number;
+        appUserId?: string | null;
+        customerInfo?: {
+            entitlements?: Array<{
+                identifier: string;
+                isActive: boolean;
+            }>;
+            activeSubscriptions?: string[];
+        } | null;
+    }): Record<string, any>;
+}

package/dist/VariableResolver.js

@@ -0,0 +1,379 @@
+"use strict";
+/**
+ * Client-side variable resolver for React Native
+ * Resolves ${variable} and {{variable}} placeholders at runtime
+ * Supports localization integration for localized variables
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableResolver = void 0;
+const LocalizationResolver_1 = require("./LocalizationResolver");
+const xFlowTags_1 = require("./xFlowTags");
+const filters_1 = require("./filters");
+const ProductVariableProvider_1 = require("./ProductVariableProvider");
+const murmur_1 = require("./murmur");
+/**
+ * Get device locale with safe fallback for React Native
+ */
+function deviceLocale() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().locale;
+    }
+    catch {
+        return 'en';
+    }
+}
+/** Properties eligible for localization (matches Android/iOS LOCALIZABLE_PROPERTIES) */
+const LOCALIZABLE_PROPERTIES = new Set([
+    'text', 'title', 'subtitle', 'label', 'placeholder',
+    'buttonText', 'ctaText', 'description', 'content',
+    'headerText', 'footerText', 'disclaimer',
+]);
+class VariableResolver {
+    constructor(configVariables, runtimeVariables = {}, localizationResolver, variableLocalizations, currentLocale) {
+        this.allVariables = {
+            ...configVariables,
+            ...runtimeVariables,
+        };
+        this.localizationResolver = localizationResolver;
+        this.variableLocalizations = variableLocalizations;
+        this.currentLocale = currentLocale;
+    }
+    /**
+     * Resolve a single string with variables
+     */
+    resolve(text) {
+        if (!text)
+            return text !== null && text !== void 0 ? text : '';
+        let result = text;
+        // Local copy — xFlow assigns must not leak across resolve() calls
+        let resolveVars = { ...this.allVariables };
+        // Process xFlow {% %} tags before {{ }} interpolation
+        if (result.includes('{%')) {
+            const xFlowResult = (0, xFlowTags_1.processXFlowTags)(result, resolveVars);
+            result = xFlowResult.text;
+            // Merge assigned variables into local context only
+            resolveVars = { ...resolveVars, ...xFlowResult.variables };
+        }
+        // Resolve ${variable} syntax
+        result = result.replace(/\$\{([\w.]+)\}/g, (_, varName) => {
+            return this.resolveVariablePath(varName, resolveVars);
+        });
+        // Resolve {{ variable }} and {{ variable | filter: arg }} syntax
+        result = result.replace(/\{\{\s*([\w.]+)(?:\s*\|\s*(.+?))?\s*\}\}/g, (match, varName, filterChain) => {
+            const name = varName.trim();
+            if (!filterChain) {
+                return this.resolveVariablePath(name, resolveVars);
+            }
+            // Filter chains operate on the raw value, bypassing localization.
+            const raw = this.resolveRawValue(name, resolveVars);
+            if (raw === undefined)
+                return match;
+            let value = raw;
+            try {
+                value = (0, filters_1.applyFilterChain)(raw, filterChain.trim());
+            }
+            catch (error) {
+                console.warn('[VariableResolver] Filter chain failed:', error);
+            }
+            return value !== undefined && value !== null ? String(value) : match;
+        });
+        return result;
+    }
+    /**
+     * Resolve a variable path to its raw (un-stringified) value.
+     * Flat-key-first (grammar §4): a literal key matching the whole path wins.
+     * Returns undefined when unresolved.
+     */
+    resolveRawValue(path, from) {
+        if (path in from)
+            return from[path];
+        const parts = path.split('.');
+        let current = from[parts[0]];
+        for (let i = 1; i < parts.length; i++) {
+            if (current && typeof current === 'object') {
+                current = current[parts[i]];
+            }
+            else {
+                return undefined;
+            }
+        }
+        return current;
+    }
+    /**
+     * Resolve nested variable paths like "offering.monthly"
+     */
+    resolveVariablePath(path, from) {
+        var _a, _b;
+        const vars = from !== null && from !== void 0 ? from : this.allVariables;
+        // Priority 1: Check variableLocalizations[path][locale]
+        if (this.variableLocalizations && this.currentLocale) {
+            const localeMap = this.variableLocalizations[path];
+            if (localeMap) {
+                const localizedValue = (_b = (_a = localeMap[this.currentLocale]) !== null && _a !== void 0 ? _a : localeMap[this.currentLocale.split('-')[0]]) !== null && _b !== void 0 ? _b : localeMap[this.currentLocale.split('_')[0]];
+                if (localizedValue !== undefined) {
+                    return localizedValue;
+                }
+            }
+        }
+        // Priority 2: Direct lookup
+        if (path in vars) {
+            return String(vars[path]);
+        }
+        // Priority 3: Try nested path resolution
+        const parts = path.split('.');
+        let current = undefined;
+        for (const part of parts) {
+            if (current === undefined) {
+                current = vars[part];
+            }
+            else if (typeof current === 'object' && current !== null) {
+                current = current[part];
+            }
+            else {
+                current = undefined;
+                break;
+            }
+        }
+        if (current !== undefined) {
+            return String(current);
+        }
+        // Return empty string for unresolved variables to match the unified parity
+        // contract: iOS VariableResolver.swift:177 and Android
+        // VariableResolver.kt:147 both substitute "". A `${path}` placeholder is
+        // editor-mode behavior and must not leak into runtime — an unresolved
+        // variable would otherwise render as literal `${user.name}` on-device.
+        //
+        // This fix existed in the legacy packages/react-native resolver and was
+        // lost when the thin bridge replaced it (ba6a68d86); the conformance
+        // corpus caught the regression. Warn rather than log so unresolved
+        // variables stay visible in production, matching both native SDKs.
+        console.warn(`[VariableResolver] Variable not resolved: ${path} — substituting empty string`);
+        return '';
+    }
+    /**
+     * Resolve all text properties in a component
+     * Applies localization for LOCALIZABLE_PROPERTIES (matching Android/iOS parity)
+     */
+    resolveComponent(component) {
+        if (!component)
+            return component;
+        const resolvedComponent = { ...component };
+        // Resolve properties
+        if (component.properties) {
+            const resolvedProperties = {};
+            for (const [key, value] of Object.entries(component.properties)) {
+                if (typeof value === 'string') {
+                    const variableResolved = this.resolve(value);
+                    // Apply localization for localizable properties (matching Android/iOS)
+                    if (this.localizationResolver
+                        && LOCALIZABLE_PROPERTIES.has(key)
+                        && !this.localizationResolver.isBaseLocale()) {
+                        resolvedProperties[key] = this.localizationResolver.resolve(`${component.id}.${key}`, variableResolved);
+                    }
+                    else {
+                        resolvedProperties[key] = variableResolved;
+                    }
+                }
+                else {
+                    resolvedProperties[key] = value;
+                }
+            }
+            resolvedComponent.properties = resolvedProperties;
+        }
+        // Recursively resolve children
+        if (component.children && Array.isArray(component.children)) {
+            resolvedComponent.children = component.children.map((child) => this.resolveComponent(child));
+        }
+        return resolvedComponent;
+    }
+    /**
+     * Resolve all components in a configuration
+     */
+    resolveConfiguration(config) {
+        if (!config)
+            return config;
+        const resolvedConfig = { ...config };
+        if (config.components && Array.isArray(config.components)) {
+            resolvedConfig.components = config.components.map((comp) => this.resolveComponent(comp));
+        }
+        return resolvedConfig;
+    }
+    // ─── Device Variable Builder (single source of truth) ──────────────────────
+    /**
+     * Build device variable map from DeviceInfo — single source of truth.
+     * Used by withDeviceInfo(), withFullContext(), withProducts().
+     * Maps RN DeviceInfo field names to canonical SDK key names.
+     */
+    static buildDeviceVariables(deviceInfo) {
+        const vars = {};
+        // Flat keys for direct access (canonical names matching Android/iOS)
+        if (deviceInfo.osName)
+            vars['device.osName'] = deviceInfo.osName;
+        if (deviceInfo.osVersion)
+            vars['device.osVersion'] = deviceInfo.osVersion;
+        if (deviceInfo.platform)
+            vars['device.platform'] = deviceInfo.platform;
+        if (deviceInfo.deviceModel)
+            vars['device.deviceModel'] = deviceInfo.deviceModel;
+        if (deviceInfo.screenWidth !== undefined)
+            vars['device.screenWidth'] = deviceInfo.screenWidth;
+        if (deviceInfo.screenHeight !== undefined)
+            vars['device.screenHeight'] = deviceInfo.screenHeight;
+        if (deviceInfo.locale)
+            vars['device.locale'] = deviceInfo.locale;
+        if (deviceInfo.timezone)
+            vars['device.timezone'] = deviceInfo.timezone;
+        if (deviceInfo.interfaceStyle)
+            vars['device.interfaceStyle'] = deviceInfo.interfaceStyle;
+        if (deviceInfo.batteryLevel !== undefined)
+            vars['device.batteryLevel'] = deviceInfo.batteryLevel;
+        // Map RN field name to canonical SDK key name
+        if (deviceInfo.isLowPowerMode !== undefined)
+            vars['device.isLowPowerModeEnabled'] = deviceInfo.isLowPowerMode;
+        if (deviceInfo.networkType)
+            vars['device.radioType'] = deviceInfo.networkType;
+        if (deviceInfo.carrierName)
+            vars['device.carrierName'] = deviceInfo.carrierName;
+        // Nested object for dot-path resolution (includes screenWidth/Height)
+        vars.device = {
+            osName: deviceInfo.osName,
+            osVersion: deviceInfo.osVersion,
+            platform: deviceInfo.platform,
+            deviceModel: deviceInfo.deviceModel,
+            locale: deviceInfo.locale,
+            timezone: deviceInfo.timezone,
+            interfaceStyle: deviceInfo.interfaceStyle,
+            screenWidth: deviceInfo.screenWidth,
+            screenHeight: deviceInfo.screenHeight,
+        };
+        return vars;
+    }
+    // ─── Factory Methods ───────────────────────────────────────────────────────
+    /**
+     * Create resolver with offering variables injected
+     */
+    static withOfferings(config, offerings) {
+        return new VariableResolver(config.variables, offerings, LocalizationResolver_1.LocalizationResolver.fromConfiguration(config), config.variableLocalizations, deviceLocale());
+    }
+    /**
+     * Create resolver with device info variables
+     * Maps device info to namespaced variables (device.*)
+     */
+    static withDeviceInfo(config, deviceInfo) {
+        var _a;
+        return new VariableResolver(config.variables, VariableResolver.buildDeviceVariables(deviceInfo), LocalizationResolver_1.LocalizationResolver.fromConfiguration(config), config.variableLocalizations, (_a = deviceInfo.locale) !== null && _a !== void 0 ? _a : deviceLocale());
+    }
+    /**
+     * Create resolver with localization support
+     */
+    static withLocalization(config, locale) {
+        const locResolver = locale
+            ? LocalizationResolver_1.LocalizationResolver.withLocale(config, locale)
+            : LocalizationResolver_1.LocalizationResolver.withDeviceLocale(config);
+        return new VariableResolver(config.variables, {}, locResolver, config.variableLocalizations, locale !== null && locale !== void 0 ? locale : deviceLocale());
+    }
+    /**
+     * Create resolver with full context (offerings, device info, localization)
+     */
+    static withFullContext(config, offerings, deviceInfo) {
+        var _a;
+        const runtimeVars = {
+            ...VariableResolver.buildDeviceVariables(deviceInfo),
+            ...offerings,
+        };
+        return new VariableResolver(config.variables, runtimeVars, LocalizationResolver_1.LocalizationResolver.withDeviceLocale(config), config.variableLocalizations, (_a = deviceInfo.locale) !== null && _a !== void 0 ? _a : deviceLocale());
+    }
+    /**
+     * Create resolver with user eligibility variables
+     * Enables {{user.isEligibleForIntro}}, {{user.hasUsedTrial}}, etc.
+     */
+    static withEligibility(config, isEligibleForIntro = true, hasUsedTrial = false, isEligibleForPromo = false) {
+        const eligibilityVars = {
+            'user.isEligibleForIntro': isEligibleForIntro,
+            'user.hasUsedTrial': hasUsedTrial,
+            'user.isEligibleForPromo': isEligibleForPromo,
+            user: {
+                isEligibleForIntro,
+                hasUsedTrial,
+                isEligibleForPromo,
+            },
+        };
+        return new VariableResolver(config.variables, eligibilityVars, LocalizationResolver_1.LocalizationResolver.fromConfiguration(config), config.variableLocalizations, deviceLocale());
+    }
+    /**
+     * Create resolver with product/package variables
+     * Enables {{product.price}}, {{selectedProduct.*}}, {{products.N.*}},
+     * {{primary.*}}, {{monthly.*}}, etc. (40+ variable keys per package)
+     *
+     * Delegates to ProductVariableProvider for full parity with Android.
+     */
+    static withProducts(config, packages, selectedIndex = 0, trialEligibility, deviceInfo) {
+        var _a;
+        const provider = new ProductVariableProvider_1.ProductVariableProvider(packages, trialEligibility);
+        const productVars = {};
+        // Selected product → product.* prefix
+        Object.assign(productVars, provider.getVariablesForProduct(selectedIndex));
+        // selectedProduct.* mirror
+        Object.assign(productVars, provider.getSelectedProductVariables(selectedIndex));
+        // products.N.* indexed access
+        Object.assign(productVars, provider.getAllProductVariables());
+        productVars['packages.count'] = packages.length;
+        // Convenience aliases (primary.*, secondary.*, monthly.*, annual.*, etc.)
+        Object.assign(productVars, provider.getConvenienceVariables());
+        // Add device info if provided — use canonical buildDeviceVariables
+        if (deviceInfo) {
+            Object.assign(productVars, VariableResolver.buildDeviceVariables(deviceInfo));
+        }
+        return new VariableResolver(config.variables, productVars, LocalizationResolver_1.LocalizationResolver.fromConfiguration(config), config.variableLocalizations, (_a = deviceInfo === null || deviceInfo === void 0 ? void 0 : deviceInfo.locale) !== null && _a !== void 0 ? _a : deviceLocale());
+    }
+    /**
+     * Create resolver with an Offering's packages
+     * Convenience wrapper around withProducts
+     */
+    static withOffering(config, offering, selectedIndex = 0, trialEligibility, deviceInfo) {
+        return VariableResolver.withProducts(config, offering.packages, selectedIndex, trialEligibility, deviceInfo);
+    }
+    /**
+     * Build the FULL render-time variable bag (device + product/offer/user) — the
+     * React-Native analog of iOS/Android `VariableResolver.withOffering(...).variables`.
+     * Fed to `processFullComponent` so Dynamic Values conditions on
+     * `products.*` / `selectedProduct.*` / `offer.*` / `user.*` actually resolve on
+     * RN (previously the render bag was device + `config.variables` only, so every
+     * product/user DV condition silently rendered `default`).
+     *
+     * `selectedIndex` is 0 for now — parity with the native Phase-2 render pass,
+     * which is not yet selection-reactive (Phase 2b). `appUserId`/`customerInfo` are
+     * passed in by the caller (`BillDog.getAppUserId()` + `customerInfoEmitter.latest`,
+     * both sync) to avoid a VariableResolver→BillDog import cycle.
+     */
+    static buildRenderVariables(config, deviceInfo, opts) {
+        var _a, _b, _c, _d, _e;
+        const selectedIndex = (_a = opts === null || opts === void 0 ? void 0 : opts.selectedIndex) !== null && _a !== void 0 ? _a : 0;
+        const bag = { ...VariableResolver.buildDeviceVariables(deviceInfo) };
+        const packages = config.packages;
+        if (Array.isArray(packages) && packages.length > 0) {
+            const provider = new ProductVariableProvider_1.ProductVariableProvider(packages, config.trialEligibility);
+            Object.assign(bag, provider.getVariablesForProduct(selectedIndex)); // product.* (+ user.isEligibleForIntro/hasUsedTrial)
+            Object.assign(bag, provider.getSelectedProductVariables(selectedIndex)); // selectedProduct.*
+            Object.assign(bag, provider.getAllProductVariables()); // products.N.*
+            Object.assign(bag, provider.getConvenienceVariables()); // primary.*/secondary.*/…
+            bag['packages.count'] = packages.length;
+            bag['products.selectedIndex'] = selectedIndex;
+        }
+        // user.seed — deterministic A/B bucket (canonical murmur; parity with native).
+        if (opts === null || opts === void 0 ? void 0 : opts.appUserId)
+            bag['user.seed'] = (0, murmur_1.userSeedBucket)(opts.appUserId);
+        // user.subscription — active entitlement tier, from the SYNC-cached CustomerInfo
+        // (may be null on cold start; best-effort, same async limitation as iOS Phase 2).
+        // Sorted for cross-platform determinism with iOS/Android.
+        const customer = opts === null || opts === void 0 ? void 0 : opts.customerInfo;
+        if (customer) {
+            const active = ((_b = customer.entitlements) !== null && _b !== void 0 ? _b : []).filter((e) => e.isActive).map((e) => e.identifier).sort();
+            bag['user.subscription'] = (_c = active[0]) !== null && _c !== void 0 ? _c : '';
+            bag['user.hasActiveSubscription'] = ((_e = (_d = customer.activeSubscriptions) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0) > 0 || active.length > 0;
+            bag['user.activeEntitlements'] = active.join(',');
+        }
+        return bag;
+    }
+}
+exports.VariableResolver = VariableResolver;

package/dist/WebViewPaywall.d.ts

@@ -0,0 +1,75 @@
+/**
+ * WebViewPaywall — Optional WebView-based paywall component for the
+ * React Native SDK.
+ *
+ * The default React Native paywall path is native (`PaywallView` →
+ * `ComponentRenderer`). This component is the WebView alternative that
+ * loads the same unified renderer bundle iOS / Android / Flutter use,
+ * so paywalls visually match across all platforms at the cost of one
+ * extra `react-native-webview` dependency.
+ *
+ * Android parity reference:
+ *   - `BillDogWebViewPaywall` (Android, billdog-paywalls-webview module)
+ *   - Canonical message protocol:
+ *       packages/paywall-renderer/src/native/messageProtocol.ts
+ *   - postMessage events handled here mirror the protocol's
+ *     OutboundMessageType union: purchase / restore / close / open_url /
+ *     track / state_changed / error / ready.
+ *
+ * Architecture choice: URL-based loading (same as Flutter) rather than
+ * bundled HTML asset. The renderer is served by the `render-paywall`
+ * edge function at `https://api.billdog.io/v1/render-paywall?...`,
+ * and the paywall config is delivered to the renderer via the JS
+ * bridge function `window.loadPaywallData(...)` — same contract as
+ * the Flutter SDK uses (packages/flutter/lib/src/widgets/paywall_view.dart).
+ *
+ * Bundling the HTML as a static asset requires a metro.config.js change
+ * (`assetExts: ['html', ...]` + `metro-html-loader`). URL-based avoids
+ * that and is the simpler MVP. If first-paint latency becomes a problem,
+ * a future revision can switch to local-asset loading.
+ */
+import React from 'react';
+export interface WebViewPaywallProps {
+    /** Paywall identifier — matches the placement id used elsewhere. */
+    paywallIdentifier: string;
+    /** API key for the BillDog project. */
+    apiKey: string;
+    /** Optional current user id; forwarded to the renderer so it can
+     *  resolve per-user variants / experiments. */
+    customerId?: string;
+    /** Render the WebView inside a fullscreen modal. Default true. */
+    modal?: boolean;
+    /** Visibility (only meaningful when `modal=true`). */
+    visible?: boolean;
+    /**
+     * Explicit locale for the rendered paywall. When omitted the component
+     * resolves the effective locale via `LocalizationResolver.getEffectiveLocale()`
+     * (runtime override > device locale > "en") — matching the Android
+     * `WebViewPaywallActivity.effectiveLocale()` precedence.
+     */
+    locale?: string;
+    /** Fires when the renderer reports `ready` over the postMessage bridge. */
+    onReady?: () => void;
+    /** Fires when the consumer should initiate a purchase. The product id
+     *  comes from the renderer's `purchase` message. */
+    onPurchase?: (productIdentifier: string) => void;
+    /** Fires when the user taps Restore. */
+    onRestore?: () => void;
+    /** Fires when the user closes the paywall. */
+    onDismiss?: () => void;
+    /** Fires on `open_url` messages (e.g. terms / privacy links). */
+    onOpenUrl?: (url: string) => void;
+    /** Fires on `track` analytics events. */
+    onTrackEvent?: (eventName: string, properties?: Record<string, unknown>) => void;
+    /** Fires on any error message from the renderer. */
+    onError?: (error: Error) => void;
+    /**
+     * Optional custom action execution handler (Route B).
+     * If provided, the consumer must execute the action and return a promise
+     * resolving with the result or rejecting with an error. If omitted, the
+     * SDK automatically executes it via the server-side Edge function.
+     */
+    onExecuteAction?: (paywallId: string | null, componentId: string, actionType: string, idempotencyKey: string | null) => Promise<unknown>;
+}
+export declare const WebViewPaywall: React.FC<WebViewPaywallProps>;
+export default WebViewPaywall;