@virex-tech/paywallo-sdk 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,1141 @@
+import * as React from 'react';
+import React__default from 'react';
+
+type EntranceAnimationType = "none" | "fade" | "slide-up" | "slide-down" | "slide-left" | "slide-right" | "scale" | "bounce";
+type LoopAnimationType = "none" | "pulse" | "glow" | "float" | "shake" | "bounce";
+type InteractionAnimationType = "none" | "scale-down" | "opacity" | "highlight";
+type AnimationEasing = "ease" | "ease-in" | "ease-out" | "ease-in-out" | "spring";
+interface EntranceAnimation {
+    type: EntranceAnimationType;
+    duration?: number;
+    delay?: number;
+    easing?: AnimationEasing;
+}
+interface LoopAnimation {
+    type: LoopAnimationType;
+    duration?: number;
+    repeatCount?: number;
+}
+interface InteractionAnimation {
+    tap?: InteractionAnimationType;
+    tapDuration?: number;
+}
+interface AnimationProps {
+    entrance?: EntranceAnimation;
+    loop?: LoopAnimation;
+    interaction?: InteractionAnimation;
+}
+
+/**
+ * Shared primitive types used across all block categories.
+ */
+interface BoxSpacing {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+interface LocalizedText {
+    [languageCode: string]: string;
+}
+type TapBehaviorType = "none" | "close" | "select-product" | "set-variable" | "custom-placement" | "open-url" | "navigate" | "restore-purchases" | "purchase";
+type NavigateTarget = "next" | "previous" | "first" | "last" | number;
+interface TapBehavior {
+    type: TapBehaviorType;
+    productId?: string;
+    variableName?: string;
+    variableValue?: string;
+    url?: string;
+    openInBrowser?: boolean;
+    target?: NavigateTarget;
+    targetStepId?: string;
+    placementName?: string;
+}
+type BlockType = "page" | "stack" | "text" | "button" | "image" | "icon" | "video" | "divider" | "spacer" | "lottie" | "carousel" | "navigation" | "tabs" | "fixed-footer" | "feature-card" | "bullet-item" | "timeline-item" | "simple-link" | "comparison-table" | "countdown" | "review" | "badge" | "popup" | "progress" | "social-proof" | "testimonial" | "accolades" | "sticker" | "product-card" | "toggle-option" | "delayed-close" | "close-button" | "back-button" | "trial-toggle" | "period-picker" | "product-list" | "exit-offer" | "spin-wheel";
+
+/**
+ * Layout block props — page, stack, fixed-footer, popup.
+ */
+
+interface PaywallNode {
+    id: string;
+    type: BlockType;
+    props: unknown;
+    children: string[];
+    parentId: string | null;
+    conditions?: BlockConditions;
+    animation?: AnimationProps;
+}
+interface PaywallState {
+    nodes: Record<string, PaywallNode>;
+    rootId: string;
+}
+type ConditionOperator = "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equals" | "less_than_or_equals" | "is_empty" | "is_not_empty" | "is_true" | "is_false";
+interface Condition {
+    id: string;
+    variable: string;
+    operator: ConditionOperator;
+    value?: string | number | boolean;
+}
+interface ConditionGroup {
+    id: string;
+    logic: "and" | "or";
+    conditions: Condition[];
+}
+interface DynamicRule {
+    id: string;
+    name?: string;
+    conditionGroups: ConditionGroup[];
+    groupsLogic: "and" | "or";
+}
+interface DynamicValue<T = string> {
+    rules: DynamicValueRule<T>[];
+    defaultValue: T;
+}
+interface DynamicValueRule<T = string> {
+    id: string;
+    condition: DynamicRule;
+    value: T;
+}
+interface VisibilityCondition {
+    enabled: boolean;
+    rule?: DynamicRule;
+    showWhen: "matches" | "not_matches";
+}
+interface BlockConditions {
+    visibility?: VisibilityCondition;
+    dynamicProps?: Record<string, DynamicValue>;
+}
+
+interface ServerProductInfo {
+    storeProductId: string;
+    name: string;
+    price: number | null;
+    billingPeriod: string | null;
+    trialDays: number | null;
+}
+interface CampaignResponse {
+    campaignId: string;
+    variantKey: string;
+    paywall: {
+        id: string;
+        placement: string;
+        config: Record<string, unknown>;
+        primaryProductId?: string;
+        secondaryProductId?: string;
+        primaryProduct?: ServerProductInfo;
+        secondaryProduct?: ServerProductInfo;
+    };
+}
+interface CampaignResult {
+    presented: boolean;
+    purchased: boolean;
+    productId?: string;
+    transactionId?: string;
+    cancelled: boolean;
+    restored: boolean;
+    campaignId?: string;
+    variantKey?: string;
+    error?: Error;
+}
+interface CampaignPresentOptions {
+    placement: string;
+    context?: Record<string, unknown>;
+    onDismiss?: () => void;
+    onPurchase?: (productId: string) => void;
+    onError?: (error: Error) => void;
+}
+
+interface PaywallConfig {
+    id: string;
+    placement: string;
+    config: {
+        craftData: string;
+    } | PaywallBlockConfig;
+    content?: string | Record<string, unknown>;
+    primaryProductId?: string;
+    secondaryProductId?: string;
+}
+interface PaywallBlockConfig {
+    type: string;
+    props: Record<string, unknown>;
+    children?: PaywallBlockConfig[];
+}
+interface PaywallResult {
+    presented: boolean;
+    purchased: boolean;
+    productId?: string;
+    transactionId?: string;
+    cancelled: boolean;
+    restored: boolean;
+    error?: Error;
+}
+interface PaywallPresentOptions {
+    placement: string;
+    onDismiss?: () => void;
+    onPurchase?: (productId: string) => void;
+    onError?: (error: Error) => void;
+}
+interface EmergencyPaywallResponse {
+    enabled: boolean;
+    paywallId?: string;
+    paywall?: PaywallConfig;
+}
+
+interface Product {
+    productId: string;
+    title: string;
+    description: string;
+    price: string;
+    priceValue: number;
+    currency: string;
+    localizedPrice: string;
+    type: "subscription" | "consumable" | "non_consumable";
+    subscriptionPeriod?: string;
+    introductoryPrice?: string;
+    introductoryPriceValue?: number;
+    freeTrialPeriod?: string;
+    pricePerMonth?: string;
+    pricePerWeek?: string;
+    pricePerDay?: string;
+    savings?: string;
+    savingsPercent?: string;
+}
+interface Purchase {
+    productId: string;
+    transactionId: string;
+    transactionDate: number;
+    receipt: string;
+    platform: "ios" | "android";
+}
+interface PurchaseResult {
+    success: boolean;
+    purchase?: Purchase;
+    error?: Error;
+}
+interface ValidatePurchaseResponse {
+    success: boolean;
+    subscription: {
+        productId: string;
+        status: string;
+        expiresAt: string | null;
+    } | null;
+    error?: string;
+}
+
+type SubscriptionStatus$1 = "active" | "expired" | "in_billing_retry" | "in_grace_period" | "revoked" | "cancelled";
+type SubscriptionPlatform = "ios" | "android";
+interface Subscription {
+    productId: string;
+    status: SubscriptionStatus$1;
+    expiresAt: Date | null;
+    platform: SubscriptionPlatform;
+    autoRenewEnabled: boolean;
+    inGracePeriod: boolean;
+}
+interface SubscriptionStatusResponse$1 {
+    hasActiveSubscription: boolean;
+    subscription: Subscription | null;
+}
+interface RestoreResult {
+    success: boolean;
+    restoredProducts: string[];
+    error?: Error;
+}
+
+type Environment = "Production" | "Sandbox";
+interface ApiClientConfig {
+    appKey: string;
+    baseUrl?: string;
+    debug?: boolean;
+    environment?: Environment;
+    offlineQueueEnabled?: boolean;
+    timeout?: number;
+}
+interface PaywalloConfig {
+    appKey: string;
+    baseUrl?: string;
+    debug?: boolean;
+    environment?: Environment;
+}
+interface UserProperties {
+    [key: string]: string | number | boolean | null;
+}
+interface IdentifyOptions {
+    email?: string;
+    properties?: UserProperties;
+}
+interface TrackEventOptions {
+    properties?: UserProperties;
+    timestamp?: number;
+}
+interface FlagVariant {
+    variant: string | null;
+    payload?: Record<string, unknown>;
+}
+interface ConditionalFlagResult {
+    value: boolean;
+    flagKey: string;
+}
+interface ConditionalFlagContext {
+    platform?: string;
+    appVersion?: string;
+    country?: string;
+    distinctId?: string;
+}
+interface AffiliateCoupon {
+    code: string;
+    status: string;
+    createdAt: Date;
+}
+interface AffiliateCommission {
+    id: string;
+    referredDistinctId: string;
+    purchaseAmount: number;
+    commissionAmount: number;
+    status: "pending" | "eligible" | "ineligible" | "withdrawn";
+    createdAt: Date;
+}
+interface AffiliateBalance {
+    total: number;
+    pending: number;
+    available: number;
+    withdrawn: number;
+}
+interface WithdrawalRequest {
+    id: string;
+    amount: number;
+    status: "pending" | "approved" | "rejected" | "paid";
+    createdAt: Date;
+}
+
+interface PaywallModalProps {
+    placement: string;
+    visible: boolean;
+    onResult: (result: PaywallResult) => void;
+    paywallConfig?: {
+        id: string;
+        placement: string;
+        config: Record<string, unknown>;
+        primaryProductId?: string;
+        secondaryProductId?: string;
+    };
+    preloadedProducts?: Map<string, Product>;
+    variantKey?: string;
+    campaignId?: string;
+}
+declare function PaywallModal({ placement, visible, onResult, paywallConfig: preloadedConfig, preloadedProducts, variantKey, campaignId, }: PaywallModalProps): React__default.ReactElement | null;
+
+interface PaywallContextValue {
+    nodes: Record<string, PaywallNode>;
+    rootId: string;
+    language: string;
+    defaultLanguage: string;
+    products: Map<string, Product>;
+    selectedProductId: string | null;
+    primaryProductId: string | null;
+    secondaryProductId: string | null;
+    currentNavigationIndex: number;
+    currentTabIndex: number;
+    trialEnabled: boolean;
+    selectedPeriod: string | null;
+    isPurchasing: boolean;
+    exitOfferVisible: boolean;
+    exitOfferTriggeredByBackButton: boolean;
+    onClose: () => void;
+    onTryClose: () => void;
+    onSelectProduct: (productId: string) => void;
+    onPurchase: (productId: string) => void;
+    onRestore: () => void;
+    onNavigate: (target: "next" | "previous" | "first" | "last" | number) => void;
+    onSetTab: (index: number) => void;
+    onSetVariable: (name: string, value: string) => void;
+    onToggleTrial: (enabled: boolean) => void;
+    onSelectPeriod: (value: string) => void;
+    onOpenUrl: (url: string, inBrowser?: boolean) => void;
+    onTapBehavior: (behavior: TapBehavior) => void;
+    onShowExitOffer: () => void;
+    onDismissExitOffer: () => void;
+    onTriggerBackButton: () => void;
+}
+declare const PaywallContext: React.Context<PaywallContextValue | null>;
+declare function usePaywallContext(): PaywallContextValue;
+
+interface PreloadResult {
+    success: boolean;
+    error?: Error;
+}
+interface PaywalloContextValue {
+    config: PaywalloConfig | null;
+    isInitialized: boolean;
+    initError: Error | null;
+    distinctId: string | null;
+    subscription: Subscription | null;
+    products: Map<string, Product>;
+    isLoadingProducts: boolean;
+    presentPaywall: (placement: string) => Promise<PaywallResult>;
+    presentCampaign: (placement: string, context?: Record<string, unknown>) => Promise<CampaignResult>;
+    preloadCampaign: (placement: string, context?: Record<string, unknown>) => Promise<PreloadResult>;
+    hasActiveSubscription: () => Promise<boolean>;
+    getSubscription: () => Promise<Subscription | null>;
+    restorePurchases: () => Promise<{
+        success: boolean;
+        error?: Error;
+    }>;
+    getPaywallConfig: (placement: string) => Promise<PaywallConfig | null>;
+    refreshProducts: (productIds: string[]) => Promise<void>;
+}
+declare const PaywalloContext: React.Context<PaywalloContextValue | null>;
+
+declare class PaywalloError extends Error {
+    readonly code: string;
+    readonly domain: string;
+    constructor(domain: string, code: string, message: string);
+}
+
+declare class PaywallError extends PaywalloError {
+    constructor(code: string, message: string);
+}
+declare const PAYWALL_ERROR_CODES: {
+    readonly NOT_INITIALIZED: "PAYWALL_NOT_INITIALIZED";
+    readonly NOT_FOUND: "PAYWALL_NOT_FOUND";
+    readonly RENDER_FAILED: "PAYWALL_RENDER_FAILED";
+    readonly LOAD_FAILED: "PAYWALL_LOAD_FAILED";
+    readonly DISMISS_FAILED: "PAYWALL_DISMISS_FAILED";
+    readonly INVALID_CONFIG: "PAYWALL_INVALID_CONFIG";
+};
+
+interface RetryConfig {
+    maxRetries: number;
+    baseDelay: number;
+    maxDelay: number;
+    retryableStatusCodes: number[];
+}
+interface HttpClientConfig {
+    baseUrl: string;
+    timeout: number;
+    retry: RetryConfig;
+    debug: boolean;
+}
+interface RequestOptions {
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    headers?: Record<string, string>;
+    body?: unknown;
+    skipRetry?: boolean;
+    timeout?: number;
+}
+interface HttpResponse<T = unknown> {
+    ok: boolean;
+    status: number;
+    data: T;
+    headers: Record<string, string>;
+}
+
+declare class HttpClient {
+    private config;
+    constructor(baseUrl: string, config?: Partial<Omit<HttpClientConfig, "baseUrl">>);
+    get<T>(path: string, options?: Partial<RequestOptions>): Promise<HttpResponse<T>>;
+    post<T>(path: string, body?: unknown, options?: Partial<RequestOptions>): Promise<HttpResponse<T>>;
+    request<T>(path: string, options: RequestOptions): Promise<HttpResponse<T>>;
+    private executeWithRetry;
+    private executeRequest;
+    private buildUrl;
+    private buildFetchOptions;
+    private shouldRetry;
+    private isNetworkError;
+    private calculateDelay;
+    private sleep;
+    private log;
+    setDebug(debug: boolean): void;
+    getConfig(): Readonly<HttpClientConfig>;
+}
+
+declare class ApiClient {
+    private baseUrl;
+    private webUrl;
+    private appKey;
+    private debug;
+    private environment;
+    private offlineQueueEnabled;
+    private httpClient;
+    private readonly cache;
+    constructor(appKey: string, baseUrl?: string, debug?: boolean, environment?: Environment, offlineQueueEnabled?: boolean, timeout?: number);
+    /** Exposed only for QueueProcessor initialization. Prefer get()/post() for requests. */
+    getHttpClient(): HttpClient;
+    getWebUrl(): string;
+    getEnvironment(): Environment;
+    getQueueSize(): number;
+    setofflineQueueEnabled(enabled: boolean): void;
+    isofflineQueueEnabled(): boolean;
+    setEnvironment(environment: Environment): void;
+    setDebug(debug: boolean): void;
+    clearQueue(): Promise<void>;
+    get<T>(path: string): Promise<HttpResponse<T>>;
+    post<T>(path: string, body: unknown, skipRetry?: boolean): Promise<HttpResponse<T>>;
+    reportError(errorType: string, message: string, context?: Record<string, unknown>): Promise<void>;
+    trackEvent(eventName: string, distinctId: string, properties?: UserProperties, timestamp?: number): Promise<void>;
+    identify(distinctId: string, properties?: UserProperties, email?: string): Promise<void>;
+    startSession(distinctId: string, sessionId: string, platform?: string): Promise<{
+        success: boolean;
+    }>;
+    endSession(sessionId: string, durationSeconds: number): Promise<{
+        success: boolean;
+    }>;
+    getVariant(flagKey: string, distinctId: string): Promise<FlagVariant>;
+    getPaywall(placement: string): Promise<PaywallConfig | null>;
+    getEmergencyPaywall(): Promise<EmergencyPaywallResponse>;
+    getCampaign(placement: string, distinctId: string, context?: Record<string, unknown>): Promise<CampaignResponse | null>;
+    validatePurchase(platform: "ios" | "android", receipt: string, productId: string, transactionId: string, priceLocal: number, currency: string, country: string, distinctId?: string, paywallPlacement?: string, variantKey?: string): Promise<ValidatePurchaseResponse>;
+    getSubscriptionStatus(distinctId: string): Promise<SubscriptionStatusResponse$1>;
+    getConditionalFlag(flagKey: string, context: ConditionalFlagContext): Promise<ConditionalFlagResult>;
+    /**
+     * POST with offline queue fallback. Enqueues when offline or on network failure.
+     * Throws only when offlineQueueEnabled is false and the request fails.
+     */
+    private postWithQueue;
+    private log;
+}
+
+declare class AffiliateManager {
+    private apiClient;
+    private debug;
+    initialize(apiClient: ApiClient, debug?: boolean): void;
+    registerCoupon(code: string): Promise<{
+        success: boolean;
+        coupon?: AffiliateCoupon;
+        error?: string;
+    }>;
+    applyCoupon(code: string): Promise<{
+        success: boolean;
+        applied?: boolean;
+        error?: string;
+    }>;
+    getMyCoupon(): Promise<{
+        coupon: AffiliateCoupon | null;
+    }>;
+    getAppliedCoupon(): Promise<{
+        coupon: {
+            code: string;
+        } | null;
+    }>;
+    getBalance(): Promise<AffiliateBalance>;
+    getCommissions(): Promise<AffiliateCommission[]>;
+    requestWithdrawal(amount: number): Promise<{
+        success: boolean;
+        withdrawal?: WithdrawalRequest;
+        error?: string;
+    }>;
+    getWithdrawals(): Promise<WithdrawalRequest[]>;
+    private get;
+    private post;
+    private ensureInitialized;
+    private log;
+}
+declare const affiliateManager: AffiliateManager;
+
+declare const PaywalloAffiliate: {
+    registerCoupon: (code: string) => Promise<{
+        success: boolean;
+        coupon?: AffiliateCoupon;
+        error?: string;
+    }>;
+    applyCoupon: (code: string) => Promise<{
+        success: boolean;
+        applied?: boolean;
+        error?: string;
+    }>;
+    getMyCoupon: () => Promise<{
+        coupon: AffiliateCoupon | null;
+    }>;
+    getAppliedCoupon: () => Promise<{
+        coupon: {
+            code: string;
+        } | null;
+    }>;
+    getBalance: () => Promise<AffiliateBalance>;
+    getCommissions: () => Promise<AffiliateCommission[]>;
+    requestWithdrawal: (amount: number) => Promise<{
+        success: boolean;
+        withdrawal?: WithdrawalRequest;
+        error?: string;
+    }>;
+    getWithdrawals: () => Promise<WithdrawalRequest[]>;
+};
+
+declare class AffiliateError extends PaywalloError {
+    constructor(code: string, message: string);
+}
+declare const AFFILIATE_ERROR_CODES: {
+    readonly NOT_INITIALIZED: "AFFILIATE_NOT_INITIALIZED";
+    readonly COUPON_REGISTER_FAILED: "AFFILIATE_COUPON_REGISTER_FAILED";
+    readonly COUPON_APPLY_FAILED: "AFFILIATE_COUPON_APPLY_FAILED";
+    readonly BALANCE_FETCH_FAILED: "AFFILIATE_BALANCE_FETCH_FAILED";
+    readonly WITHDRAWAL_FAILED: "AFFILIATE_WITHDRAWAL_FAILED";
+    readonly NETWORK_ERROR: "AFFILIATE_NETWORK_ERROR";
+};
+
+declare class IAPService {
+    private productsCache;
+    private apiClient;
+    constructor(apiClient?: ApiClient);
+    private get debug();
+    private getDeviceCountry;
+    private getApiClient;
+    isAvailable(): boolean;
+    loadProducts(productIds: string[]): Promise<Product[]>;
+    getProduct(productId: string): Product | undefined;
+    getCachedProducts(): Map<string, Product>;
+    private validateWithServer;
+    private finishTransaction;
+    purchase(productId: string, options?: {
+        paywallPlacement?: string;
+        variantKey?: string;
+    }): Promise<PurchaseResult>;
+    restore(): Promise<Purchase[]>;
+}
+declare function getIAPService(): IAPService;
+
+declare function isAvailable(): boolean;
+declare const nativeStoreKit: {
+    isAvailable: typeof isAvailable;
+    getProducts(productIds: string[]): Promise<Product[]>;
+    purchase(productId: string): Promise<Purchase | null>;
+    finishTransaction(transactionId: string): Promise<void>;
+    getActiveTransactions(): Promise<Purchase[]>;
+};
+
+type PurchaseState = "idle" | "loading" | "purchasing" | "restoring" | "error";
+interface IAPProduct {
+    productId: string;
+    price: string;
+    currency: string;
+    localizedPrice: string;
+    title: string;
+    description: string;
+    type: "inapp" | "subs";
+    subscriptionPeriodAndroid?: string;
+    subscriptionPeriodNumberIOS?: string;
+    subscriptionPeriodUnitIOS?: string;
+    introductoryPrice?: string;
+    introductoryPricePaymentModeIOS?: string;
+    introductoryPriceNumberOfPeriodsIOS?: string;
+    introductoryPriceSubscriptionPeriodIOS?: string;
+    freeTrialPeriodAndroid?: string;
+}
+interface IAPPurchase {
+    productId: string;
+    transactionId?: string;
+    transactionDate: number;
+    transactionReceipt: string;
+    purchaseToken?: string;
+}
+interface PurchaseControllerConfig {
+    debug?: boolean;
+    validateOnServer?: boolean;
+    serverValidationUrl?: string;
+}
+interface ProductPriceInfo {
+    price: string;
+    priceValue: number;
+    currency: string;
+    localizedPrice: string;
+    pricePerMonth?: string;
+    pricePerWeek?: string;
+    pricePerDay?: string;
+}
+
+declare class PurchaseError extends PaywalloError {
+    readonly userCancelled: boolean;
+    constructor(code: string, message: string, userCancelled?: boolean);
+}
+declare const PURCHASE_ERROR_CODES: {
+    readonly NOT_INITIALIZED: "PURCHASE_NOT_INITIALIZED";
+    readonly PRODUCT_NOT_FOUND: "PRODUCT_NOT_FOUND";
+    readonly PURCHASE_FAILED: "PURCHASE_FAILED";
+    readonly RESTORE_FAILED: "RESTORE_FAILED";
+    readonly VALIDATION_FAILED: "VALIDATION_FAILED";
+    readonly USER_CANCELLED: "USER_CANCELLED";
+    readonly NETWORK_ERROR: "PURCHASE_NETWORK_ERROR";
+    readonly STORE_ERROR: "PURCHASE_STORE_ERROR";
+    readonly PENDING_PURCHASE: "PURCHASE_PENDING";
+    readonly DEFERRED_PURCHASE: "PURCHASE_DEFERRED";
+    readonly STORE_NOT_AVAILABLE: "PURCHASE_STORE_NOT_AVAILABLE";
+};
+declare function createPurchaseError(code: keyof typeof PURCHASE_ERROR_CODES, message?: string): PurchaseError;
+
+interface IdentityState {
+    deviceId: string;
+    email: string | null;
+    properties: UserProperties;
+}
+declare class IdentityManager {
+    private deviceId;
+    private email;
+    private properties;
+    private apiClient;
+    private secureStorage;
+    private debug;
+    private initialized;
+    initialize(apiClient: ApiClient, debug?: boolean): Promise<string>;
+    identify(options?: IdentifyOptions | UserProperties): Promise<void>;
+    getDistinctId(): string;
+    getDeviceId(): string | null;
+    getEmail(): string | null;
+    getProperties(): UserProperties;
+    updateProperties(properties: UserProperties): Promise<void>;
+    reset(): Promise<void>;
+    getState(): IdentityState;
+    isSecureStorageAvailable(): boolean;
+    private loadPersistedState;
+    private ensureInitialized;
+    private log;
+}
+declare const identityManager: IdentityManager;
+
+declare class IdentityError extends PaywalloError {
+    constructor(code: string, message: string);
+}
+declare const IDENTITY_ERROR_CODES: {
+    readonly NOT_INITIALIZED: "IDENTITY_NOT_INITIALIZED";
+    readonly DEVICE_ID_UNAVAILABLE: "IDENTITY_DEVICE_ID_UNAVAILABLE";
+    readonly STORAGE_READ_FAILED: "IDENTITY_STORAGE_READ_FAILED";
+    readonly STORAGE_WRITE_FAILED: "IDENTITY_STORAGE_WRITE_FAILED";
+    readonly IDENTIFY_FAILED: "IDENTITY_IDENTIFY_FAILED";
+};
+
+type NetworkState = "online" | "offline" | "unknown";
+type NetworkListener = (state: NetworkState) => void;
+interface NetworkMonitorConfig {
+    debug: boolean;
+    checkInterval: number;
+    checkUrl: string;
+}
+
+declare class NetworkMonitorClass {
+    private config;
+    private listeners;
+    private currentState;
+    private netInfoModule;
+    private netInfoSubscription;
+    private appStateSubscription;
+    private initialized;
+    private checkIntervalId;
+    initialize(config?: Partial<NetworkMonitorConfig>): Promise<void>;
+    private setupNetInfoListener;
+    private setupFallbackDetection;
+    private setupAppStateListener;
+    private checkConnectivity;
+    private netInfoStateToNetworkState;
+    private updateState;
+    private notifyListeners;
+    isOnline(): boolean;
+    getState(): NetworkState;
+    isInitialized(): boolean;
+    addListener(listener: NetworkListener): () => void;
+    removeListener(listener: NetworkListener): void;
+    forceCheck(): Promise<NetworkState>;
+    dispose(): void;
+    private log;
+    setDebug(debug: boolean): void;
+}
+declare const networkMonitor: NetworkMonitorClass;
+
+interface SessionState {
+    sessionId: string | null;
+    startedAt: Date | null;
+    isActive: boolean;
+    duration: number;
+}
+interface SessionConfig {
+    sessionTimeoutMs?: number;
+    trackAppState?: boolean;
+}
+type EmergencyPaywallHandler = (paywallId: string) => Promise<void>;
+
+declare class SessionManager {
+    private sessionId;
+    private sessionStartedAt;
+    private appState;
+    private apiClient;
+    private debug;
+    private initialized;
+    private config;
+    private backgroundTimestamp;
+    private appStateSubscription;
+    private emergencyPaywallHandler;
+    private emergencyPaywallShownInSession;
+    private secureStorage;
+    initialize(apiClient: ApiClient, config?: SessionConfig, debug?: boolean): Promise<void>;
+    startSession(): Promise<string>;
+    endSession(): Promise<void>;
+    getSessionId(): string | null;
+    getSessionDuration(): number;
+    isSessionActive(): boolean;
+    getState(): SessionState;
+    destroy(): void;
+    registerEmergencyPaywallHandler(handler: EmergencyPaywallHandler): void;
+    private restoreSession;
+    private setupAppStateListener;
+    private handleAppStateChange;
+    private handleForeground;
+    private handleBackground;
+    private checkEmergencyPaywall;
+    private trackSessionStart;
+    private trackSessionEnd;
+    private trackAppOpen;
+    private trackAppBackground;
+    private ensureInitialized;
+    private log;
+}
+declare const sessionManager: SessionManager;
+
+declare class SessionError extends PaywalloError {
+    constructor(code: string, message: string);
+}
+declare const SESSION_ERROR_CODES: {
+    readonly NOT_INITIALIZED: "SESSION_NOT_INITIALIZED";
+    readonly START_FAILED: "SESSION_START_FAILED";
+    readonly END_FAILED: "SESSION_END_FAILED";
+    readonly RESTORE_FAILED: "SESSION_RESTORE_FAILED";
+};
+
+interface PreloadCampaignResult {
+    success: boolean;
+    error?: Error;
+}
+interface PaywalloInitConfig extends PaywalloConfig {
+    sessionConfig?: SessionConfig;
+    autoStartSession?: boolean;
+    offlineQueueEnabled?: boolean;
+    timeout?: number;
+    /** Request ATT permission during init (iOS only). Default: false. */
+    requestATT?: boolean;
+}
+interface IPaywalloClient {
+    init(config: PaywalloInitConfig): Promise<void>;
+    identify(options?: IdentifyOptions | UserProperties): Promise<void>;
+    track(eventName: string, options?: TrackEventOptions): Promise<void>;
+    getVariant(flagKey: string): Promise<FlagVariant>;
+    getConditionalFlag(flagKey: string, context?: Partial<ConditionalFlagContext>): Promise<boolean>;
+    getPaywall(placement: string): Promise<PaywallConfig | null>;
+    presentPaywall(placement: string): Promise<PaywallResult>;
+    getCampaign(placement: string, context?: Record<string, unknown>): Promise<CampaignResponse | null>;
+    presentCampaign(placement: string, context?: Record<string, unknown>): Promise<CampaignResult>;
+    hasActiveSubscription(): Promise<boolean>;
+    getSubscription(): Promise<Subscription | null>;
+    restorePurchases(): Promise<RestoreResult>;
+    requireSubscription(paywallPlacement?: string): Promise<boolean>;
+    requireSubscriptionWithCampaign(placement: string, context?: Record<string, unknown>): Promise<boolean>;
+    gateContent<T>(content: () => T | Promise<T>, paywallPlacement?: string): Promise<T | null>;
+    gateContentWithCampaign<T>(content: () => T | Promise<T>, placement: string, context?: Record<string, unknown>): Promise<T | null>;
+    preloadCampaign(placement: string, context?: Record<string, unknown>): Promise<PreloadCampaignResult>;
+    getPreloadedCampaign(placement: string): CampaignResponse | null;
+    reset(): Promise<void>;
+    fullReset(): Promise<void>;
+    getConfig(): PaywalloConfig | null;
+    getDistinctId(): string;
+    getDeviceId(): string | null;
+    getEmail(): string | null;
+    getEnvironment(): Environment;
+    setEnvironment(environment: Environment): void;
+    getApiClient(): ApiClient | null;
+    getWebUrl(): string | null;
+    getIdentityState(): IdentityState;
+    getSessionState(): SessionState;
+    getSessionId(): string | null;
+    startSession(): Promise<string>;
+    endSession(): Promise<void>;
+    registerPaywallPresenter(presenter: (placement: string) => Promise<PaywallResult>): void;
+    registerCampaignPresenter(presenter: (campaign: CampaignResponse) => Promise<CampaignResult>): void;
+    registerSubscriptionGetter(getter: () => Promise<Subscription | null>): void;
+    registerActiveChecker(checker: () => Promise<boolean>): void;
+    registerRestoreHandler(handler: () => Promise<RestoreResult>): void;
+    registerEmergencyPaywallHandler(handler: EmergencyPaywallHandler): void;
+    isOnline(): boolean;
+    getOfflineQueueSize(): number;
+    clearOfflineQueue(): Promise<void>;
+    processOfflineQueue(): Promise<{
+        processed: number;
+        failed: number;
+    }>;
+    onboardingStep(index: number, name: string): Promise<void>;
+    coreAction(actionName: string): Promise<void>;
+}
+
+declare const PaywalloClient: IPaywalloClient;
+
+interface QueueItem {
+    id: string;
+    method: "POST" | "PUT";
+    url: string;
+    body: unknown;
+    headers?: Record<string, string>;
+    timestamp: number;
+    attempts: number;
+    maxAttempts: number;
+}
+interface OfflineQueueConfig {
+    maxItems: number;
+    maxAge: number;
+    maxAttempts: number;
+    storageKey: string;
+    debug: boolean;
+}
+type QueueEventType = "item:added" | "item:removed" | "item:success" | "item:failed" | "item:evicted" | "processing:start" | "processing:end";
+interface QueueEvent {
+    type: QueueEventType;
+    item?: QueueItem;
+    error?: Error;
+    queueSize: number;
+}
+type QueueListener = (event: QueueEvent) => void;
+
+declare class OfflineQueueClass {
+    private config;
+    private queue;
+    private listeners;
+    private initialized;
+    private processing;
+    private processingLock;
+    private cleanupTimer;
+    initialize(config?: Partial<OfflineQueueConfig>): Promise<void>;
+    private loadFromStorage;
+    private saveToStorage;
+    private cleanupExpired;
+    enqueue(method: "POST" | "PUT", url: string, body: unknown, headers?: Record<string, string>): Promise<QueueItem>;
+    private findDuplicateIndex;
+    dequeue(): Promise<QueueItem | null>;
+    removeItem(id: string): Promise<boolean>;
+    processQueue(processor: (item: QueueItem) => Promise<boolean | {
+        success: boolean;
+        permanent?: boolean;
+    }>, options?: {
+        delayBetweenItems?: number;
+    }): Promise<{
+        processed: number;
+        failed: number;
+    }>;
+    /** Returns true if the item was permanently removed (counted as failed). */
+    private handleItemFailure;
+    private sleep;
+    getQueue(): ReadonlyArray<QueueItem>;
+    getSize(): number;
+    isEmpty(): boolean;
+    isProcessing(): boolean;
+    clear(): Promise<void>;
+    clearItemsWithInvalidAppKey(validAppKey: string): Promise<number>;
+    addListener(listener: QueueListener): () => void;
+    removeListener(listener: QueueListener): void;
+    private emit;
+    private log;
+    setDebug(debug: boolean): void;
+    dispose(): void;
+}
+declare const offlineQueue: OfflineQueueClass;
+
+interface QueueProcessorConfig {
+    debounceMs: number;
+    debug: boolean;
+}
+declare class QueueProcessorClass {
+    private config;
+    private httpClient;
+    private networkUnsubscribe;
+    private debounceTimeout;
+    private retryIntervalId;
+    private initialized;
+    initialize(httpClient: HttpClient, config?: Partial<QueueProcessorConfig>): void;
+    private scheduleProcessing;
+    processQueue(): Promise<{
+        processed: number;
+        failed: number;
+    }>;
+    private processItem;
+    enqueueIfOffline(method: "POST" | "PUT", url: string, body: unknown, headers?: Record<string, string>): Promise<{
+        queued: boolean;
+        item?: QueueItem;
+    }>;
+    getQueueSize(): number;
+    clearQueue(): Promise<void>;
+    dispose(): void;
+    private log;
+    setDebug(debug: boolean): void;
+}
+declare const queueProcessor: QueueProcessorClass;
+
+declare class AnalyticsError extends PaywalloError {
+    constructor(code: string, message: string);
+}
+declare const ANALYTICS_ERROR_CODES: {
+    readonly NOT_INITIALIZED: "ANALYTICS_NOT_INITIALIZED";
+    readonly INVALID_STEP_INDEX: "ANALYTICS_INVALID_STEP_INDEX";
+    readonly INVALID_ACTION_NAME: "ANALYTICS_INVALID_ACTION_NAME";
+};
+
+declare class CampaignError extends PaywalloError {
+    constructor(code: string, message: string);
+}
+declare const CAMPAIGN_ERROR_CODES: {
+    readonly NOT_INITIALIZED: "CAMPAIGN_NOT_INITIALIZED";
+    readonly FETCH_FAILED: "CAMPAIGN_FETCH_FAILED";
+    readonly PRELOAD_FAILED: "CAMPAIGN_PRELOAD_FAILED";
+    readonly NOT_FOUND: "CAMPAIGN_NOT_FOUND";
+    readonly PRESENT_FAILED: "CAMPAIGN_PRESENT_FAILED";
+};
+
+declare function usePaywallo(): PaywalloContextValue;
+
+interface FormattedProduct extends ProductPriceInfo {
+    productId: string;
+    title: string;
+    description: string;
+    subscriptionPeriod?: string;
+    introductoryPrice?: string;
+    freeTrialPeriod?: string;
+}
+
+interface UseProductsResult {
+    products: IAPProduct[];
+    formattedProducts: FormattedProduct[];
+    isLoading: boolean;
+    error: Error | null;
+    loadProducts: (productIds: string[]) => Promise<void>;
+    getProduct: (productId: string) => IAPProduct | undefined;
+    getFormattedProduct: (productId: string) => FormattedProduct | undefined;
+    getPriceInfo: (productId: string) => ProductPriceInfo | undefined;
+}
+declare function useProducts(initialProductIds?: string[]): UseProductsResult;
+
+interface UsePurchaseResult {
+    state: PurchaseState;
+    purchase: (productId: string) => Promise<IAPPurchase>;
+    restore: () => Promise<IAPPurchase[]>;
+    error: PurchaseError | null;
+    isLoading: boolean;
+    isPurchasing: boolean;
+    isRestoring: boolean;
+}
+declare function usePurchase(): UsePurchaseResult;
+
+type SubscriptionStatus = "active" | "expired" | "grace_period" | "billing_retry" | "canceled" | "paused" | "unknown";
+interface SubscriptionInfo {
+    id: string;
+    productId: string;
+    status: SubscriptionStatus;
+    expiresAt: Date;
+    originalPurchaseDate: Date;
+    latestPurchaseDate: Date;
+    willRenew: boolean;
+    isTrial: boolean;
+    isIntroductoryPeriod: boolean;
+    platform: "ios" | "android";
+    storeTransactionId?: string;
+    cancellationDate?: Date;
+    gracePeriodExpiresAt?: Date;
+}
+interface SubscriptionStatusResponse {
+    hasActiveSubscription: boolean;
+    subscription: SubscriptionInfo | null;
+    entitlements: string[];
+}
+interface CachedSubscription {
+    data: SubscriptionStatusResponse;
+    cachedAt: number;
+    isStale: boolean;
+}
+interface SubscriptionManagerConfig {
+    cacheTTL?: number;
+    serverUrl: string;
+    appKey: string;
+    debug?: boolean;
+}
+
+interface UseSubscriptionResult {
+    subscription: SubscriptionInfo | null;
+    isActive: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    entitlements: string[];
+    refresh: () => Promise<void>;
+    restore: () => Promise<void>;
+}
+declare function useSubscription(): UseSubscriptionResult;
+
+interface PaywalloProviderProps {
+    children: React__default.ReactNode;
+    config: PaywalloConfig;
+}
+declare function PaywalloProvider({ children, config }: PaywalloProviderProps): React__default.ReactElement;
+
+declare class SubscriptionCache {
+    private ttl;
+    private memoryCache;
+    private storage;
+    constructor(ttl?: number);
+    get(): Promise<CachedSubscription | null>;
+    set(data: SubscriptionStatusResponse): Promise<void>;
+    invalidate(): Promise<void>;
+    private isExpired;
+    setTTL(ttl: number): void;
+}
+
+type SubscriptionListener = (subscription: SubscriptionStatusResponse) => void;
+declare class SubscriptionManagerClass {
+    private config;
+    private cache;
+    private listeners;
+    private userId;
+    constructor();
+    init(config: SubscriptionManagerConfig): void;
+    setUserId(userId: string | null): void;
+    hasActiveSubscription(forceRefresh?: boolean): Promise<boolean>;
+    getSubscription(forceRefresh?: boolean): Promise<SubscriptionInfo | null>;
+    getEntitlements(forceRefresh?: boolean): Promise<string[]>;
+    getSubscriptionStatus(forceRefresh?: boolean): Promise<SubscriptionStatusResponse>;
+    restorePurchases(): Promise<SubscriptionStatusResponse>;
+    private fetchSubscriptionStatus;
+    private getEmptyStatus;
+    addListener(listener: SubscriptionListener): () => void;
+    private notifyListeners;
+    onPurchaseComplete(): Promise<void>;
+    private log;
+}
+declare const subscriptionManager: SubscriptionManagerClass;
+
+declare function setCurrentLanguage(language: string): void;
+declare function setDefaultLanguage(language: string): void;
+declare function getCurrentLanguage(): string;
+declare function getDefaultLanguage(): string;
+declare function getLocalizedString(text: string | LocalizedText | undefined): string;
+declare function detectDeviceLanguage(): string;
+declare function initLocalization(options?: {
+    defaultLanguage?: string;
+    detectDevice?: boolean;
+}): void;
+
+interface VariableContext {
+    selectedProductId?: string;
+    primaryProductId?: string;
+    secondaryProductId?: string;
+    products: Map<string, Product>;
+    customVariables?: Record<string, string>;
+    deviceInfo?: {
+        name?: string;
+        model?: string;
+        os?: string;
+        osVersion?: string;
+        locale?: string;
+    };
+    userInfo?: {
+        id?: string;
+        name?: string;
+        email?: string;
+    };
+}
+declare function resolveText(text: string, context: VariableContext): string;
+declare function parseVariables(text: string): string[];
+declare function hasVariables(text: string): boolean;
+
+declare const Paywallo: IPaywalloClient;
+
+export { AFFILIATE_ERROR_CODES, ANALYTICS_ERROR_CODES, type AffiliateBalance, type AffiliateCommission, type AffiliateCoupon, AffiliateError, AffiliateManager, AnalyticsError, ApiClient, type ApiClientConfig, type BlockType, type BoxSpacing, CAMPAIGN_ERROR_CODES, type CachedSubscription, CampaignError, type CampaignPresentOptions, type CampaignResponse, type CampaignResult, type ConditionalFlagContext, type ConditionalFlagResult, PURCHASE_ERROR_CODES as ERROR_CODES, type Environment, type FlagVariant, HttpClient, type HttpClientConfig, type HttpResponse, type IAPProduct, type IAPPurchase, IAPService, IDENTITY_ERROR_CODES, type IPaywalloClient, type IdentifyOptions, IdentityError, IdentityManager, type IdentityState, type LocalizedText, type NetworkListener, type NetworkMonitorConfig, type NetworkState, type OfflineQueueConfig, PAYWALL_ERROR_CODES, PURCHASE_ERROR_CODES, type PaywallBlockConfig, type PaywallConfig, PaywallContext, PaywallError, PaywallModal, type PaywallNode, type PaywallPresentOptions, type PaywallResult, type PaywallState, Paywallo, PaywalloAffiliate, PaywalloClient, type PaywalloConfig, PaywalloContext, PaywalloError, type PaywalloInitConfig, PaywalloProvider, type PreloadCampaignResult, type PreloadResult, type Product, type ProductPriceInfo, type Purchase, type PurchaseControllerConfig, PurchaseError, type PurchaseResult, type PurchaseState, type QueueEvent, type QueueItem, type QueueListener, type QueueProcessorConfig, type RequestOptions, type RestoreResult, type RetryConfig, SESSION_ERROR_CODES, type SessionConfig, SessionError, SessionManager, type SessionState, type Subscription, SubscriptionCache, type SubscriptionInfo, type SubscriptionManagerConfig, type SubscriptionPlatform, type SubscriptionStatus$1 as SubscriptionStatus, type SubscriptionStatusResponse$1 as SubscriptionStatusResponse, type TapBehavior, type TrackEventOptions, type UserProperties, type ValidatePurchaseResponse, type VariableContext, type WithdrawalRequest, affiliateManager, createPurchaseError, Paywallo as default, detectDeviceLanguage, getCurrentLanguage, getDefaultLanguage, getIAPService, getLocalizedString, hasVariables, identityManager, initLocalization, nativeStoreKit, networkMonitor, offlineQueue, parseVariables, queueProcessor, resolveText, sessionManager, setCurrentLanguage, setDefaultLanguage, subscriptionManager, usePaywallContext, usePaywallo, useProducts, usePurchase, useSubscription };