@namiml/sdk-core 3.4.0-dev.202603271304

package/dist/index.d.ts

@@ -0,0 +1,2912 @@
+/**
+ * Platform-agnostic storage interface.
+ * Web: backed by localStorage
+ * React Native: backed by MMKV or similar synchronous store
+ */
+interface IStorageAdapter {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+    getAllKeys(): string[];
+}
+
+interface Device {
+    id: string;
+    advertising_id: string;
+    app_env: string;
+    app_version: string;
+    country: string;
+    customer_data_platform_id: string;
+    device_model: string;
+    extended_framework_version: string;
+    extended_platform_version: string;
+    extended_platform: string;
+    form_factor: TDevice;
+    language: string;
+    marketplace_country: string;
+    os_name: string;
+    os_version: string;
+    sdk_client: string;
+    sdk_version: string;
+    vendor_id: string;
+}
+interface DevicePayload {
+    id?: string;
+    os_version: string;
+    os_name: string;
+    browser_name: string;
+    browser_version: string | undefined;
+    sdk_client: string;
+    device_model?: string;
+    form_factor?: string;
+    sdk_version: string;
+    language: string;
+    extended_platform_version?: string;
+    extended_platform?: string;
+}
+type TDevice = 'phone' | 'tablet' | 'television' | 'desktop';
+type TDeviceOrientation = 'landscape' | 'portrait';
+
+interface ScreenInfo {
+    width: number;
+    height: number;
+    scale: number;
+}
+/**
+ * Platform-agnostic device information interface.
+ * Web: backed by Bowser + navigator
+ * React Native: backed by react-native-device-info + Platform + Dimensions
+ */
+interface IDeviceAdapter {
+    getDeviceData(namiCommands?: string[]): DevicePayload;
+    getDeviceFormFactor(): TDevice;
+    getDeviceScaleFactor(formFactor?: string): number;
+    generateUUID(): string;
+    getScreenInfo(): ScreenInfo;
+    getLanguage(): string;
+}
+
+interface FormFactor {
+    form_factor: string;
+    supports_portrait: boolean;
+    supports_landscape: boolean;
+}
+type AvailableCampaignsResponseHandler = (campaigns: NamiCampaign[]) => void;
+declare enum CampaignRuleConversionEventType {
+    DEEPLINK = "deeplink",
+    IN_APP = "in_app"
+}
+
+declare const LogicalOperator: {
+    readonly NONE: "none";
+    readonly AND: "and";
+    readonly OR: "or";
+};
+type LogicalOperator = (typeof LogicalOperator)[keyof typeof LogicalOperator];
+declare const FilterOperator: {
+    readonly I_CONTAINS: "i_contains";
+    readonly EQUALS: "equals";
+    readonly I_EQUALS: "i_equals";
+    readonly NOT_EQUALS: "not_equals";
+    readonly NOT_I_EQUALS: "not_i_equals";
+    readonly NOT_CONTAINS: "not_contains";
+    readonly SET: "set";
+    readonly NOT_SET: "notSet";
+};
+type FilterOperator = (typeof FilterOperator)[keyof typeof FilterOperator];
+interface NamiConditionFilter {
+    identifier: string;
+    operator: FilterOperator;
+    values: string[];
+}
+interface NamiConditions {
+    filter?: NamiConditionFilter[];
+    operator?: LogicalOperator;
+}
+
+declare const NamiFlowStepType: {
+    readonly ENTRY: "entry";
+    readonly SCREEN: "screen";
+    readonly BRANCH: "branch";
+    readonly EXIT: "exit";
+    readonly UNKNOWN: "unknown";
+};
+type NamiFlowStepType = (typeof NamiFlowStepType)[keyof typeof NamiFlowStepType];
+declare enum NamiFlowActionFunction {
+    NAVIGATE = "flowNav",
+    BACK = "flowPrev",
+    NEXT = "flowNext",
+    FINISHED = "flowDone",
+    DISMISS = "flowDismiss",
+    EXIT = "flowExit",
+    HANDOFF = "flowHandoff",
+    TRACK = "trackEvent",
+    LOG = "logEvent",
+    SET_VIDEO = "setVideo",
+    FLOW_EVENT = "flowEvent",
+    BLOCK_BACK = "blockBackToStep",
+    FLOW_ENABLED = "flowInteractionEnabled",
+    FLOW_DISABLED = "flowInteractionDisabled",
+    SET_TAGS = "setTags",
+    PAUSE = "flowPause",
+    RESUME = "flowResume"
+}
+type NamiFlowHandoffStepHandler = (handoffTag: string, handoffData?: Record<string, any>) => void;
+type NamiFlowEventHandler = (eventHandler: Record<string, any>) => void;
+interface NamiFlowDTO {
+    flow_id?: string;
+    object_id?: string;
+    object?: NamiFlowObjectDTO;
+}
+type NamiFlowWithObject = Omit<NamiFlowDTO, 'object'> & {
+    object: NamiFlowObjectDTO;
+};
+interface NamiFlowObjectDTO {
+    id?: string;
+    name?: string;
+    resume_from_bookmark?: boolean;
+    screens?: string[];
+    form_factors?: FormFactor[];
+    version?: string;
+    steps?: NamiFlowStep[];
+    transition?: NamiFlowTransition;
+}
+type SetVideoAction = {
+    name?: string;
+    url?: string;
+};
+interface NamiFlowAction {
+    id?: string;
+    function: `${NamiFlowActionFunction}`;
+    parameters?: {
+        handoffTag?: string;
+        handoffData?: Record<string, any>;
+        handoffFormId?: string;
+        step?: string;
+        eventName?: string;
+        delay?: string | number;
+        [key: string]: any;
+    } & SetVideoAction;
+    conditions?: NamiConditions[];
+}
+interface NamiFlowOn {
+    before?: NamiFlowAction[];
+    action?: NamiFlowAction[];
+    after?: NamiFlowAction[];
+}
+interface NamiFlowStep {
+    id: string;
+    name?: string;
+    type: NamiFlowStepType;
+    screen?: string;
+    branch_tags?: string[];
+    actions: Partial<Record<string, NamiFlowOn[]>>;
+    allow_back_to?: boolean;
+}
+type NamiFlowTransition = 'none' | 'slide' | 'verticalSlide' | 'fade';
+type NamiFlowTransitionDirection = 'forward' | 'backward';
+interface NamiFlowAnimation {
+    transition: NamiFlowTransition;
+    direction: NamiFlowTransitionDirection;
+}
+declare const NamiReservedActions: {
+    readonly BUY_SKU: "__buy_sku__";
+    readonly DEFAULT: "__default__";
+    readonly APPEAR: "__appear__";
+    readonly DISAPPEAR: "__disappear__";
+    readonly LOGIN_SUCCESS: "__login_success__";
+    readonly LOGIN_FAILURE: "__login_failure__";
+    readonly LOGOUT_SUCCESS: "__logout_success__";
+    readonly LOGOUT_FAILURE: "__logout_failure__";
+    readonly PURCHASE_SUCCESS: "__purchase_success__";
+    readonly PURCHASE_FAILURE: "__purchase_failure__";
+    readonly RESUME: "__resume__";
+    readonly REMOTE_BACK: "__remoteback__";
+    readonly TAG_UPDATE: "__tag_update__";
+};
+
+/**
+ * @type NamiCampaignSegment
+ * Represents a segment within a campaign.
+ */
+interface NamiCampaignSegment {
+    form_factors: FormFactor[];
+    paywall?: string | null;
+    paywall_url?: string | null;
+    flow?: NamiFlowDTO | null;
+    segment: string;
+    split: number;
+    conversion_event_type?: CampaignRuleConversionEventType | null;
+    conversion_event_url?: string | null;
+}
+/**
+ * @type NamiAnonymousCampaign
+ * Represents the anonymous campaign in Nami.
+ */
+interface NamiAnonymousCampaign {
+    rule: string;
+    name: string;
+    type: string | NamiCampaignRuleType;
+    value?: string | null;
+    external_segment: string | null;
+    segments: NamiCampaignSegment[];
+}
+/**
+ * @type NamiCampaign
+ * Represents the campaign in Nami.
+ */
+interface NamiCampaign {
+    rule: string;
+    name: string;
+    segment: string;
+    paywall?: string | null;
+    paywall_url?: string | null;
+    page_urls?: Record<string, string> | null;
+    type: string | NamiCampaignRuleType;
+    value?: string | null;
+    form_factors: FormFactor[];
+    external_segment: string | null;
+    conversion_event_type?: CampaignRuleConversionEventType | null;
+    conversion_event_url?: string | null;
+    flow?: NamiFlowDTO | null;
+}
+interface NamiFlowCampaign extends NamiCampaign {
+    flow: NamiFlowWithObject;
+}
+declare function isNamiFlowCampaign(campaign?: NamiCampaign): campaign is NamiFlowCampaign;
+/**
+ * @enum NamiCampaignRuleType
+ * Types of Nami campaigns
+ */
+declare enum NamiCampaignRuleType {
+    DEFAULT = "default",
+    LABEL = "label",
+    UNKNOWN = "unknown",
+    URL = "url"
+}
+
+declare const NamiAnimationType: {
+    readonly Wave: "wave";
+    readonly Pulse: "pulse";
+    readonly None: "none";
+};
+type NamiAnimationType = typeof NamiAnimationType[keyof typeof NamiAnimationType];
+type PulseSpec = typeof NamiAnimationType.Pulse | {
+    type: typeof NamiAnimationType.Pulse;
+    duration?: number;
+    scale?: number;
+};
+type WaveSpec = typeof NamiAnimationType.Wave | {
+    type: typeof NamiAnimationType.Wave;
+    duration?: number;
+    delay?: number;
+    circle1Color?: string;
+    circle2Color?: string;
+    lineWidth?: number;
+};
+type NoneSpec = typeof NamiAnimationType.None | {
+    type: typeof NamiAnimationType.None;
+};
+type NamiAnimationSpec = WaveSpec | PulseSpec | NoneSpec;
+type NamiAnimationObjectSpec = Extract<WaveSpec, {
+    type: typeof NamiAnimationType.Wave;
+}> | Extract<PulseSpec, {
+    type: typeof NamiAnimationType.Pulse;
+}> | Extract<NoneSpec, {
+    type: typeof NamiAnimationType.None;
+}>;
+type Wave = Required<Extract<WaveSpec, {
+    type: typeof NamiAnimationType.Wave;
+}>>;
+type Pulse = Required<Extract<PulseSpec, {
+    type: typeof NamiAnimationType.Pulse;
+}>>;
+type None = Required<Extract<NoneSpec, {
+    type: typeof NamiAnimationType.None;
+}>>;
+type NamiAnimation = Wave | Pulse | None;
+
+/**
+ * @type NamiProductDetails
+ * minimal required product details formed from actual product details
+ */
+interface NamiProductDetails {
+    name?: string;
+    description?: string;
+    product_ref_id: string;
+    product_type: NamiSKUType;
+    subscription_period?: NamiSubscriptionPeriod;
+    offers: NamiProductOffer[];
+}
+type NamiProductOffer = NamiOfferPrice & {
+    offer_ref_id?: string;
+    offer_type: 'promo' | 'default' | (string & {});
+    promo_period?: NamiOfferPeriod;
+    promo_price?: NamiOfferPrice;
+};
+type NamiOfferPrice = {
+    price: number;
+    currency: string;
+};
+type NamiOfferPeriod = NamiSubscriptionPeriod;
+type NamiSubscriptionInterval = 'day' | 'week' | 'month' | 'year' | 'unknown' | (string & {});
+type NamiSubscriptionPeriod = {
+    type: NamiSubscriptionInterval;
+    count: number;
+    period_start?: number;
+    period_end?: number;
+};
+
+interface SKU {
+    id: string;
+    name: string;
+    sku_ref_id: string;
+    entitlements: IEntitlements$1[];
+    sku_type?: NamiSKUType;
+}
+interface PaywallSKU extends SKU {
+    display_text?: string;
+    sub_display_text?: string;
+    featured?: boolean;
+    variables?: {
+        [key: string]: any;
+    };
+    product_details?: NamiProductDetails | null;
+    offer_id?: string | null;
+    offer_type?: string | null;
+    offer_ref_id?: string | null;
+    computed_signature?: string | null;
+}
+type AppleProduct = unknown;
+type GoogleProduct = unknown;
+type AmazonProduct = unknown;
+
+/**
+ * @type NamiSKU
+ * This object represents a specific in-app purchase SKU available on a specific platform.
+ *
+ * It contains some general meta-data about specific SKU and associated [ProductDetails] object from
+ * Google Play Billing.
+ *
+ * Note that in certain cases, depending on cached state of the SDK, [ProductDetails] might not
+ * be fully complete object (potentially generated temporarily with minimum required information)
+ */
+type NamiSKU = {
+    id: string;
+    name?: string;
+    skuId: string;
+    appleProduct?: AppleProduct;
+    googleProduct?: GoogleProduct;
+    amazonProduct?: AmazonProduct;
+    type: NamiSKUType;
+    promoId?: string | null;
+    promoToken?: string | null;
+    productDetails?: NamiProductDetails | null;
+    entitlements: IEntitlements$1[];
+};
+/**
+ * @type NamiSKUType
+ * Types of products from Nami
+ */
+type NamiSKUType = 'unknown' | 'one_time_purchase' | 'subscription';
+
+type TImageComponent = TBaseComponent & {
+    component: "image";
+    url?: string | null;
+    aspectRatio?: number;
+    imageCropping?: "fill" | "fit";
+    alt?: string | null;
+    blur?: string | null;
+};
+type TSegmentPicker = TBaseComponent & {
+    component: "segmentPicker" | "formSegmentPicker";
+    formId?: string;
+    components: TSegmentPickerItem[];
+};
+type TSegmentPickerItem = TBaseComponent & {
+    component: "segmentPickerItem";
+    ref?: any;
+    text?: string;
+    alignment?: AlignmentType;
+    activeFillColor?: string;
+    activeBorderColor?: string;
+    activeBorderRadius?: number;
+    activeBorderWidth?: number;
+    activeRoundBorders?: Array<BorderLocationType>;
+    activeFontSize?: number;
+    activeFontColor?: string;
+    activeFontName?: string;
+    activeDropShadow?: string;
+    inactiveBorderRadius?: number;
+    inactiveBorderColor?: string;
+    inactiveBorderWidth?: number;
+    inactiveRoundBorders?: Array<BorderLocationType>;
+    inactiveFontSize?: number;
+    inactiveFontName?: string;
+    inactiveFontColor?: string;
+    inactiveDropShadow?: string;
+    leftPadding?: number;
+    rightPadding?: number;
+    topPadding?: number;
+    bottomPadding?: number;
+    formId?: string;
+    checked?: boolean;
+};
+type TSpacerComponent = TBaseComponent & {
+    component: "spacer";
+};
+type TSvgImageComponent = TBaseComponent & {
+    component: "svgImage";
+    url?: string | null;
+    fontColor?: string;
+};
+type TSymbolComponent = Omit<TTextComponent, "component" | "textType" | "text"> & {
+    component: "symbol";
+    name: string;
+};
+type TTextComponent = TBaseComponent & {
+    component: "text";
+    textType: "title" | "body" | "legal" | "text";
+    androidFontSize?: number;
+    fontSize?: number;
+    activeFontColor?: string;
+    fontColor?: string;
+    fontName?: string;
+    text: string;
+    strikethrough?: boolean | string;
+    linkColor?: string;
+    dateTimeFormat?: string;
+    blur?: number | null;
+    capitalize?: boolean;
+};
+type TTextLikeComponent = TTextComponent | TTextListComponent | TSymbolComponent;
+type TTextListComponent = Omit<TTextComponent, "component" | "text"> & {
+    component: "text-list";
+    texts: string[];
+    bulletComponent?: TSymbolComponent;
+};
+type TVideoComponent = TBaseComponent & {
+    component: "videoUrl";
+    url?: string | null;
+    aspectRatio?: number;
+    imageCropping?: "fill" | "fit";
+    autoplayVideo?: boolean;
+    controlsType?: string;
+    fallbackImage?: string | null;
+    loopVideo?: boolean;
+    mute?: boolean;
+    screenreaderText?: string;
+};
+type TConditionalComponent = TBaseComponent & {
+    component: "condition";
+    components?: TComponent[];
+    assertions?: TTestObject[];
+    orAssertions?: TTestObject[] | undefined;
+};
+type TQRCodeComponent = TBaseComponent & {
+    component: "qrCode";
+    url: string;
+    height: number | string;
+    width: number | string;
+    color?: string;
+    fillColor?: string;
+    borderWidth?: number;
+    borderColor?: string;
+};
+type TProgressIndicatorComponent = TBaseComponent & {
+    component: "progressIndicator";
+    activeBorderRadius?: number;
+    activeFillColor?: string;
+    activeFillColorFallback?: string;
+    inactiveBorderRadius?: number;
+    inactiveFillColor?: string;
+    inactiveFillColorFallback?: string;
+    percentage?: "auto" | number;
+    innerPadding?: number;
+    activeDropShadow?: string;
+    inactiveDropShadow?: string;
+};
+type TProgressBarComponent = TBaseComponent & {
+    component: "progressBar";
+    mode: "determinate" | "indeterminate";
+    activeBorderRadius?: number;
+    activeFillColor?: string;
+    activeFillColorFallback?: string;
+    inactiveBorderRadius?: number;
+    inactiveFillColor?: string;
+    inactiveFillColorFallback?: string;
+    percentage?: "auto" | number;
+    innerPadding?: number;
+    activeDropShadow?: string;
+    inactiveDropShadow?: string;
+    duration?: "auto" | number;
+    delay?: number;
+    activeWidth?: number | string;
+    screenreaderText?: string;
+};
+type TToggleButtonComponent = TBaseComponent & {
+    component: "toggleButton";
+    components: TComponent[];
+    checked?: boolean;
+    activeFillColor?: string;
+    activeFillColorFallback?: string;
+    inactiveFillColor?: string;
+    inactiveFillColorFallback?: string;
+    activeBorderColor?: string;
+    inactiveBorderColor?: string;
+    activeBorderWidth?: number;
+    inactiveBorderWidth?: number;
+    activeDropShadow?: string;
+    inactiveDropShadow?: string;
+    formId?: string;
+    screenreaderText?: string;
+    screenreaderHint?: string;
+    mode?: "radio" | "toggle";
+    value?: string;
+};
+type TCountdownTimerTextComponent = TBaseComponent & {
+    component: "countdownTimerText";
+    mode?: "duration" | "targetDateTime";
+    durationSeconds?: number;
+    resetOnRemount?: boolean;
+    targetDateTime?: string;
+    separator?: string;
+    zeroPad?: boolean;
+    direction?: "horizontal" | "vertical";
+    labelPosition?: "none" | "top" | "bottom" | "below" | "above";
+    units?: {
+        days?: boolean;
+        hours?: boolean;
+        minutes?: boolean;
+        seconds?: boolean;
+    };
+    labels?: {
+        days?: string;
+        hours?: string;
+        minutes?: string;
+        seconds?: string;
+    };
+    fontSize?: number;
+    fontColor?: string;
+    fontName?: string;
+    labelFontSize?: number;
+    labelFontColor?: string;
+    labelFontName?: string;
+    labelSpacing?: number;
+    showWhenCompleted?: "zero" | "hidden";
+    screenreaderText?: string;
+    screenreaderHint?: string;
+};
+
+type TVariablePattern = `\${var.${string}}`;
+type THeaderFooter = (TContainer | TButtonContainer | TSpacerComponent | TTextComponent | TConditionalComponent)[] | null;
+type Button = TBaseComponent & {
+    id?: string;
+    sku?: NamiSKU;
+    url?: string;
+    components: Array<TTextComponent | TTextListComponent | TSpacerComponent | TImageComponent | TContainer | TConditionalComponent | TSymbolComponent>;
+    screenreaderText?: string;
+    screenreaderHint?: string;
+    text?: string | null;
+    actionTap?: string | null;
+};
+type TButtonContainer = Button & TDisabledButton & {
+    component: "button";
+    focused?: boolean;
+};
+type TDisabledButton = {
+    disabled?: boolean;
+    disabledFillColor?: string;
+    disabledLinkColor?: string;
+    disabledBorderColor?: string;
+    disabledBorderWidth?: number;
+    disabledFontColor?: string;
+    disabledFontSize?: number;
+    disabledDropShadow?: string;
+};
+type TPlayPauseButton = Button & {
+    component: "playPauseButton";
+    pausedOnTap: UserAction;
+    playingOnTap: UserAction;
+    pausedComponents: TComponent[];
+    playingComponents: TComponent[];
+};
+type TVolumeButton = Button & {
+    component: "volumeButton";
+    mutedComponents: TComponent[];
+    volumeComponents: TComponent[];
+    mutedOnTap: UserAction;
+    volumeOnTap: UserAction;
+};
+type UserAction = {
+    function: string;
+    parameters?: UserActionParameters;
+};
+type UserActionParameters = {
+    formId?: string;
+    value?: string;
+    partialState?: Record<string, any>;
+    url?: string;
+    screen?: string;
+    promo?: string;
+    confirmationMessage?: string;
+    confirmBeforePurchase?: TTestObject[];
+};
+type SKUActionHandler = (sku: NamiSKU) => void;
+type DeepLinkUrlHandler = (url: string) => void;
+type CloseHandler = (body?: any) => void;
+type Callback$1 = () => void;
+type CarouselIndicator = {
+    width: number;
+    height: number;
+    borderRadius: number;
+    fillColor: string;
+    component: "container";
+};
+type TCarouselContainer = Omit<TContainer, "component"> & {
+    component: "carouselContainer";
+    indicatorColor: string;
+    activeIndicatorColor: string;
+    autoplay: boolean;
+    autoplaySeconds: number;
+    loopSource?: string | TCarouselSlide[];
+    loopVariable?: string;
+    loopSourceConditions?: TTestObject[];
+    showIndicators?: boolean;
+    inactiveSlideScale?: number;
+    nextSlidePadding?: number;
+    previousSlidePadding?: number;
+    slideSpacing?: number;
+    onChange?: UserAction;
+    indicator?: CarouselIndicator;
+    activeIndicator?: CarouselIndicator;
+};
+type TCarouselSlidesState = {
+    [groupId: string]: {
+        [carouselName: string]: TCarouselSlide[];
+    };
+};
+type TCarouselSlide = {
+    id: string;
+    title?: string;
+    [slideAttr: string]: any;
+};
+type TFlexProductContainer = Omit<TContainer, "component"> & {
+    component: "flexProductContainer";
+    products: "all" | "subset";
+    flexDirection: FlexDirectionObject;
+    subsetGroup?: string;
+    productFeaturedComponents?: TContainer[];
+    productBaseComponents?: TContainer[];
+};
+type FlexDirectionObject = {
+    small: "vertical" | "horizontal";
+    medium: "vertical" | "horizontal";
+    large: "vertical" | "horizontal";
+    xlarge: "vertical" | "horizontal";
+};
+type TProductContainer = Omit<TContainer, "component"> & {
+    component: "productContainer";
+    products: "all" | "subset";
+    subsetGroup?: string;
+    productFeaturedComponents?: TContainer[];
+    productBaseComponents?: TContainer[];
+};
+type TStack = Omit<TContainer, "component"> & {
+    component: "stack";
+};
+type TCollapseContainer = TBaseComponent & {
+    component: "collapseContainer";
+    collapseHeader: TContainer;
+    components: TComponent[];
+    open: "collapse" | "open";
+    backgroundBlur?: number | null;
+};
+type TResponsiveGrid = TBaseComponent & {
+    component: "responsiveGrid";
+    components: any;
+    loopVariable?: string;
+    loopSource?: string;
+    loopSourceConditions: TTestObject[];
+};
+type TToggleSwitch = TBaseComponent & {
+    component: 'toggleSwitch';
+    checked?: boolean;
+    formId: string;
+    innerPadding?: TVariablePattern | number;
+    activeHandleFillColor?: string;
+    activeHandleBorderColor?: string;
+    activeHandleBorderWidth?: number;
+    activePlateFillColor?: string;
+    activePlateBorderColor?: string;
+    activePlateBorderWidth?: number;
+    activePlateBorderRadius?: number;
+    inactiveHandleFillColor?: string;
+    inactiveHandleBorderColor?: string;
+    inactiveHandleBorderWidth?: number;
+    inactivePlateFillColor?: string;
+    inactivePlateBorderColor?: string;
+    inactivePlateBorderWidth?: number;
+    inactivePlateBorderRadius?: number;
+    disabled?: boolean;
+};
+type TRadioButton = TBaseComponent & {
+    component: 'radio';
+    components: TComponent[];
+    active?: boolean;
+    innerPadding?: TVariablePattern | number;
+    activeFillColor?: string;
+    activeBorderColor?: string;
+    activeBorderWidth?: number;
+    activeDropShadow?: string;
+    inactiveFillColor?: string;
+    inactiveBorderColor?: string;
+    inactiveBorderWidth?: number;
+    inactiveDropShadow?: string;
+    sku?: NamiSKU;
+};
+
+interface TBaseComponent {
+    id?: string;
+    title?: string;
+    testId?: string;
+    component: string;
+    namiComponentType?: string;
+    grow?: boolean;
+    flag?: null | string;
+    context?: {
+        [key: string]: any;
+    };
+    moveX?: number | string;
+    moveY?: string | number;
+    direction?: DirectionType;
+    spacing?: number;
+    alignment?: AlignmentType;
+    horizontalAlignment?: AlignmentType;
+    verticalAlignment?: AlignmentType;
+    leftPadding?: number | string;
+    rightPadding?: number | string;
+    topPadding?: number | string;
+    bottomPadding?: number | string;
+    leftMargin?: number | string;
+    rightMargin?: number | string;
+    topMargin?: number | string;
+    bottomMargin?: number | string;
+    fillColor?: string;
+    borderWidth?: number;
+    borderRadius?: number;
+    borderColor?: string;
+    borders?: Array<BorderSideType>;
+    focusedBorders?: Array<BorderSideType>;
+    focusedFillColor?: string;
+    focusedFontColor?: string;
+    focusedBorderColor?: string;
+    focusedBorderWidth?: number;
+    focusedBorderRadius?: number;
+    roundBorders?: Array<BorderLocationType>;
+    focusedRoundBorders?: Array<BorderLocationType>;
+    fillColorFallback?: string;
+    focusedFillColorFallback?: string;
+    zIndex?: number;
+    conditionAttributes?: TConditionalAttributes;
+    height?: number | string;
+    width?: number | string;
+    dropShadow?: string;
+    onTap?: UserAction;
+    actionTap?: string;
+    refId?: string;
+    _fields?: {
+        [attribute: string]: TFieldSettings;
+    } & {
+        _group: string;
+        _label: string;
+        _toggleAttr: string | null;
+        _toggleValue: any;
+        _collapsible: boolean;
+        _hint: string | null;
+    };
+    _fieldGroupLabel?: string;
+    _fieldLabel?: string;
+    _fieldHint?: string;
+    _fieldReadOnly?: boolean;
+    _fieldPlaceholder?: string;
+    _fieldDescription?: string;
+    _fieldOmit?: string[];
+    fixedHeight?: number;
+    fixedWidth?: number | "fitContent";
+    hidden?: boolean;
+    animation?: NamiAnimationSpec;
+}
+type TComponent = TButtonContainer | TContainer | TTextListComponent | TTextComponent | TSpacerComponent | TImageComponent | TSvgImageComponent | TSymbolComponent | TCarouselContainer | TProductContainer | TFlexProductContainer | TStack | TConditionalComponent | TSegmentPicker | TSegmentPickerItem | TVideoComponent | TCollapseContainer | TResponsiveGrid | TVolumeButton | TPlayPauseButton | TQRCodeComponent | TToggleSwitch | TRadioButton | TProgressIndicatorComponent | TToggleButtonComponent | TCountdownTimerTextComponent | TProgressBarComponent;
+type DirectionType = "vertical" | "horizontal";
+type AlignmentType = "center" | "right" | "left" | "top" | "bottom";
+type BorderLocationType = "upperLeft" | "upperRight" | "lowerLeft" | "lowerRight";
+type BorderSideType = 'left' | 'right' | 'top' | 'bottom';
+type TContainerPosition = `${'center' | 'start' | 'end'}-${'top' | 'bottom' | 'left' | 'right'}`;
+declare const BorderMap: Record<BorderLocationType, string>;
+declare const BorderSideMap: Record<BorderSideType, string>;
+type TTestObject = {
+    value: any;
+    expected: any;
+    operator: "equals" | "contains" | "notEquals" | "set" | "notSet" | "notContains" | 'gt' | 'lt' | 'gte' | 'lte';
+};
+type TransformToString<T> = {
+    [P in keyof T]: T[P] extends number | boolean ? T[P] | string : T[P];
+};
+type TConditionalAttributes = Array<Omit<TConditionalComponent, "components"> & {
+    attributes: Partial<TransformToString<TBaseComponent>> & {
+        name?: string;
+        text?: string;
+        texts?: string[];
+        url?: string;
+        fontSize?: number;
+        screenreaderText?: string;
+        fontColor?: string;
+        linkColor?: string;
+    };
+}>;
+type TField = "image" | "listContainerComponent" | "text" | "url" | "textArea" | "fontSelect" | "splitTextArea" | "color" | "colorGradient" | "number" | "alignment" | "carouselSlides" | "option" | "iconSelect" | "toggle";
+type TContainer = TBaseComponent & {
+    component: "container" | "formContainer";
+    position?: TContainerPosition;
+    fillColor?: string;
+    fillImage?: string | null;
+    components?: TComponent[];
+    loopVariable?: string;
+    loopSource?: string | any[];
+    backgroundBlur?: number | null;
+};
+type TFieldSettings = {
+    type: TField;
+    label: string;
+    hint: string | null;
+    description: string | null;
+    placeholder: string | null;
+    variable: string;
+    readOnly: boolean;
+    markdownHint: boolean;
+    options: {
+        label: string;
+        value: any;
+    }[] | null;
+    maxLimit: number | null;
+    minLimit: number | null;
+    aspectRatio: number | null;
+    newSlide?: TCarouselSlide;
+    carousel?: string;
+    darkModeVariable?: string;
+    conditions?: TTestObject[];
+    showOpacity?: boolean;
+    newRow?: any;
+};
+
+interface IConfig {
+    id: string;
+    capabilities: string[];
+    marketplace_app_id?: string | null;
+    campaign_cache_ttl?: number | null;
+}
+type InitialConfig = {
+    appConfig?: IConfig;
+    platform_config?: IConfig;
+    products?: PaywallSKU[];
+    paywalls?: IPaywall[];
+    campaign_rules?: NamiAnonymousCampaign[];
+};
+type InitialConfigCompressed = {
+    initial_config: string;
+};
+declare const isInitialConfigCompressed: (config: InitialConfig | InitialConfigCompressed) => config is InitialConfigCompressed;
+type NamiConfigurationState = {
+    sdkInitialized: boolean;
+    configureState: string;
+};
+type ExtendedPlatformInfo = {
+    platform: string;
+    version: string;
+};
+declare enum Capabilities {
+    SDK = "sdk",
+    ML = "ml",
+    THIRD_PARTY_ANALYTICS = "third_party_analytics",
+    THIRD_PARTY_TRANSACTIONS = "third_party_transactions",
+    PAYWALL_PERSONALIZATION = "paywall_personalization",
+    ANONYMOUS_MODE_CAPABILITY = "anonymous_allowed",
+    LANGUAGE_MANAGEMENT = "language_management",
+    ENTITLEMENT_MANAGEMENT = "entitlement_management"
+}
+
+/**
+ * @type NamiLanguageCodes
+ * Languages supported by Nami paywalls
+ */
+type NamiLanguageCodes = 
+/** Language Afrikaans **/
+"af"
+/** Language Arabic **/
+ | "ar"
+/** Language Algerian **/
+ | "ar-dz"
+/** Language Asturian **/
+ | "ast"
+/** Language Azerbaijani **/
+ | "az"
+/** Language Bulgarian **/
+ | "bg"
+/** Language Belarusian **/
+ | "be"
+/** Language Bengali **/
+ | "bn"
+/** Language Breton **/
+ | "br"
+/** Language Bosnian **/
+ | "bs"
+/** Language Catalan **/
+ | "ca"
+/** Language Czech **/
+ | "cs"
+/** Language Welsh **/
+ | "cy"
+/** Language Danish **/
+ | "da"
+/** Language German **/
+ | "de"
+/** Language Lower Sorbian **/
+ | "dsb"
+/** Language Greek **/
+ | "el"
+/** Language English **/
+ | "en"
+/** Language Australian English **/
+ | "en-au"
+/** Language British English **/
+ | "en-gb"
+/** Language Esperanto **/
+ | "eo"
+/** Language Spanish **/
+ | "es"
+/** Language Argentinian Spanish **/
+ | "es-ar"
+/** Language Colombian Spanish **/
+ | "es-co"
+/** Language Mexican Spanish **/
+ | "es-mx"
+/** Language Nicaraguan Spanish **/
+ | "es-ni"
+/** Language Venezuelan Spanish **/
+ | "es-ve"
+/** Language Estonian **/
+ | "et"
+/** Language Basque **/
+ | "eu"
+/** Language Persian **/
+ | "fa"
+/** Language Finnish **/
+ | "fi"
+/** Language French **/
+ | "fr"
+/** Language Frisian **/
+ | "fy"
+/** Language Irish **/
+ | "ga"
+/** Language Scottish Gaelic **/
+ | "gd"
+/** Language Galician **/
+ | "gl"
+/** Language Hebrew **/
+ | "he"
+/** Language Hindi **/
+ | "hi"
+/** Language Croatian **/
+ | "hr"
+/** Language Upper Sorbian **/
+ | "hsb"
+/** Language Hungarian **/
+ | "hu"
+/** Language Armenian **/
+ | "hy"
+/** Language Interlingua **/
+ | "ia"
+/** Language Indonesian **/
+ | "id"
+/** Language Igbo **/
+ | "ig"
+/** Language Ido **/
+ | "io"
+/** Language Icelandic **/
+ | "is"
+/** Language Italian **/
+ | "it"
+/** Language Japanese **/
+ | "ja"
+/** Language Georgian **/
+ | "ka"
+/** Language Kabyle **/
+ | "kab"
+/** Language Kazakh **/
+ | "kk"
+/** Language Khmer **/
+ | "km"
+/** Language Kannada **/
+ | "kn"
+/** Language Korean **/
+ | "ko"
+/** Language Kyrgyz **/
+ | "ky"
+/** Language Luxembourgish **/
+ | "lb"
+/** Language Lithuanian **/
+ | "lt"
+/** Language Latvian **/
+ | "lv"
+/** Language Macedonian **/
+ | "mk"
+/** Language Malayalam **/
+ | "ml"
+/** Language Mongolian **/
+ | "mn"
+/** Language Marathi **/
+ | "mr"
+/** Language Burmese **/
+ | "my"
+/** Language Norwegian Bokmål **/
+ | "nb"
+/** Language Nepali **/
+ | "ne"
+/** Language Dutch **/
+ | "nl"
+/** Language Norwegian Nynorsk **/
+ | "nn"
+/** Language Ossetic **/
+ | "os"
+/** Language Punjabi **/
+ | "pa"
+/** Language Polish **/
+ | "pl"
+/** Language Portuguese **/
+ | "pt"
+/** Language Brazilian Portuguese **/
+ | "pt-br"
+/** Language Romanian **/
+ | "ro"
+/** Language Russian **/
+ | "ru"
+/** Language Slovak **/
+ | "sk"
+/** Language Slovenian **/
+ | "sl"
+/** Language Albanian **/
+ | "sq"
+/** Language Serbian **/
+ | "sr"
+/** Language Serbian Latin **/
+ | "sr-latn"
+/** Language Swedish **/
+ | "sv"
+/** Language Swahili **/
+ | "sw"
+/** Language Tamil **/
+ | "ta"
+/** Language Telugu **/
+ | "te"
+/** Language Tajik **/
+ | "tg"
+/** Language Thai **/
+ | "th"
+/** Language Turkmen **/
+ | "tk"
+/** Language Turkish **/
+ | "tr"
+/** Language Tatar **/
+ | "tt"
+/** Language Udmurt **/
+ | "udm"
+/** Language Ukrainian **/
+ | "uk"
+/** Language Urdu **/
+ | "ur"
+/** Language Uzbek **/
+ | "uz"
+/** Language Vietnamese **/
+ | "vi"
+/** Language Simplified Chinese **/
+ | "zh-hans"
+/** Language Traditional Chinese **/
+ | "zh-hant";
+
+/**
+ * Set the level of logs to print while running the SDK
+ */
+type NamiLogLevel = "error" | "warn" | "info" | "debug";
+declare enum LogLevel {
+    DEBUG = 1,
+    INFO = 2,
+    WARN = 3,
+    ERROR = 4
+}
+
+/**
+ * @type NamiInitialConfig
+ *
+ * Defines the structure of the initial configuration that can be provided
+ * when setting up the Nami SDK.
+ */
+type NamiInitialConfig = InitialConfig | InitialConfigCompressed;
+/**
+ * @type NamiConfiguration
+ * This is needed to configure and initialize the SDK via [Nami.configure]
+ * method
+ *
+ * @param appPlatformID A UUID for the app. You can find the Nami App Platform ID in the App
+ * Settings screen on the Platforms tab in the Nami Control Center.
+ * @param logLevel Optional preferable [NamiLogLevel] to set within SDK to get appropriate
+ * logging information. Make sure to either not set this param in release build, or set
+ * to [NamiLogLevel.ERROR] if you would like Nami error logs to be shown in your release/production
+ * app build. Default is set to [NamiLogLevel.WARN]
+ * @param namiCommands provides set of external commands useful for SDK.
+ * @param initialConfig contains initial configuration, useful in offline mode.
+ * @param namiLanguageCode sets the language to be used for paywalls on the device. Select from
+ * [NamiLanguageCode]
+ * <p>
+ * Default is set to `false`. Note that this should be set to `true` only from `debug` or
+ * `non-production` version of the app. Setting this to `true` in a `production` build can
+ * potentially have unwanted consequences.
+ */
+type NamiConfiguration = {
+    appPlatformID: string;
+    logLevel?: NamiLogLevel;
+    namiCommands?: string[];
+    namiLanguageCode?: NamiLanguageCodes;
+    initialConfig?: string | NamiInitialConfig;
+    formFactor?: string;
+    purchaseChannel?: string;
+    /** Enable verbose flow lifecycle logging. Debug-only; do not ship in production. */
+    maxLogging?: boolean;
+};
+
+/**
+ * @enum NamiPaywallAction
+ * Types of actions paywall will have
+ */
+declare enum NamiPaywallAction {
+    BUY_SKU = "BUY_SKU",
+    SELECT_SKU = "SELECT_SKU",
+    RESTORE_PURCHASES = "RESTORE_PURCHASES",
+    SIGN_IN = "SIGN_IN",
+    CLOSE_PAYWALL = "CLOSE_PAYWALL",
+    SHOW_PAYWALL = "SHOW_PAYWALL",
+    PURCHASE_SELECTED_SKU = "PURCHASE_SELECTED_SKU",
+    PURCHASE_SUCCESS = "PURCHASE_SUCCESS",
+    PURCHASE_FAILED = "PURCHASE_FAILED",
+    PURCHASE_CANCELLED = "PURCHASE_CANCELLED",
+    PURCHASE_PENDING = "PURCHASE_PENDING",
+    PURCHASE_UNKNOWN = "PURCHASE_UNKNOWN",
+    PURCHASE_DEFERRED = "PURCHASE_DEFERRED",
+    DEEPLINK = "DEEPLINK",
+    TOGGLE_CHANGE = "TOGGLE_CHANGE",
+    PAGE_CHANGE = "PAGE_CHANGE",
+    SLIDE_CHANGE = "SLIDE_CHANGE",
+    COLLAPSIBLE_DRAWER_OPEN = "COLLAPSIBLE_DRAWER_OPEN",
+    COLLAPSIBLE_DRAWER_CLOSE = "COLLAPSIBLE_DRAWER_CLOSE",
+    VIDEO_STARTED = "VIDEO_STARTED",
+    VIDEO_PAUSED = "VIDEO_PAUSED",
+    VIDEO_RESUMED = "VIDEO_RESUMED",
+    VIDEO_ENDED = "VIDEO_ENDED",
+    VIDEO_CHANGED = "VIDEO_CHANGED",
+    VIDEO_MUTED = "VIDEO_MUTED",
+    VIDEO_UNMUTED = "VIDEO_UNMUTED",
+    COUNTDOWN_TIMER_COMPLETED = "COUNTDOWN_TIMER_COMPLETED",
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * @type NamiPaywallEvent
+ * Represents the events(actions) triggered by rendered paywall
+ */
+type NamiPaywallEvent = {
+    /**
+     * Any action from [NamiPaywallAction]
+     */
+    action: NamiPaywallAction;
+    sku?: NamiSKU;
+    campaignId?: string;
+    campaignName?: string;
+    campaignType?: string;
+    campaignLabel?: string;
+    campaignUrl?: string;
+    paywallId?: string;
+    paywallName?: string;
+    componentChange?: NamiPaywallComponentChange;
+    /**
+     * segment from [NamiCampaign]
+     */
+    segmentId?: string;
+    /**
+     * external_segment from [NamiCampaign]
+     */
+    externalSegmentId: string | null;
+    deeplinkUrl?: string;
+    purchaseError?: string;
+    purchases?: NamiPurchase[];
+    /**
+     * Total time user has spent on paywall page,
+     * From rendering paywall to clicking on close button of paywall
+     */
+    timeSpentOnPaywall?: number;
+    videoMetaData?: NamiPaywallEventVideoMetadata;
+    purchaseChannel?: string;
+};
+type NamiPaywallActionHandler = (event: NamiPaywallEvent) => void;
+/**
+ * @type NamiPaywallLaunchContext
+ * Will be used to pass custom context while launching paywall
+ */
+type NamiPaywallLaunchContext = {
+    productGroups?: string[];
+    customAttributes: {
+        [key: string]: string;
+    };
+    customObject?: {
+        [key: string]: any;
+    };
+    currentGroup?: string;
+};
+/**
+ * @type NamiPaywallComponentChange
+ */
+type NamiPaywallComponentChange = {
+    id?: string;
+    name?: string;
+};
+/**
+ * @type NamiPaywallEventVideoMetadata
+ */
+type NamiPaywallEventVideoMetadata = {
+    id?: string;
+    name?: string;
+    url?: string;
+    loopVideo: boolean;
+    muteByDefault: boolean;
+    autoplayVideo: boolean;
+    contentTimecode?: number;
+    contentDuration?: number;
+};
+
+/**
+ * @type NamiEntitlement
+ * Represents what features a device has access to in an app.
+ */
+type NamiEntitlement$1 = {
+    /**
+     * The last known Purchase that unlocked this entitlement. There must be a corresponding
+     * NamiSKU associated to this NamiPurchase. That NamiSKU must reside in purchasedSKUs.
+     */
+    activePurchases: NamiPurchase[];
+    /**
+     * Description of entitlement
+     */
+    desc: string;
+    /**
+     * Friendly name of entitlement
+     */
+    name: string;
+    /**
+     * Internal ID for use by the Nami SDK
+     */
+    namiId: string;
+    /**
+     * NamiSKUs purchased by the user that actually unlock this entitlement
+     */
+    purchasedSkus: NamiSKU[];
+    /**
+     * The unique ID of the entitlement defined in the Nami Control Center, use this to refer
+     * to the system when referencing an entitlement.
+     */
+    referenceId: string;
+    /**
+     * The list of possible NamiSKU objects that would unlock this entitlement
+     */
+    relatedSkus: NamiSKU[];
+};
+
+declare enum LaunchCampaignError {
+    DEFAULT_CAMPAIGN_NOT_FOUND = "Default campaign not found",
+    LABELED_CAMPAIGN_NOT_FOUND = "Labeled campaign not found",
+    CAMPAIGN_DATA_NOT_FOUND = "Campaign data not found",
+    PAYWALL_ALREADY_DISPLAYED = "Paywall is already being displayed",
+    SDK_NOT_INITIALIZED = "SDK has not been initialized",
+    PAYWALL_COULD_NOT_DISPLAY = "Failed to display paywall",
+    URL_CAMPAIGN_NOT_FOUND = "URL campaign not found",
+    PRODUCT_DATA_NOT_FOUND = "Product data not found",
+    PRODUCT_GROUPS_NOT_FOUND = "Product groups not found",
+    FLOW_SCREEN_DATA_UNAVILABLE = "Flow unavailable due to missing screen data"
+}
+
+/**
+ * This data class represents a customer's subscription journey state
+ */
+type CustomerJourneyState = {
+    former_subscriber: boolean;
+    in_grace_period: boolean;
+    in_trial_period: boolean;
+    in_intro_offer_period: boolean;
+    is_cancelled: boolean;
+    in_pause: boolean;
+    in_account_hold: boolean;
+};
+/**
+ * This data class represents a device's profile
+ */
+type DeviceProfile = {
+    customer_journey_state: CustomerJourneyState;
+};
+
+declare class BasicNamiFlow implements NamiFlowObjectDTO {
+    id: string;
+    name: string;
+    steps: NamiFlowStep[];
+    screens: string[];
+    resumeFromBookmark: boolean;
+    transition: NamiFlowTransition;
+    constructor(flowObject?: Partial<{
+        id: string;
+        name: string;
+        steps: NamiFlowStep[];
+        screens: string[];
+        resume_from_bookmark: boolean;
+        transition?: NamiFlowTransition;
+    }>);
+    get allScreensAvailable(): boolean;
+}
+declare class NamiFlow extends BasicNamiFlow {
+    campaign?: NamiCampaign;
+    context?: NamiPaywallLaunchContext;
+    stepcrumbs: NamiFlowStep[];
+    branchcrumbs: string[];
+    component: PaywallHandle;
+    manager: NamiFlowManager;
+    currentButton?: any;
+    activeHandoffSequence: {
+        formStates: Record<string, boolean | string>;
+        remainingKeys: string[];
+    } | null;
+    currentScreenState: TPaywallContext | null;
+    isPaused: boolean;
+    pausedStepID?: string;
+    timerStates: {
+        [timerId: string]: TimerState;
+    };
+    constructor(campaign: NamiFlowCampaign, paywall: PaywallHandle, manager: NamiFlowManager, context?: NamiPaywallLaunchContext);
+    private registerResolvers;
+    get currentFlowStep(): NamiFlowStep | undefined;
+    get nextStepAvailable(): boolean;
+    get previousStepAvailable(): boolean;
+    get previousFlowStep(): NamiFlowStep | undefined;
+    get nextFlowStep(): NamiFlowStep | undefined;
+    getStep(stepId: string): NamiFlowStep | undefined;
+    private findStepByType;
+    private isStepActive;
+    private flowLog;
+    finished(): void;
+    back(): void;
+    next(): void;
+    private backToPreviousScreenStep;
+    forward(stepId: string): void;
+    pause(): void;
+    resumeFromPause(): void;
+    executeLifecycle(step: NamiFlowStep, key: string, data?: Record<string, any>): void;
+    private lifecycles;
+    triggerActions(actionId: string, component?: any, data?: Record<string, any>): void;
+    executeFullLifecycles(lifecycles: NamiFlowOn[], data?: Record<string, any>): void;
+    triggerBeforeActions(actionId: string, component?: any, data?: Record<string, any>): void;
+    triggerAfterActions(actionId: string, component?: any, data?: Record<string, any>): void;
+    currentStepHasHoistedPrimaryActions(actionId: string): boolean;
+    private shouldRun;
+    private performAction;
+    private nextStep;
+    private handleScreenStep;
+    private handleBranchStep;
+    getFormData(): Record<string, boolean | string>;
+    flowHandoffFormSequence(): void;
+    resumeNextHandoff(): void;
+}
+
+declare class NamiFlowManager {
+    private static _instance;
+    static get instance(): NamiFlowManager;
+    currentFlow?: NamiFlow;
+    flowOpen: boolean;
+    private lastAnimatedFlowProgress;
+    private navGraphCache;
+    private constructor();
+    handoffStepHandler?: NamiFlowHandoffStepHandler;
+    static registerStepHandoff(handoffStepHandler?: NamiFlowHandoffStepHandler): void;
+    eventHandler?: NamiFlowEventHandler;
+    static registerEventHandler(eventHandler: NamiFlowEventHandler): void;
+    static resume(): void;
+    resume(): void;
+    static finish(): void;
+    static pause(): void;
+    static isFlowOpen(): boolean;
+    presentFlow(campaign: NamiFlowCampaign, paywall: PaywallHandle, context?: NamiPaywallLaunchContext): NamiFlow;
+    finishFlow(): void;
+    /**
+     * Gets the last animated progress for a component by ID
+     * @param key Component ID
+     * @returns Last animated progress value (0-1), or 0 if not found
+     */
+    getLastAnimatedFlowProgress(key: string): number;
+    /**
+     * Sets the last animated progress for a component by ID
+     * Only stores if there's an active flow
+     * @param key Component ID
+     * @param value Progress value (0-1)
+     */
+    setLastAnimatedFlowProgress(key: string, value: number): void;
+    /**
+     * Gets the current flow progress based on screen steps
+     * @param key Component ID (for compatibility)
+     * @returns Progress as a percentage (0-1)
+     */
+    getCurrentFlowProgress(key?: string): number;
+    /**
+     * Find the first screen that has branching (multiple forward navigation targets)
+     */
+    private findBranchPoint;
+    /**
+     * Calculate progress for flows with branching (supports 2+ branches)
+     */
+    private calculateBranchingProgress;
+    /**
+     * Count how many screens are forward-reachable from the current step
+     * Only counts screens with higher indices (true forward navigation)
+     */
+    private countForwardScreens;
+    /**
+     * Checks if a screen has branching navigation (2 or more forward targets)
+     * Supports any number of branches: 2, 3, 4, etc.
+     */
+    private hasBranching;
+    /**
+     * Build navigation graph from flow steps
+     * Maps each step ID to its possible navigation targets
+     */
+    private buildNavGraph;
+    static getLastAnimatedFlowProgress(key: string): number;
+    static setLastAnimatedFlowProgress(key: string, value: number): void;
+    static getCurrentFlowProgress(key?: string): number;
+    /**
+     * Gets the current flow step's auto-advance delay (in seconds)
+     * Parses __appear__ actions to find flowNav/flowNext with a delay parameter
+     * @returns Delay in seconds, or null if not auto-advancing
+     */
+    getCurrentFlowStepAutoAdvanceDelay(): number | null;
+    static getCurrentFlowStepAutoAdvanceDelay(): number | null;
+}
+
+type NamiPurchaseSource = 'CAMPAIGN' | 'MARKETPLACE' | 'UNKNOWN';
+type TransactionRequest = {
+    quantity?: string;
+    currency?: string;
+    purchase_env: string;
+    amount?: number;
+    impression: string;
+    session?: string;
+    original_transaction_id?: string;
+    transaction_id: string;
+    source?: string;
+    sku: string;
+    localized_description?: string;
+    subscription_interval?: string;
+    subscription_interval_count?: number;
+    purchase_date?: string;
+    original_purchase_date?: string;
+    app_env: string;
+};
+type PurchaseValidationRequest = {
+    app_env: string;
+    payload: string;
+    sku: string;
+};
+type NamiPurchaseCompleteResult = {
+    success: boolean;
+    billingResponseCode?: number;
+    message?: string;
+    purchase?: NamiPurchase;
+};
+
+/**
+ * @type NamiPurchase
+ * This object represents a completed purchase in the SDK. A device purchases a NamiSKU and that
+ * purchase makes available a set of NamiEntitlements
+ */
+type NamiPurchase = {
+    sku?: NamiSKU;
+    /**
+     * The store sku reference identifier for this NamiPurchase
+     */
+    skuId: string;
+    /**
+     * The purchase order ID record or receipt ID associated to this purchase
+     */
+    transactionIdentifier?: string;
+    /**
+     * For bypass store purchases only, indicates when this purchase will cease to back
+     * an entitlement rendering it as inactive.
+     */
+    expires?: Date;
+    /**
+     * The source a purchase comes from - either on Google Play (marketplace), through a paywall (campaign).
+     */
+    purchaseToken?: string;
+    /**
+     * The date and time when the purchase was initiated
+     */
+    purchaseInitiatedTimestamp?: Date;
+    /**
+     * The source a purchase comes from - either on Google Play (marketplace), through a paywall (campaign).
+     */
+    purchaseSource?: NamiPurchaseSource;
+};
+type NamiPurchasesState = 'pending' | 'purchased' | 'consumed' | 'resubscribed' | 'unsubscribed' | 'deferred' | 'failed' | 'cancelled' | 'unknown';
+type NamiPurchaseDetails = {
+    skuId: string;
+    transactionId: string;
+    amount?: number;
+    currency?: string;
+};
+
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+
+type NamiPresentationStyle = 'fullscreen' | 'sheet' | 'compact_sheet' | 'modal';
+declare function getEffectiveWebStyle(style: NamiPresentationStyle | undefined | null): NamiPresentationStyle;
+type TPaywallContext = TInitialState & {
+    paywallId: string;
+    livePaywalls: IPaywall[];
+    selectedPaywall?: IPaywall;
+    selectedCampaign?: NamiCampaign;
+    campaignRules: NamiCampaign[];
+    anySkuHasTrialOffer: boolean;
+    anySkuHasIntroOffer: boolean;
+    anySkuHasPromoOffer: boolean;
+    safeAreaTop: number;
+    slides?: TCarouselSlidesState;
+    currentPage: string;
+    fullScreenPresentation?: boolean;
+    isLoggedIn?: boolean;
+    darkMode?: boolean;
+    orientation: TDeviceOrientation;
+    focusedState: boolean;
+    platformId: string;
+    mediaList: {
+        [key: string]: any;
+    };
+    customer: {
+        [key: string]: any;
+    };
+    hasNotch: boolean;
+    skuItems: PaywallSKU[];
+    groups: {
+        id: string;
+        displayName: string;
+        ref: string;
+    }[];
+    currentGroupId: string;
+    formStates: {
+        [formId: string]: boolean | string;
+    };
+    timerStates: {
+        [timerId: string]: TimerState;
+    };
+    selectedProducts: {
+        [currentGroupId: string]: string | null;
+    };
+    launch: TPaywallLaunchContext;
+    sku: {
+        [key: string]: any;
+    };
+    purchaseInProgress: boolean;
+    productBeingPurchased?: NamiSKU;
+    timeSpentOnPaywall?: number;
+    userInteractionEnabled?: boolean;
+};
+type TimerState = {
+    remainingSeconds: number;
+    savedAt: number;
+    hasEmittedCompletion: boolean;
+};
+type TPaywallLaunchContext = Required<NamiPaywallLaunchContext>;
+type ProductGroup = {
+    id: string;
+    products: PaywallSKU[];
+    ref: string;
+};
+interface IPaywall {
+    id: string;
+    name: string;
+    paywall_type: string;
+    sku_menus: ISkuMenu[];
+    template: TPaywallTemplate;
+    fonts: FontCollection;
+}
+interface ISkuMenu {
+    id: string;
+    name: string;
+    display_name: string;
+    ref: string;
+    products: PaywallSKU[];
+}
+interface IEntitlements$1 {
+    id: string;
+    entitlement_ref_id: string;
+    name: string;
+    description: string | null;
+    type: string;
+}
+interface IProductsWithComponents extends PaywallSKU {
+    components: TComponent;
+}
+type FontCollection = {
+    [fontName: string]: FontDetails;
+};
+type FontDetails = {
+    id: string;
+    family: string;
+    style: string;
+    file: string;
+};
+type TPaywallTemplate = {
+    id: string;
+    orgs?: string | null;
+    org_id?: string | null;
+    changelog?: string;
+    userHasAccess?: boolean;
+    media?: {
+        [key: string]: string;
+    };
+    pages: TPages[];
+    ready?: boolean;
+    version: string | number;
+    codename: string;
+    doc_link: string;
+    thumbnail?: string;
+    skuContexts?: {
+        [skuId: string]: {
+            [key: string]: any;
+        };
+    };
+    initialState: TInitialState;
+    min_sdk_version: string;
+    capabilities?: string[];
+    displaySingleGroup?: boolean;
+};
+type TPages = {
+    name: string;
+    header: THeaderFooter;
+    contentContainer: TContainer | null;
+    footer: THeaderFooter;
+    backgroundContainer: TContainer | null;
+};
+type TInitialState = {
+    slides?: TCarouselSlidesState;
+    currentPage: string;
+    fullScreenPresentation?: boolean;
+    isLoggedIn?: boolean;
+    presentationStyle?: NamiPresentationStyle;
+    presentation_style?: NamiPresentationStyle;
+    [key: string]: any;
+    groups: InitiateStateGroup[];
+    currentGroupId: string;
+    selectedProducts: {
+        [currentGroupId: string]: string | null;
+    };
+};
+type InitiateStateGroup = {
+    id: string;
+    displayName: string;
+    ref: string;
+};
+type TPaywallMedia = {
+    id: string;
+    content: string | null;
+    paywall: string;
+    name: string;
+};
+type TProductGroup = {
+    id: string;
+    display_name: string;
+    display_order: number;
+    default: boolean;
+    paywall: string;
+    ref: string;
+};
+type TMediaTypes = {
+    [name: string]: Optional<TPaywallMedia, 'id'>;
+};
+type TOffer = {
+    freeTrialEligible: boolean;
+    introEligible: boolean;
+    promoEligible: boolean;
+};
+declare enum PaywallManagerEvents {
+    BuySku = "RegisterBuySKU",
+    Close = "PaywallCloseRequested",
+    SignIn = "PaywallSignInRequested",
+    Restore = "PaywallRestoreRequested",
+    DeeplinkAction = "PaywallDeeplinkAction"
+}
+type PaywallActionEvent = {
+    action: NamiPaywallAction;
+    sku?: NamiSKU;
+    videoMetaData: NamiPaywallEventVideoMetadata;
+    timeSpentOnPaywall?: number;
+    componentChange?: NamiPaywallComponentChange;
+    purchaseError?: string;
+    purchases?: NamiPurchase[];
+};
+type PaywallResultHandler = (success: boolean, error?: LaunchCampaignError) => void;
+type NamiAppSuppliedVideoDetails = {
+    url: string;
+    name?: string;
+};
+
+interface FlowNavigationOptions {
+    transition: string;
+    direction: 'forward' | 'backward';
+}
+/**
+ * Opaque handle representing a platform-specific paywall instance.
+ * Web: PaywallComponent (HTMLElement)
+ * RN: A navigation/view handle
+ */
+type PaywallHandle = unknown;
+/**
+ * Platform-agnostic UI operations interface.
+ * Web: DOM-based Lit components
+ * React Native: React Native views + navigation
+ */
+interface IUIAdapter {
+    createPaywall(type: string | undefined, value: string, context: NamiPaywallLaunchContext): PaywallHandle;
+    reRenderPaywall(): void;
+    flowNavigateToScreen(paywall: IPaywall, options: FlowNavigationOptions): void;
+    /** Called after SDK configuration completes — used for platform-specific post-init setup */
+    postConfigure?(): void;
+}
+
+interface IPlatformAdapters {
+    storage: IStorageAdapter;
+    device: IDeviceAdapter;
+    ui: IUIAdapter;
+}
+declare function registerPlatformAdapters(adapters: IPlatformAdapters): void;
+declare function getPlatformAdapters(): IPlatformAdapters;
+
+declare class Nami {
+    #private;
+    static instance: Nami;
+    maxLogging: boolean;
+    get isInitialized(): boolean;
+    static sdkVersion(): string;
+    static sdkPackageVersion(): string;
+    /**
+     * Configures and initializes the SDK.
+     * This method must be called as the first thing before interacting with the SDK.
+     * @param with A [NamiConfiguration] object with required values
+     * @returns {Promise<NamiConfigurationState>}
+     */
+    static configure(options: NamiConfiguration): Promise<NamiConfigurationState>;
+    private static setInitialConfig;
+    private initializeSDK;
+}
+
+/**
+ * @class NamiCampaignManager
+ * Provides methods for managing all aspects of a campaign.
+ */
+declare class NamiCampaignManager {
+    static instance: NamiCampaignManager;
+    private emitter;
+    /**
+     * @returns {NamiCampaign[]} A list of NamiCampaign
+     */
+    static allCampaigns(): NamiCampaign[];
+    /**
+     * Checks if a campaign is available for a given argument.
+     * The argument can be a label string, or a deeplink URL.
+     *
+     * @param label - The argument to check. Can be a label string, or a deeplink URL.
+     * @returns {boolean} True if the campaign is available, False otherwise.
+     */
+    static isCampaignAvailable(label: string): boolean;
+    /**
+     * Checks if a campaign is a Flow campaign for a given argument.
+     * The argument can be a label string, or a deeplink URL.
+     *
+     * @param label - The label of the campaign to check. Can be a label string.
+     * @param withUrl - The deeplink URL of the campaign to check.
+     * @returns {boolean} True if the campaign is a Flow campaign, False otherwise.
+     */
+    static isFlow(label?: string, withUrl?: string): boolean;
+    /**
+     * Fetches the latest active campaigns for the current device.
+     *
+     * @returns {Promise<NamiCampaign[]>} A promise that resolves to a list of active campaigns.
+     */
+    static refresh(): Promise<NamiCampaign[]>;
+    /**
+     * Registers a handler that will be called whenever there is an update
+     * in the list of active campaigns. The Nami SDK will trigger this callback
+     * with the updated list of active campaigns.
+     *
+     * The handler will receive an array of `NamiCampaign` objects representing
+     * the current active campaigns.
+     *
+     * @param {AvailableCampaignsResponseHandler} handler - The callback function that will be invoked when the campaign list is updated.
+     * @returns {Callback} A function that can be called to unregister the handler.
+     */
+    static registerAvailableCampaignsHandler(handler: AvailableCampaignsResponseHandler): Callback$1;
+    /**
+     * Launches a campaign with a given label.
+     * @param label - The label of the campaign to launch.
+     * @param withUrl - The deeplink URL of the campaign to launch.
+     * @param actionCallback - Optional handler for paywall actions.
+     * @returns {PaywallHandle | void} The launched paywall handle (platform-specific).
+     */
+    static launch(label?: string, withUrl?: string, context?: NamiPaywallLaunchContext, resultCallback?: PaywallResultHandler, actionCallback?: NamiPaywallActionHandler): PaywallHandle;
+    /**
+      * Provide the list of product groups supported by the provided placement label or URL.
+      * @param label Campaign placement label defined in Nami Control Center for launching a specific campaign.
+      * @param uri Campaign placement URI defined in Nami Control Center for launching a specific campaign.
+      * @return List of product groups associated with the specified campaign placement.
+      */
+    static getProductGroups(label?: string, withUrl?: string): string[];
+    /**
+     * Get all product SKUs associated with the provided placement label or URL.
+     * @param label Campaign placement label defined in Nami Control Center for launching a specific campaign.
+     * @param withUrl Campaign placement URI defined in Nami Control Center for launching a specific campaign.
+     * @returns List of product SKUs associated with the specified campaign placement.
+     */
+    static getAllProducts(label?: string, withUrl?: string): string[];
+    /**
+     * Get the list of currently active product SKUs associated with the provided placement label or URL.
+     * @param label Campaign placement label defined in Nami Control Center for launching a specific campaign.
+     * @param withUrl Campaign placement URI defined in Nami Control Center for launching a specific campaign.
+     * @returns List of current product SKUs associated with the specified campaign placement.
+     */
+    static getCurrentProducts(label?: string, withUrl?: string): string[];
+    /**
+     * Private Instance Methods
+     */
+    private get sdkInitialized();
+    private campaignTypeAndLabel;
+}
+
+type NamiProfile = {
+    externalId: string;
+};
+/**
+ * Represents the possible account actions states that can be returned by callback registered from
+ * [NamiCustomerManager.registerAccountStateHandler]
+ */
+declare enum AccountStateAction {
+    LOGIN = "login",
+    LOGOUT = "logout",
+    ADVERTISING_ID_SET = "advertising_id_set",
+    ADVERTISING_ID_CLEARED = "advertising_id_cleared",
+    VENDOR_ID_SET = "vendor_id_set",
+    VENDOR_ID_CLEARED = "vendor_id_cleared",
+    CUSTOMER_DATA_PLATFORM_ID_SET = "customer_data_platform_id_set",
+    CUSTOMER_DATA_PLATFORM_ID_CLEARED = "customer_data_platform_id_cleared",
+    ANONYMOUS_MODE_ON = "anonymous_mode_on",
+    ANONYMOUS_MODE_OFF = "anonymous_mode_off",
+    NAMI_DEVICE_ID_SET = "nami_device_id_set",
+    NAMI_DEVICE_ID_CLEARED = "nami_device_id_cleared"
+}
+
+type NamiCustomerJourneyStateHandler = (customerJourneyState: CustomerJourneyState) => void;
+
+type AccountStateHandler = (action: AccountStateAction, success: boolean, error?: Error) => void;
+/**
+ * @class NamiCustomerManager
+ * Provides methods for managing customer-related functionality.
+ */
+declare class NamiCustomerManager {
+    static instance: NamiCustomerManager;
+    private emitter;
+    constructor();
+    /**
+     * Checks if the customer is logged in.
+     *
+     * @returns {boolean} Returns true if the customer is logged in, false otherwise.
+     */
+    static isLoggedIn(): boolean;
+    /**
+     * Returns the external ID of the currently logged in user.
+     *
+     * @returns {string | undefined} The external ID of the logged in user.
+    */
+    static loggedInId(): string | undefined;
+    /**
+     * Logs in a customer with the specified ID.
+     *
+     * @param id - The ID of the customer to log in. Must be a SHA256 hash or UUID.
+     * @returns {Promise<void>} A Promise that resolves when the login is successful.
+    */
+    static login(externalId: string): Promise<void>;
+    /**
+     * This method detaches the whole platform account from the signed in user
+     * @returns {Promise<void>} A Promise that resolves when the logout is successful.
+     */
+    static logout(): Promise<void>;
+    /**
+     * This method for connecting the device to a Customer Data Platform identifier
+     *
+     * Advanced use case. Make sure you have user consent.
+     *
+     * @param id a value supplied from your CDP platform
+     * @returns {Promise<void>} A Promise that resolves when CustomerDataPlatformId will be set.
+     */
+    static setCustomerDataPlatformId(id: string): Promise<void>;
+    /**
+     * This method for clearing the Customer Data Platform identifier linked to this device
+     *
+     * Advanced use case.
+     * @returns {Promise<void>} A Promise that resolves when CustomerDataPlatformId will be cleared.
+     */
+    static clearCustomerDataPlatformId(): Promise<void>;
+    /**
+     * Registers a callback function to handle changes in the account state.
+     *
+     * @param callback - The callback function to be registered.
+     * @returns {Callback} A function that can be used to unregister the original callback.
+     */
+    static registerAccountStateHandler(handler: AccountStateHandler): Callback$1;
+    /**
+     * Sets the anonymous mode for the customer.
+     *
+     * @param enabled - A boolean value indicating whether the anonymous mode should be enabled or disabled.
+     * @returns {Promise<void>} A Promise that resolves when the anonymous mode is set.
+     */
+    static setAnonymousMode(enabled: boolean): Promise<void>;
+    /**
+     * @returns {boolean} whether or not the SDK is currently operating in anonymous mode
+     */
+    static inAnonymousMode(): boolean;
+    /**
+     * Sets an optional customer attributes that can be used to personalize your Nami paywalls.
+     *
+     * @param key - The name of the attribute. For example: `firstName`.
+     * @param value - The value of the customer attribute. For example: `Joe`.
+     */
+    static setCustomerAttribute(key: string, value: string): void;
+    /**
+     * Retrieves the value for a given key in the on-device customer attribute key/value store.
+     *
+     * @param key - The name of the attribute. For example: `firstName`
+     * @returns {string | null} The value of the customer attribute.
+     */
+    static getCustomerAttribute(key: string): string | null;
+    /**
+    * Retrieves all the customer attribute key/value store.
+    *
+    * @returns {string | null} The value of the customer attribute.
+    */
+    static getAllCustomerAttributes(): string[];
+    /**
+     * Clears a value of the given key in the on-device key/value store.
+     *
+     * @param key - The key of the customer attribute to clear.
+     */
+    static clearCustomerAttribute(key: string): void;
+    /**
+     * Clear all customer attributes from the on-device key/value store.
+     */
+    static clearAllCustomerAttributes(): void;
+    /**
+     * @return current customer's journey state.
+     */
+    static journeyState(): CustomerJourneyState | null;
+    /**
+     * @return the unique identifier Nami users to identify this device. Please note
+     * you should not depend on the device identifier persisting across app re-installs.
+     */
+    static deviceId(): string;
+    /**
+     * When there has been an update received to the active entitlements,
+     * the Nami SDK will provide notification of that event through
+     * this callback with list of active [NamiEntitlement]
+     *
+     * @param {NamiCustomerJourneyStateHandler} handler - The callback function that will be invoked when the campaign list is updated.
+     * @returns {Callback} A function that can be called to unregister the handler.
+     */
+    static registerJourneyStateHandler(handler: NamiCustomerJourneyStateHandler): Callback$1 | undefined;
+    /**
+     * Private Static Methods
+     */
+    private static invokeStateHandler;
+    /**
+     * Private Instance Methods
+     */
+    private get isSDKInitialized();
+    private static updateCustomerDataPlatformId;
+    /**
+     * @returns whether or not the configured app platform id belongs to an anonymous mode
+     * capable Nami account.
+     */
+    private static anonymousModeCapability;
+    private static refetchConfig;
+}
+
+declare class NamiProfileManager {
+    static instance: NamiProfileManager;
+    private externalId?;
+    constructor();
+    setExternalId(externalId: string | undefined): NamiProfileManager;
+    getExternalId(): string | undefined;
+    isLoggedIn(): boolean;
+    private save;
+    private load;
+    login(externalId: string): Promise<void>;
+    logout(): Promise<void>;
+}
+
+declare class NamiEventEmitter {
+    private static instance;
+    private emitter;
+    static getInstance(): NamiEventEmitter;
+    on(eventName: string, listener: (...args: any[]) => void): void;
+    off(eventName: string, listener: (...args: any[]) => void): void;
+    emit(eventName: string, ...args: any[]): void;
+    addListener(eventName: string, listener: (...args: any[]) => void): void;
+    removeListener(eventName: string, listener: (...args: any[]) => void): void;
+    removeAllListeners(eventName?: string): void;
+    listeners(eventName: string): any[];
+    listenerCount(eventName: string): number;
+}
+
+/**
+ * @class NamiPaywallManager
+ * Provides methods for managing all aspects of a paywall in the Nami SDK.
+ */
+declare class NamiPaywallManager {
+    static instance: NamiPaywallManager;
+    static emitter: NamiEventEmitter;
+    private emitter;
+    productDetails: NamiProductDetails[];
+    /**
+     * @returns {IPaywall[]} a list of Paywall
+     */
+    static allPaywalls(): IPaywall[];
+    /**
+     * Used to set product details when store products are unavailable. For advanced use cases only.
+     */
+    static setProductDetails(productDetails: NamiProductDetails[]): void;
+    /**
+     * Register a callback which would be invoked when user will sign-in
+     */
+    static registerSignInHandler(handler: Callback$1): Callback$1;
+    /**
+     * Register a callback which would be invoked when user close a paywall raised by Nami system
+     */
+    static registerCloseHandler(handler: CloseHandler): Callback$1;
+    /**
+     * Register a callback which would be invoked when user will take action on deeplink
+     */
+    static registerDeeplinkActionHandler(handler: DeepLinkUrlHandler): Callback$1;
+    /**
+     * Register a [NamiBuySkuHandler] which would be invoked when a user triggers
+     * a buy sku action on a paywall.
+     *
+     * Only available for plans where Nami is not handling subscription & IAP management.
+     */
+    static registerBuySkuHandler(handler: SKUActionHandler): Callback$1;
+    /**
+     * Register a callback which would be invoked when user restore a product
+     */
+    static registerRestoreHandler(handler: Callback$1): Callback$1;
+    /**
+     * Notify the NamiPaywallManager that a purchase initiated from the
+     * [NamiBuySkuHandler] is complete.
+     *
+     * Only available for plans where Nami is not handling subscription & IAP management.
+     *
+     * @returns {Promise<void>} A Promise that resolves when buying SKU will be complete.
+     */
+    static buySkuComplete(purchase: NamiPurchaseDetails): Promise<void>;
+    /**
+     * Notify the NamiPaywallManager that purchase flow handled by you is cancelled.
+     * Used to disable product purchase-in-progress loading indicators
+     */
+    static buySkuCancel(): void;
+    /**
+     * Set the video details for the app supplied video
+     * @param url The URL of the video
+     * @param name The name of the video
+     */
+    static setAppSuppliedVideoDetails(url: string, name?: string): void;
+    /**
+     * Enables or disables user interaction on Nami paywalls.
+     *
+     * @param {boolean} allowed - Whether user interaction should be allowed.
+     * @returns {void}
+     */
+    static allowUserInteraction(allowed: boolean): void;
+    /**
+     * Private Instance Methods
+     */
+    private get sdkInitialized();
+}
+
+type IEntitlements = {
+    id: string;
+    entitlement_ref_id: string;
+    name: string;
+    description: string | null;
+    type: string;
+    expires?: string;
+};
+type NamiEntitlement = {
+    activePurchases: NamiPurchase[];
+    desc: string;
+    name: string;
+    namiId: string;
+    purchasedSkus: NamiSKU[];
+    referenceId: string;
+    relatedSkus: NamiSKU[];
+    expires?: number;
+};
+type NamiActiveEntitlementsHandler = (entitlement: NamiEntitlement[]) => void;
+
+/**
+ * @class NamiEntitlementManager
+ * Contains all methods and objects to work with entitlements in the SDK.
+ */
+declare class NamiEntitlementManager {
+    static instance: NamiEntitlementManager;
+    private emitter;
+    /**
+     * @returns {NamiEntitlement[]} A list of currently active entitlements
+     */
+    static active(): NamiEntitlement[];
+    /**
+     * Checks if a Nami Control Center defined Entitlement has at least one backing purchase
+     * and it's not expired.
+     *
+     * @param referenceId - entitlement referenceId
+     * @returns {boolean} True if the entitlement is active for given referenceId, false otherwise.
+     */
+    static isEntitlementActive(referenceId: string): boolean;
+    /**
+     * Asks Nami to fetch the latest active entitlements
+     *
+     * @returns {Promise<NamiEntitlement[]>} A promise that resolves to a list of NamiEntitlement
+     */
+    static refresh(): Promise<NamiEntitlement[]>;
+    /**
+     * When there has been an update received to the active entitlements,
+     * the Nami SDK will provide notification of that event through
+     * this callback with list of active [NamiEntitlement]
+     *
+     * @param {NamiActiveEntitlementsHandler} handler - The callback function that will be invoked when the campaign list is updated.
+     * @returns {Callback} A function that can be called to unregister the handler.
+     */
+    static registerActiveEntitlementsHandler(handler: NamiActiveEntitlementsHandler): Callback$1 | undefined;
+    /**
+     *  Clear any provisional entitlement grants, which are entitlements issued on-device only.
+     *  Useful for development and purchase testing. Not recommended to be called in production.
+     */
+    static clearProvisionalEntitlementGrants(): void;
+    /**
+     * Private Instance Methods
+     */
+    private get sdkInitialized();
+}
+
+declare class SimpleEventTarget implements EventTarget {
+    private listeners;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null): void;
+    dispatchEvent(event: Event): boolean;
+}
+
+type Callback = () => void;
+declare const initialState: TPaywallContext;
+declare class PaywallState extends SimpleEventTarget {
+    static providers: PaywallState[];
+    state: TPaywallContext;
+    subscribers: Set<Callback>;
+    productDetails: NamiProductDetails[];
+    flow?: NamiFlow;
+    filteredSkuMenus: ISkuMenu[];
+    static create(paywall: IPaywall, context: NamiPaywallLaunchContext, campaign: NamiCampaign): PaywallState;
+    static remove(provider: PaywallState): void;
+    static get currentProvider(): PaywallState | undefined;
+    static setCustomerAttribute(attributes: {
+        [key: string]: string;
+    }): void;
+    static removeCustomerAttribute(key: string): void;
+    static setAppSuppliedVideoDetails(details: NamiAppSuppliedVideoDetails): void;
+    static getSelectedPaywall(): IPaywall | undefined;
+    static setUserInteractionEnabled(enabled: boolean): void;
+    static setUserTags(tags: {
+        [key: string]: string;
+    }): void;
+    static setProductDetails(details: NamiProductDetails[]): void;
+    static setPurchaseInProgress(inProgress: boolean): void;
+    static setIsLoggedIn(isLoggedIn: boolean): void;
+    static setPurchase(inProgress: boolean, product?: NamiSKU): void;
+    static getSelectedSlideIndex(): number | undefined;
+    constructor(paywall: IPaywall, context: NamiPaywallLaunchContext, campaign: NamiCampaign);
+    protected onStateChanged(): void;
+    subscribe(callback: Callback): Callback;
+    unsubscribe(callback: Callback): void;
+    emitEvent<T = any>(name: string, payload?: T): void;
+    onEvent<T = any>(name: string, handler: (payload: T) => void): () => void;
+    private setState;
+    setProductDetails(details: NamiProductDetails[]): void;
+    getProductDetails(): NamiProductDetails[];
+    setCurrentGroupData(currentGroupId: string, currentGroupName: string): void;
+    setFormState(formId: string, state: boolean | string): void;
+    setTimerState(timerId: string, remainingSeconds: number, savedAt: number, hasEmittedCompletion: boolean): void;
+    getTimerState(timerId: string): TimerState | undefined;
+    getCurrentGroupId(): string;
+    getCurrentGroupName(): string;
+    setCurrentFormId(formId: string, value?: string): void;
+    getCurrentFormId(formId: string): boolean | string;
+    setSelectedProducts(products: {
+        [currentGroupId: string]: string | null;
+    }): void;
+    selectedProducts(): {
+        [currentGroupId: string]: string | null;
+    };
+    setPaywall(paywall: IPaywall, context: NamiPaywallLaunchContext, campaign: NamiCampaign): void;
+    getSelectedPaywall(): IPaywall | undefined;
+    getSelectedCampaign(): NamiCampaign | undefined;
+    getCurrentPlacementLabel(): string | null | undefined;
+    getPaywallActionEventData(): Partial<NamiPaywallEvent>;
+    paywallId(): string;
+    setCurrentPage(page: string): void;
+    setCustomerAttribute(attributes: {
+        [key: string]: string;
+    }): void;
+    removeCustomerAttribute(key: string): void;
+    setIsLoggedIn(isLoggedIn: boolean): void;
+    setMediaList(media: TPaywallMedia[]): void;
+    setSafeAreaTop(safeAreaTop: number): void;
+    setFullScreenPresentation(fullScreenPresentation: boolean): void;
+    setFormFactor(formFactor: TDevice): void;
+    getFormFactor(): TDevice;
+    setPurchaseInProgress(inProgress: boolean): void;
+    setPurchase(inProgress: boolean, product?: NamiSKU): void;
+    setTimeSpentOnPaywall(time: number): void;
+    setAppSuppliedVideoDetails({ url, name }: NamiAppSuppliedVideoDetails): void;
+    resetAppSuppliedVideoDetails(): void;
+    setLaunchDetails(value: string, type?: string): void;
+    setOpenHeaderIds(id: string, sku?: NamiSKU): void;
+    getCurrentCollapsibleSku(): NamiSKU;
+    setFlow(flow: NamiFlow): void;
+    setUserInteractionEnabled(enabled: boolean): void;
+    setUserTags(tags: {
+        [key: string]: string;
+    }): void;
+    setCurrentSlideIndex(index: number): void;
+}
+
+declare class StorageService {
+    private memoryStore;
+    private get storage();
+    setDevice(device: Device): void;
+    getDevice(): Device | null;
+    resetDevice(): void;
+    getAnonymousMode(): boolean;
+    setAnonymousMode(mode: boolean): void;
+    clearAnonymousMode(): void;
+    setAppConfig(key: string, config: IConfig): void;
+    getAppConfig(key: string): IConfig | null;
+    setLanguageCode(code?: string): void;
+    getLanguageCode(): string;
+    setCampaignRules(key: string, campaignRules: NamiCampaign[]): void;
+    getCampaignRules(key: string): NamiCampaign[] | null;
+    setPaywalls(key: string, paywalls: IPaywall[]): void;
+    getPaywalls(key: string): IPaywall[] | null;
+    setActiveEntitlements(key: string, entitlements: IEntitlements[]): void;
+    getActiveEntitlements(key: string): IEntitlements[];
+    setNamiEntitlements(key: string, entitlements: NamiEntitlement[]): void;
+    getNamiEntitlements(key: string): NamiEntitlement[];
+    setProducts(key: string, products: SKU[]): void;
+    getProducts(key: string): SKU[] | null;
+    getCachedProducts(): SKU[] | null;
+    setNamiConfig(config: Omit<NamiConfiguration, "initialConfig">): void;
+    getNamiConfig(): Omit<NamiConfiguration, "initialConfig"> | null;
+    setCustomerAttribute<T>(attribute: string, value: T): void;
+    getCustomerAttribute<T>(attribute: string): T | null;
+    getAllCustomerAttributes(): string[];
+    getAllCustomerAttributesKeys(): string[];
+    clearCustomerAttribute(attribute: string): boolean;
+    clearAllCustomerAttributes(): void;
+    setNamiProfile(profileData: NamiProfile): void;
+    getNamiProfile(): NamiProfile | null;
+    removeNamiProfile(): void;
+    setCustomerJourneyState(state: CustomerJourneyState): void;
+    getCustomerJourneyState(): CustomerJourneyState | null;
+    setSessionCounter(): void;
+    getSessionCounter(): number;
+    setLastImpressionId(id: string): void;
+    getLastImpressionId(): string;
+    setPurchaseImpression(): void;
+    getPurchaseImpression(): string;
+    setSessionId(id?: string): void;
+    getSessionId(): string;
+    clearSessionId(): void;
+    setLaunchId(id?: string): void;
+    getLaunchId(): string;
+    clearLaunchId(): void;
+    setPurchaseChannel(channel?: string): void;
+    getPurchaseChannel(): string | null;
+    getAnonymousUUID(): string | null;
+    setAnonymousUUID(uuid: string): void;
+    clearAnonymousUUID(): void;
+    setApiCampaignSessionTimestamp(): void;
+    getApiCampaignSessionTimestamp(): number | null;
+    purgeApiCampaignCache(): void;
+    private getCampaignCacheTtl;
+    private isLegacyTimestampedCache;
+    /**
+     * Set an item in localStorage.
+     * @param {string} key - The key under which to store the data.
+     * @param {T} value - The data to store.
+     */
+    private setItem;
+    /**
+     * Get an item from localStorage.
+     * @param {string} key - The key of the item to retrieve.
+     * @returns {T | null} The stored data, or null if not found.
+     */
+    private getItem;
+    /**
+     * Remove an item from localStorage.
+     * @param {string} key - The key of the item to remove.
+     */
+    private resetItem;
+    /**
+     * Clear all items from localStorage.
+     */
+    clear(): void;
+}
+declare const storageService: StorageService;
+
+declare class Logger {
+    private currentLogLevel;
+    setLogger: (level?: NamiLogLevel) => void;
+    debug<T>(message: T, ...args: unknown[]): void;
+    info<T>(message: T, ...args: unknown[]): void;
+    warn<T>(message: T, ...args: unknown[]): void;
+    error<T>(message: T, ...args: unknown[]): void;
+    private shouldLog;
+    private formatMessage;
+}
+declare const logger: Logger;
+
+declare class SessionService {
+    static instance: SessionService;
+    startSession(): Promise<void>;
+}
+
+declare const postConversion: (transactionInfo: TransactionRequest) => Promise<void>;
+
+type PricingPhase = {
+    priceAmountMicros: number;
+    priceCurrencyCode: string;
+    billingPeriod: string;
+    formattedPrice: string;
+};
+
+interface ApiResponse<T> {
+    count: number;
+    next: number;
+    page_number: number;
+    previous: null;
+    results: T;
+    total_pages: number;
+}
+type LoginResponse = {
+    external_id: string;
+    user_id: string;
+};
+type Session = {
+    id?: string;
+    app_env?: string;
+    start_time?: Date;
+    end_time?: Date;
+};
+type Impression = {
+    id?: string;
+    session?: string;
+    segment?: string;
+    call_to_action?: string;
+    app_env?: string;
+    url_params?: Record<string, string>;
+    launch_id?: string;
+};
+
+declare const NAMI_SDK_VERSION: string;
+declare const NAMI_SDK_PACKAGE_VERSION: string;
+declare const PRODUCTION: string;
+declare const DEVELOPMENT: string;
+declare const PLATFORM_ID_REQUIRED: string;
+declare const DEVICE_ID_REQUIRED: string;
+declare const EXTERNAL_ID_REQUIRED: string;
+declare const SDK_NOT_INITIALIZED: string;
+declare const CAMPAIGN_NOT_AVAILABLE: string;
+declare const FLOW_SCREENS_NOT_AVAILABLE: string;
+declare const UNABLE_TO_UPDATE_CDP_ID: string;
+declare const ANONYMOUS_MODE_ALREADY_ON: string;
+declare const ANONYMOUS_MODE_ALREADY_OFF: string;
+declare const ANONYMOUS_MODE_LOGIN_NOT_ALLOWED: string;
+declare const SESSION_REQUIRED: string;
+declare const DEVICE_ID_NOT_SET: string;
+declare const AUTH_DEVICE: string;
+declare const NAMI_CONFIGURATION: string;
+declare const NAMI_PROFILE: string;
+declare const API_CONFIG: string;
+declare const API_CAMPAIGN_RULES: string;
+declare const API_PAYWALLS: string;
+declare const API_CAMPAIGN_SESSION_TIMESTAMP: string;
+declare const API_PRODUCTS: string;
+declare const API_ACTIVE_ENTITLEMENTS: string;
+declare const SERVER_NAMI_ENTITLEMENTS: string;
+declare const INITIAL_APP_CONFIG: string;
+declare const INITIAL_CAMPAIGN_RULES: string;
+declare const INITIAL_PAYWALLS: string;
+declare const INITIAL_PRODUCTS: string;
+declare const LOCAL_NAMI_ENTITLEMENTS: string;
+declare const CUSTOMER_ATTRIBUTES_KEY_PREFIX: string;
+declare const NAMI_CUSTOMER_JOURNEY_STATE: string;
+declare const ANONYMOUS_MODE: string;
+declare const ANONYMOUS_UUID: string;
+declare const KEY_SESSION_COUNTER: string;
+declare const INITIAL_SESSION_COUNTER_VALUE: number;
+declare const NAMI_LAST_IMPRESSION_ID: string;
+declare const NAMI_PURCHASE_IMPRESSION_ID: string;
+declare const NAMI_LAUNCH_ID: string;
+declare const NAMI_SESSION_ID: string;
+declare const NAMI_LANGUAGE_CODE: string;
+declare const NAMI_PURCHASE_CHANNEL: string;
+declare const API_VERSION: string;
+declare const BASE_URL_PATH: string;
+declare const BASE_URL: string;
+declare const BASE_STAGING_URL: string;
+declare const CUSTOM_HOST_PREFIX: string;
+declare const USE_STAGING_API: string;
+declare const EXTENDED_CLIENT_INFO_PREFIX: string;
+declare const EXTENDED_CLIENT_INFO_DELIMITER: string;
+declare const VALIDATE_PRODUCT_GROUPS: string;
+declare const EXTENDED_PLATFORM: string;
+declare const EXTENDED_PLATFORM_VERSION: string;
+declare const API_MAX_CALLS_LIMIT: number;
+declare const API_RETRY_DELAY_SEC: number;
+declare const API_TIMEOUT_LIMIT: number;
+declare const DEVICE_API_TIMEOUT_LIMIT: number;
+declare const STATUS_SUCCESS: number;
+declare const STATUS_BAD_REQUEST: number;
+declare const STATUS_NOT_FOUND: number;
+declare const STATUS_CONFLICT: number;
+declare const STATUS_INTERNAL_SERVER_ERROR: number;
+declare const INITIAL_SUCCESS: string;
+declare const RECONFIG_SUCCESS: string;
+declare const ALREADY_CONFIGURED: string;
+declare const AVAILABLE_CAMPAIGNS_CHANGED: string;
+declare const PAYWALL_ACTION_EVENT: string;
+declare const AVAILABLE_ACTIVE_ENTITLEMENTS_CHANGED: string;
+declare const CUSTOMER_JOURNEY_STATE_CHANGED: string;
+declare const SKU_TEXT_REGEX: RegExp;
+declare const VAR_REGEX: RegExp;
+declare const HTML_REGEX: RegExp;
+declare const SMART_TEXT_PATTERN: string;
+declare const LIQUID_VARIABLE_REGEX: RegExp;
+
+declare const SHOULD_SHOW_LOADING_INDICATOR = false;
+
+declare const getBaseUrl: (namiCommands?: string[]) => string;
+declare const getExtendedClientInfo: (namiCommands: string[]) => ExtendedPlatformInfo;
+declare const hasCapability: (capability: string) => boolean;
+declare const hasPurchaseManagement: (messagePrefix?: string) => boolean;
+declare const shouldValidateProductGroups: () => boolean;
+declare function tryParseJson(str: string): InitialConfig | InitialConfigCompressed | undefined;
+declare function tryParseB64Gzip(str: string): InitialConfig | undefined;
+
+declare const getDeviceData: (namiCommands?: string[]) => DevicePayload;
+declare const getDeviceFormFactor: () => TDevice;
+declare function getDeviceScaleFactor(formFactor?: string): number;
+declare function generateUUID(): string;
+declare function audienceSplitPosition(uuid: string): number;
+declare function bigintToUuid(v: bigint): string;
+declare function uuidFromSplitPosition(namiCommands?: string[]): string | undefined;
+
+type TSemverObj = {
+    semver: string | undefined;
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: string;
+    buildmetadata: string;
+};
+declare function parseToSemver(versionString: string): TSemverObj;
+/**
+ * Validates if the current SDK version meets the minimum required version for a component
+ * Logs a warning if the SDK version is insufficient
+ * @param minSDKVersion - The minimum SDK version required for the component
+ * @param componentName - The name of the component
+ */
+declare function validateMinSDKVersion(minSDKVersion: TSemverObj | undefined, componentName: string): void;
+
+declare function empty<T>(object: T): boolean;
+
+declare const formatDate: (text: string, dateFormat: string) => string;
+declare const isValidISODate: (isoDate: string) => boolean;
+declare const convertLocale: (locale: string) => string;
+
+declare const getUrlParams: () => Record<string, string>;
+
+/**
+ * Interface for NamiRefs instance to maintain type safety
+ * Only includes methods needed by utilities that depend on NamiRefs
+ */
+interface INamiRefsInstance {
+    isInMemoryAnonymousMode(): boolean;
+    setInMemoryAnonymousMode(enabled: boolean): void;
+}
+/**
+ * Utility function to check anonymous mode status
+ * Checks both persistent (storage) and in-memory flags
+ * @returns true if device is in anonymous mode (either persistent or temporary)
+ */
+declare function isAnonymousMode(): boolean;
+
+/**
+ * Returns the translated string for the given key in the current SDK language.
+ * Uses Nami language code from storage (set via Nami.configure({ namiLanguageCode })).
+ * Falls back to English if the key or locale is missing.
+ */
+declare function getTranslate(key: string): string;
+
+declare class NamiAPI {
+    static instance: NamiAPI;
+    private baseURL;
+    private platformID;
+    private get deviceID();
+    constructor();
+    static configure(config: NamiConfiguration): void;
+    protected configure(config: NamiConfiguration): void;
+    login(externalId: string): Promise<LoginResponse>;
+    logout(): Promise<Record<string, never>>;
+    startSession(sessionStartTime: Date): Promise<void>;
+    postImpression(options: Impression): Promise<void>;
+    postConversion(options: TransactionRequest): Promise<void>;
+    purchaseValidation(options: PurchaseValidationRequest): Promise<void>;
+    fetchAPI<T>(path: string, timeout?: number, retries?: number): Promise<T>;
+    requestBodyAPI<T, U>(path: string, bodyData: T, method?: string, keepalive?: boolean, timeout?: number, retries?: number): Promise<U>;
+}
+
+declare class NamiRefs {
+    static instance: NamiRefs;
+    private inMemoryAnonymousMode;
+    constructor();
+    setInMemoryAnonymousMode(enabled: boolean): void;
+    isInMemoryAnonymousMode(): boolean;
+    isAnonymousMode(): boolean;
+    init(config: NamiConfiguration): Promise<void>;
+    private setInitialValues;
+    private initAnonymousDevice;
+    private initIdentifiedDevice;
+    private initAndFetchRequiredData;
+    fetchCampaignsAndPaywalls(): Promise<NamiCampaign[]>;
+    private reRenderPaywall;
+}
+
+declare const isValidUrl: (label: string) => boolean;
+declare const selectSegment: (segments: NamiCampaignSegment[], splitPosition: number) => NamiCampaignSegment;
+declare const mapAnonymousCampaigns: (campaigns: NamiAnonymousCampaign[], splitPosition: number, formFactor?: TDevice) => NamiCampaign[];
+/**
+ *
+ * @returns A combined list of unique campaigns based on both API and Initial, filtered by form factor.
+ * This is used to get all campaigns that are applicable to the current device.
+ *
+ * Note: Since this function returns a unique list of campaigns, and API campaigns take precedence,
+ * there may be times when API campaigns are returned that do not yet have paywalls but initial campaigns would.
+ */
+declare const allCampaigns: () => NamiCampaign[];
+declare const getInitialCampaigns: () => NamiCampaign[];
+declare const getApiCampaigns: () => NamiCampaign[];
+/**
+ * Get paywall data from label. This function continues to search for both the campaign and paywall
+ * based on the provided label and type. It first checks API data, then falls back to initial data.
+ *
+ * @param value Campaign label to search for
+ * @param type Campaign type to filter by
+ * @returns An object containing the currently available campaign and paywall data
+ */
+declare const getPaywallDataFromLabel: (value: string, type?: string) => {
+    campaign: NamiCampaign | undefined;
+    paywall: IPaywall | undefined;
+};
+
+declare class EntitlementUtils {
+    static instance: EntitlementUtils;
+    refIdToPurchasedSKUs: {
+        [key: string]: NamiSKU[];
+    };
+    refIdToRelatedSKUs: {
+        [key: string]: NamiSKU[];
+    };
+    refIdToActivePurchases: {
+        [key: string]: NamiPurchase[];
+    };
+}
+declare const toNamiEntitlements: (entitlement: IEntitlements) => NamiEntitlement;
+declare const setActiveNamiEntitlements: (entitlements: NamiEntitlement[]) => void;
+declare const activeEntitlements: () => NamiEntitlement[];
+declare const invokeHandler: () => void;
+declare const getEntitlementRefIdsForSku: (purchasedSkuId: string) => string[];
+/**
+ * Populate a list of [NamiEntitlement] from the entitlements that have been provided by the
+ * app config. Also clears any previous list of [NamiEntitlement] from cache
+ */
+declare const createNamiEntitlements: (entitlements?: IEntitlements[]) => NamiEntitlement[];
+/**
+ * For namiPurchase instance, it will have a purchasedSKU that will back the activation of
+ * the entitlement.
+ *
+ * The purchaseSku (pSKU) can then be used to retrieve all entitlements activated by that pSKU
+ *
+ * The entitlement will then be inspected to see if pSKU has yet to be tracked by that
+ * entitlement. If it has not, then it will be added.
+ *
+ * The entitlement will then be inspected to see if there any active purchases that match
+ * the NamiSKU. If there isn't any, then the NamiPurchase is then added to the
+ * entitlement's list of active purchases
+ */
+declare const applyEntitlementActivation: (namiPurchase: NamiPurchase) => string[];
+/**
+   * Using the Nami Purchase object, look up the corresponding NamiSKU
+   * and set the NamiEntitlement associated to NamiSKU as an active entitlement
+   *
+   * @return List of strings where each string is a reference Id of an entitlement
+   * that was just successfully activated
+   */
+declare const activateEntitlementByPurchase: (purchase: NamiPurchase) => string[];
+declare const skuMapFromEntitlements: (entitlements?: IEntitlements[]) => {
+    [key: string]: NamiSKU[];
+};
+declare const updateRelatedSKUsForNamiEntitlement: (entitlementRefId: string, entitlementRefIdToNamiSkus: {
+    [key: string]: NamiSKU[];
+}) => void;
+declare function toNamiSKU(sku: PaywallSKU | SKU): NamiSKU;
+
+declare function namiBuySKU(skuRefId: string): NamiPurchaseCompleteResult | undefined;
+
+declare function currentSku(productDetails: NamiProductDetails[], initialState: TInitialState, skuMenus: ISkuMenu[], skus: PaywallSKU[]): {
+    [key: string]: any;
+};
+declare function skuItems(productDetails: NamiProductDetails[], skuMenus: ISkuMenu[], currentGroupId: string): PaywallSKU[];
+declare function getSkuSmartTextValue(productDetail?: NamiProductDetails | null, sku?: PaywallSKU, skus?: PaywallSKU[]): {
+    [key: string]: any;
+};
+declare function getSlideSmartTextValue(productDetail?: NamiProductDetails | null, slide?: TCarouselSlide, skus?: PaywallSKU[]): {
+    [key: string]: any;
+};
+declare function checkAnySkuHasTrialOffer(productDetails: NamiProductDetails[], skuMenus: ISkuMenu[]): boolean;
+declare function checkAnySkuHasPromoOffer(productDetails: NamiProductDetails[], skuMenus: ISkuMenu[]): boolean;
+declare function productDetail(details?: NamiProductDetails[], refId?: string): NamiProductDetails | null;
+declare function normalizeLaunchContext(stateContext: NamiPaywallLaunchContext, context: NamiPaywallLaunchContext, skuMenus?: ISkuMenu[]): TPaywallLaunchContext;
+
+declare const getSkuProductDetailKeys: () => string[];
+declare const getProductDetail: (variableName: string, product?: NamiProductDetails | null, referenceId?: string, skus?: PaywallSKU[]) => unknown;
+
+declare class RetryLimitExceededError extends Error {
+    statusCode: number;
+    status: number;
+    constructor(statusCode: number, message: string);
+}
+declare class APIError extends Error {
+}
+declare class ConflictError extends APIError {
+    status: number;
+    constructor();
+}
+declare class SDKNotInitializedError extends Error {
+    constructor();
+}
+declare class PlatformIDRequiredError extends Error {
+    constructor();
+}
+declare class DeviceIDRequiredError extends Error {
+    constructor();
+}
+declare class ExternalIDRequiredError extends Error {
+    constructor();
+}
+declare class CampaignNotAvailableError extends Error {
+    constructor();
+}
+declare class FlowScreensNotAvailableError extends Error {
+    constructor();
+}
+declare class AnonymousModeAlreadyOnError extends Error {
+    constructor();
+}
+declare class AnonymousModeAlreadyOffError extends Error {
+    constructor();
+}
+declare class AnonymousLoginError extends Error {
+    constructor();
+}
+declare class AnonymousCDPError extends Error {
+    constructor();
+}
+declare class BadRequestError extends APIError {
+    constructor(message: string);
+}
+declare class NotFoundError extends APIError {
+    constructor(message: string);
+}
+declare class ClientError extends APIError {
+    statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+declare class InternalServerError extends APIError {
+    constructor(message: string);
+}
+declare const handleErrors: (status: number, path: string) => void;
+
+declare class CampaignRuleRepository {
+    currentFormFactor: TDevice;
+    splitPosition: number;
+    disableCampaignUpdates: boolean;
+    useLegacyPaywallFetch: boolean;
+    static instance: CampaignRuleRepository;
+    constructor();
+    configure(formFactor: TDevice, splitPosition: number, namiCommands?: string[]): void;
+    fetchCampaignRules(paywalls: IPaywall[]): Promise<NamiCampaign[]>;
+    static extractPaywallUrls(campaigns: NamiCampaign[]): string[];
+    static hasPaywallUrls(campaigns: NamiCampaign[]): boolean;
+    fetchCampaignRulesRaw(): Promise<NamiCampaign[]>;
+    finalizeCampaignRules(campaignRules: NamiCampaign[], paywalls: IPaywall[]): NamiCampaign[];
+    invokeAvailableCampaignsResponseHandler(): void;
+    private getAnonymousCampaigns;
+    private getCampaigns;
+    private fallbackData;
+}
+
+declare class ConfigRepository {
+    static instance: ConfigRepository;
+    fetchConfig(): Promise<IConfig | null>;
+}
+
+declare class CustomerJourneyRepository {
+    static instance: CustomerJourneyRepository;
+    fetchCustomerJourneyState(): Promise<CustomerJourneyState | null>;
+}
+
+declare class DeviceRepository {
+    static instance: DeviceRepository;
+    createOrUpdateDevice(deviceData: DevicePayload, splitPositionUUID?: string, namiRefs?: INamiRefsInstance): {
+        id: string;
+        device: Promise<Device | null> | null;
+    };
+    createDevice(deviceData: DevicePayload, namiRefs?: INamiRefsInstance): Promise<Device | null>;
+    updateDevice(currentDeviceId: string, deviceData: DevicePayload): Promise<Device | null>;
+    updateDeviceField<T>(key: string, value: T): Promise<Device | null>;
+    private requestAPIData;
+    private isEqualDevices;
+    getOrCreateAnonymousUUID(): string;
+    private getAnonymousUUID;
+}
+
+declare class EntitlementRepository {
+    static instance: EntitlementRepository;
+    constructor();
+    /**
+     * Just fetch [ActiveEntitlement] from API and save it in localstorage.
+     */
+    fetchActiveEntitlements(): Promise<IEntitlements[] | null>;
+    private getAPIEntitlements;
+    private invokeActiveEntitlementsHandler;
+}
+
+declare class PaywallRepository {
+    static instance: PaywallRepository;
+    fetchPaywalls(): Promise<IPaywall[]>;
+    private getAnonymousPaywalls;
+    private getPaywalls;
+    fetchPaywallByUrl(url: string): Promise<IPaywall>;
+    fetchPaywallsByUrls(urls: string[]): Promise<IPaywall[]>;
+    private fallbackData;
+}
+
+declare class ProductRepository {
+    static instance: ProductRepository;
+    fetchProducts(): Promise<SKU[]>;
+    private fallbackData;
+}
+
+/**
+ * Get initial paywalls from storage service.
+ * @returns An array of initial paywalls from storage service.
+ */
+declare const getInitialPaywalls: () => IPaywall[];
+/**
+ * Get all API paywalls from storage service.
+ * @returns An array of API paywalls from storage service.
+ */
+declare const getApiPaywalls: () => IPaywall[];
+/**
+ * Get all paywalls from both API and Initial sources, ensuring uniqueness.
+ * This function combines paywalls from both sources and filters out duplicates.
+ * API Data takes precedence over Initial Data.
+ *
+ * @returns A combined list of unique paywalls based on both API and Initial data.
+ */
+declare const allPaywalls: () => IPaywall[];
+declare const getPaywall: (paywallId: string) => IPaywall | undefined;
+declare const hasAllPaywalls: (paywallIds: string[]) => boolean;
+
+type Resolver = (identifier: string) => any;
+declare class NamiConditionEvaluator {
+    private static instance;
+    private resolvers;
+    private namespaceResolvers;
+    private constructor();
+    static get shared(): NamiConditionEvaluator;
+    registerNamespaceResolver(namespace: string, resolver: Resolver): void;
+    resetResolvers(): void;
+    evaluate(conditions: NamiConditions): boolean;
+    evaluateOrdered(conditions?: NamiConditions): boolean;
+    private evaluateFilter;
+    private resolve;
+    private resolveRaw;
+    private extractProperty;
+    private log;
+}
+
+declare abstract class BaseNamespaceResolver {
+    protected abstract readonly namespace: string;
+    protected abstract resolveValue(path: string): any;
+    constructor();
+    protected register(): void;
+    protected resolveKeyPath(keyPath: string, target: any): any;
+}
+
+declare class LaunchContextResolver extends BaseNamespaceResolver {
+    protected readonly namespace = "LaunchContext";
+    private context;
+    constructor(context: NamiPaywallLaunchContext);
+    protected resolveValue(keyPath: string): any;
+}
+
+declare class PlacementLabelResolver extends BaseNamespaceResolver {
+    protected readonly namespace = "Placement";
+    private campaign?;
+    constructor(campaign?: NamiCampaign);
+    protected resolveValue(keyPath: string): any;
+}
+
+declare const isSubscription: (productType?: string) => productType is "subscription";
+declare function getStandardBillingPeriod(product: NamiProductDetails): string | null;
+declare function getFreeTrialPeriod(product: NamiProductDetails): string | null;
+declare function extractStandardPricingPhases(product: NamiProductDetails): PricingPhase[];
+declare function convertOfferToPricingPhase(offer: NamiProductOffer | null, subPeriod?: NamiSubscriptionPeriod): PricingPhase;
+declare function convertISO8601PeriodToText(iso8601Period: string | null, singular?: boolean, justPeriod?: boolean, justNumber?: boolean, useAbbrev?: boolean): string | null;
+declare function getCurrencyFormat(priceCurrencyCode: string): Intl.NumberFormat;
+declare const getPriceDifference: (currentSkuPricePerMonth?: number, referencedSkuPricePerMonth?: number, currencyFormat?: Intl.NumberFormat) => string | null;
+declare const getPercentagePriceDifference: (currentSkuPrice?: number, currentSkuDurationInMonths?: number, referencedSkuPrice?: number, referencedSkuPeriodInMonths?: number) => string | null;
+declare const getReferenceSku: (skus: PaywallSKU[], referenceId: string) => PaywallSKU | undefined;
+declare const getPricePerMonth: (phase: PricingPhase) => number;
+declare const getPeriodNumberInDays: (billingPeriod: string) => number;
+declare const getPeriodNumberInWeeks: (billingPeriod: string) => number;
+declare const getBillingPeriodNumber: (billingPeriod: string) => number;
+declare const formattedPrice: (price: number) => number;
+declare function toDouble(num: number): number;
+
+export { ALREADY_CONFIGURED, ANONYMOUS_MODE, ANONYMOUS_MODE_ALREADY_OFF, ANONYMOUS_MODE_ALREADY_ON, ANONYMOUS_MODE_LOGIN_NOT_ALLOWED, ANONYMOUS_UUID, APIError, API_ACTIVE_ENTITLEMENTS, API_CAMPAIGN_RULES, API_CAMPAIGN_SESSION_TIMESTAMP, API_CONFIG, API_MAX_CALLS_LIMIT, API_PAYWALLS, API_PRODUCTS, API_RETRY_DELAY_SEC, API_TIMEOUT_LIMIT, API_VERSION, AUTH_DEVICE, AVAILABLE_ACTIVE_ENTITLEMENTS_CHANGED, AVAILABLE_CAMPAIGNS_CHANGED, AccountStateAction, AnonymousCDPError, AnonymousLoginError, AnonymousModeAlreadyOffError, AnonymousModeAlreadyOnError, BASE_STAGING_URL, BASE_URL, BASE_URL_PATH, BadRequestError, BasicNamiFlow, BorderMap, BorderSideMap, CAMPAIGN_NOT_AVAILABLE, CUSTOMER_ATTRIBUTES_KEY_PREFIX, CUSTOMER_JOURNEY_STATE_CHANGED, CUSTOM_HOST_PREFIX, CampaignNotAvailableError, CampaignRuleConversionEventType, CampaignRuleRepository, Capabilities, ClientError, ConfigRepository, ConflictError, CustomerJourneyRepository, DEVELOPMENT, DEVICE_API_TIMEOUT_LIMIT, DEVICE_ID_NOT_SET, DEVICE_ID_REQUIRED, DeviceIDRequiredError, DeviceRepository, EXTENDED_CLIENT_INFO_DELIMITER, EXTENDED_CLIENT_INFO_PREFIX, EXTENDED_PLATFORM, EXTENDED_PLATFORM_VERSION, EXTERNAL_ID_REQUIRED, EntitlementRepository, EntitlementUtils, ExternalIDRequiredError, FLOW_SCREENS_NOT_AVAILABLE, FlowScreensNotAvailableError, HTML_REGEX, INITIAL_APP_CONFIG, INITIAL_CAMPAIGN_RULES, INITIAL_PAYWALLS, INITIAL_PRODUCTS, INITIAL_SESSION_COUNTER_VALUE, INITIAL_SUCCESS, InternalServerError, KEY_SESSION_COUNTER, LIQUID_VARIABLE_REGEX, LOCAL_NAMI_ENTITLEMENTS, LaunchCampaignError, LaunchContextResolver, LogLevel, NAMI_CONFIGURATION, NAMI_CUSTOMER_JOURNEY_STATE, NAMI_LANGUAGE_CODE, NAMI_LAST_IMPRESSION_ID, NAMI_LAUNCH_ID, NAMI_PROFILE, NAMI_PURCHASE_CHANNEL, NAMI_PURCHASE_IMPRESSION_ID, NAMI_SDK_PACKAGE_VERSION, NAMI_SDK_VERSION, NAMI_SESSION_ID, Nami, NamiAPI, NamiAnimationType, NamiCampaignManager, NamiCampaignRuleType, NamiConditionEvaluator, NamiCustomerManager, NamiEntitlementManager, NamiEventEmitter, NamiFlow, NamiFlowActionFunction, NamiFlowManager, NamiFlowStepType, NamiPaywallAction, NamiPaywallManager, PaywallManagerEvents as NamiPaywallManagerEvents, NamiProfileManager, NamiRefs, NamiReservedActions, NotFoundError, PAYWALL_ACTION_EVENT, PLATFORM_ID_REQUIRED, PRODUCTION, PaywallManagerEvents, PaywallRepository, PaywallState, PlacementLabelResolver, PlatformIDRequiredError, ProductRepository, RECONFIG_SUCCESS, RetryLimitExceededError, SDKNotInitializedError, SDK_NOT_INITIALIZED, SERVER_NAMI_ENTITLEMENTS, SESSION_REQUIRED, SHOULD_SHOW_LOADING_INDICATOR, SKU_TEXT_REGEX, SMART_TEXT_PATTERN, STATUS_BAD_REQUEST, STATUS_CONFLICT, STATUS_INTERNAL_SERVER_ERROR, STATUS_NOT_FOUND, STATUS_SUCCESS, SessionService, SimpleEventTarget, StorageService, UNABLE_TO_UPDATE_CDP_ID, USE_STAGING_API, VALIDATE_PRODUCT_GROUPS, VAR_REGEX, activateEntitlementByPurchase, activeEntitlements, allCampaigns, allPaywalls, applyEntitlementActivation, audienceSplitPosition, bigintToUuid, checkAnySkuHasPromoOffer, checkAnySkuHasTrialOffer, convertISO8601PeriodToText, convertLocale, convertOfferToPricingPhase, createNamiEntitlements, currentSku, empty, extractStandardPricingPhases, formatDate, formattedPrice, generateUUID, getApiCampaigns, getApiPaywalls, getBaseUrl, getBillingPeriodNumber, getCurrencyFormat, getDeviceData, getDeviceFormFactor, getDeviceScaleFactor, getEffectiveWebStyle, getEntitlementRefIdsForSku, getExtendedClientInfo, getFreeTrialPeriod, getInitialCampaigns, getInitialPaywalls, getPaywall, getPaywallDataFromLabel, getPercentagePriceDifference, getPeriodNumberInDays, getPeriodNumberInWeeks, getPlatformAdapters, getPriceDifference, getPricePerMonth, getProductDetail, getReferenceSku, getSkuProductDetailKeys, getSkuSmartTextValue, getSlideSmartTextValue, getStandardBillingPeriod, getTranslate, getUrlParams, handleErrors, hasAllPaywalls, hasCapability, hasPurchaseManagement, initialState, invokeHandler, isAnonymousMode, isInitialConfigCompressed, isNamiFlowCampaign, isSubscription, isValidISODate, isValidUrl, logger, mapAnonymousCampaigns, namiBuySKU, normalizeLaunchContext, parseToSemver, postConversion, productDetail, registerPlatformAdapters, selectSegment, setActiveNamiEntitlements, shouldValidateProductGroups, skuItems, skuMapFromEntitlements, storageService, toDouble, toNamiEntitlements, toNamiSKU, tryParseB64Gzip, tryParseJson, updateRelatedSKUsForNamiEntitlement, uuidFromSplitPosition, validateMinSDKVersion };
+export type { AlignmentType, AmazonProduct, ApiResponse, AppleProduct, AvailableCampaignsResponseHandler, BorderLocationType, BorderSideType, Callback$1 as Callback, CloseHandler, CustomerJourneyState, DeepLinkUrlHandler, DevicePayload, DeviceProfile, DirectionType, ExtendedPlatformInfo, FlexDirectionObject, FlowNavigationOptions, FontCollection, FontDetails, FormFactor, GoogleProduct, IConfig, IDeviceAdapter, IEntitlements$1 as IEntitlements, IPaywall, IPlatformAdapters, IProductsWithComponents, ISkuMenu, IStorageAdapter, IUIAdapter, Impression, InitialConfig, InitialConfigCompressed, InitiateStateGroup, NamiAnimation, NamiAnimationObjectSpec, NamiAnimationSpec, NamiAnonymousCampaign, NamiAppSuppliedVideoDetails, NamiCampaign, NamiCampaignSegment, NamiConfiguration, NamiConfigurationState, NamiEntitlement$1 as NamiEntitlement, NamiFlowAction, NamiFlowAnimation, NamiFlowCampaign, NamiFlowDTO, NamiFlowEventHandler, NamiFlowHandoffStepHandler, NamiFlowObjectDTO, NamiFlowOn, NamiFlowStep, NamiFlowTransition, NamiFlowTransitionDirection, NamiFlowWithObject, NamiInitialConfig, NamiLanguageCodes, NamiLogLevel, NamiPaywallActionHandler, NamiPaywallComponentChange, NamiPaywallEvent, NamiPaywallEventVideoMetadata, NamiPaywallLaunchContext, NamiPresentationStyle, NamiProductDetails, NamiProductOffer, NamiProfile, NamiPurchase, NamiPurchaseCompleteResult, NamiPurchaseDetails, NamiPurchasesState, NamiSKU, NamiSKUType, NamiSubscriptionInterval, NamiSubscriptionPeriod, None, NoneSpec, PaywallActionEvent, PaywallHandle, PaywallResultHandler, PaywallSKU, PricingPhase, ProductGroup, Pulse, PulseSpec, PurchaseValidationRequest, SKU, SKUActionHandler, ScreenInfo, Session, TBaseComponent, TButtonContainer, TCarouselContainer, TCarouselSlide, TCarouselSlidesState, TCollapseContainer, TComponent, TConditionalAttributes, TConditionalComponent, TContainer, TContainerPosition, TCountdownTimerTextComponent, TDevice, TDisabledButton, TField, TFieldSettings, TFlexProductContainer, THeaderFooter, TImageComponent, TInitialState, TMediaTypes, TOffer, TPages, TPaywallContext, TPaywallLaunchContext, TPaywallMedia, TPaywallTemplate, TPlayPauseButton, TProductContainer, TProductGroup, TProgressBarComponent, TProgressIndicatorComponent, TQRCodeComponent, TRadioButton, TResponsiveGrid, TSegmentPicker, TSegmentPickerItem, TSemverObj, TSpacerComponent, TStack, TSvgImageComponent, TSymbolComponent, TTestObject, TTextComponent, TTextLikeComponent, TTextListComponent, TToggleButtonComponent, TToggleSwitch, TVariablePattern, TVideoComponent, TVolumeButton, TimerState, TransactionRequest, UserAction, UserActionParameters, Wave, WaveSpec };