react-native-nami-sdk 3.3.0-beta.8 → 3.3.1

package/android/src/main/java/com/{nami/reactlibrary/NamiEntitlementManagerBridgeModule.kt → namiml/reactnative/NamiEntitlementManagerBridge.kt}

@@ -1,16 +1,22 @@
-package com.nami.reactlibrary
+package com.namiml.reactnative
 
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.namiml.entitlement.NamiEntitlementManager
-// import com.namiml.entitlement.NamiEntitlementSetter
-import com.facebook.react.bridge.Callback
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
 
-class NamiEntitlementManagerBridgeModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext) {
+@ReactModule(name = NamiEntitlementManagerBridgeModule.NAME)
+class NamiEntitlementManagerBridgeModule internal constructor(
+    reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext), TurboModule {
+
+    companion object {
+        const val NAME = "RNNamiEntitlementManager"
+    }
 
     override fun getName(): String {
-        return "RNNamiEntitlementManager"
+        return NAME
     }
 
     @ReactMethod
@@ -32,7 +38,7 @@ class NamiEntitlementManagerBridgeModule(reactContext: ReactApplicationContext)
     }
 
     @ReactMethod
-    fun refresh(callback: Callback) {
+    fun refresh() {
         NamiEntitlementManager.refresh { activeNativeEntitlements ->
             val resultArray: WritableArray = WritableNativeArray()
             if (activeNativeEntitlements != null) {
@@ -42,7 +48,9 @@ class NamiEntitlementManagerBridgeModule(reactContext: ReactApplicationContext)
                     }
                 }
             }
-            callback.invoke(resultArray)
+            reactApplicationContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("EntitlementsChanged", resultArray)
         }
     }
 
@@ -68,9 +76,11 @@ class NamiEntitlementManagerBridgeModule(reactContext: ReactApplicationContext)
 
     @ReactMethod
     fun addListener(eventName: String?) {
+        // Required for React Native event emitter support
     }
 
     @ReactMethod
     fun removeListeners(count: Int?) {
+        // Required for React Native event emitter support
     }
 }

package/android/src/main/java/com/namiml/reactnative/NamiFlowManagerBridge.kt

@@ -0,0 +1,79 @@
+package com.namiml.reactnative
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+import com.namiml.flow.NamiFlowManager
+
+@ReactModule(name = NamiFlowManagerBridgeModule.NAME)
+class NamiFlowManagerBridgeModule internal constructor(
+    reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext), TurboModule {
+
+    companion object {
+        const val NAME = "RNNamiFlowManager"
+    }
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    @ReactMethod
+    fun registerStepHandoff() {
+        NamiFlowManager.registerStepHandoff { handoffTag, handoffData ->
+            val payload = Arguments.createMap().apply {
+                putString("handoffTag", handoffTag)
+                if (handoffData != null) {
+                    try {
+                        val map = Arguments.makeNativeMap(handoffData)
+                        putMap("handoffData", map)
+                    } catch (e: Exception) {
+                        Log.d(NAME, "Failed to convert handoffData to NativeMap: ${e.localizedMessage}")
+                    }
+                }
+            }
+            sendEvent("Handoff", payload)
+        }
+    }
+
+    @ReactMethod
+    fun registerEventHandler() {
+        NamiFlowManager.registerEventHandler { data ->
+            val payload = Arguments.makeNativeMap(data)
+            sendEvent("FlowEvent", payload)
+        }
+    }
+
+    @ReactMethod
+    fun resume() {
+        Handler(Looper.getMainLooper()).postDelayed({
+            NamiFlowManager.resume()
+        }, 100L)
+    }
+
+    @ReactMethod
+    fun finish() {
+        Handler(Looper.getMainLooper()).postDelayed({
+            NamiFlowManager.finish()
+        }, 100L)
+    }
+
+    @ReactMethod
+    fun isFlowOpen(promise: Promise) {
+        promise.resolve(NamiFlowManager.isFlowOpen())
+    }
+
+    private fun sendEvent(eventName: String, params: WritableMap?) {
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+
+    // Required for RN EventEmitter support
+    @ReactMethod fun addListener(eventName: String?) {}
+    @ReactMethod fun removeListeners(count: Int?) {}
+}

package/android/src/main/java/com/namiml/reactnative/NamiPaywallManagerBridgeModule.kt

@@ -0,0 +1,197 @@
+package com.namiml.reactnative
+
+import android.app.Activity
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+import com.namiml.paywall.NamiPaywallManager
+import com.namiml.paywall.NamiSKU
+import com.namiml.paywall.model.NamiPurchaseSuccess
+
+@ReactModule(name = NamiPaywallManagerBridgeModule.NAME)
+class NamiPaywallManagerBridgeModule internal constructor(
+    reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext), TurboModule {
+
+    companion object {
+        const val NAME = "RNNamiPaywallManager"
+    }
+
+    override fun getName(): String = NAME
+
+    private var latestPaywallActivity: Activity? = null
+
+    @ReactMethod
+    fun buySkuComplete(dict: ReadableMap) {
+        val product = dict.getMap("product")
+        val productId = product?.getString("id")
+        val skuRefId = product?.getString("skuId")
+        val typeString = product?.getString("type")
+        val storeType = dict.getString("storeType") ?: "GooglePlay"
+        var purchaseSuccess: NamiPurchaseSuccess? = null
+
+        if (productId != null && skuRefId != null) {
+            val namiSku = NamiSKU.create(
+                skuRefId = skuRefId,
+                skuId = productId,
+            )
+
+            when (storeType) {
+                "GooglePlay" -> {
+                    val purchaseToken = dict.getString("purchaseToken")
+                    val orderId = dict.getString("orderId")
+                    if (purchaseToken != null && orderId != null) {
+                        purchaseSuccess = NamiPurchaseSuccess.GooglePlay(
+                            product = namiSku,
+                            orderId = orderId,
+                            purchaseToken = purchaseToken,
+                        )
+                    }
+                }
+                "Amazon" -> {
+                    val receiptId = dict.getString("receiptId")
+                    val localizedPrice = dict.getString("localizedPrice")
+                    val userId = dict.getString("userId")
+                    val marketplace = dict.getString("marketplace")
+                    if (receiptId != null && localizedPrice != null && userId != null && marketplace != null) {
+                        purchaseSuccess = NamiPurchaseSuccess.Amazon(
+                            product = namiSku,
+                            receiptId = receiptId,
+                            localizedPrice = localizedPrice,
+                            userId = userId,
+                            marketplace = marketplace,
+                        )
+                    }
+                }
+            }
+
+            if (purchaseSuccess != null) {
+                val activity = latestPaywallActivity ?: currentActivity
+                if (activity != null) {
+                    NamiPaywallManager.buySkuComplete(activity, purchaseSuccess)
+                } else {
+                    Log.w(NAME, "No activity available to complete purchase.")
+                }
+            } else {
+                Log.d(NAME, "Unable to create a valid NamiPurchaseSuccess object. Purchase not completed.")
+            }
+        }
+    }
+
+    @ReactMethod
+    fun registerCloseHandler() {
+        NamiPaywallManager.registerCloseHandler { activity ->
+            latestPaywallActivity = activity
+            val map = Arguments.createMap().apply {
+                putBoolean("paywallCloseRequested", true)
+            }
+            emitEvent("PaywallCloseRequested", map)
+        }
+    }
+
+    @ReactMethod
+    fun dismiss(promise: Promise) {
+        latestPaywallActivity?.let {
+            NamiPaywallManager.dismiss(it) { result -> promise.resolve(result) }
+        } ?: promise.resolve(false)
+    }
+
+    @ReactMethod
+    fun registerBuySkuHandler() {
+        NamiPaywallManager.registerBuySkuHandler { activity, sku ->
+            latestPaywallActivity = activity
+            try {
+                val dictionary = sku.toSkuDict()
+                emitEvent("RegisterBuySKU", dictionary)
+            } catch (e: Exception) {
+                Log.e(NAME, "Failed to convert SKU: ${e.localizedMessage}")
+            }
+        }
+    }
+
+    @ReactMethod
+    fun registerSignInHandler() {
+        NamiPaywallManager.registerSignInHandler { activity ->
+            latestPaywallActivity = activity
+            val map = Arguments.createMap().apply {
+                putBoolean("paywallSignInRequested", true)
+            }
+            emitEvent("PaywallSignInRequested", map)
+        }
+    }
+
+    @ReactMethod
+    fun registerRestoreHandler() {
+        NamiPaywallManager.registerRestoreHandler { activity ->
+            latestPaywallActivity = activity
+            val map = Arguments.createMap().apply {
+                putBoolean("paywallRestoreRequested", true)
+            }
+            emitEvent("PaywallRestoreRequested", map)
+        }
+    }
+
+    @ReactMethod
+    fun registerDeeplinkActionHandler() {
+        NamiPaywallManager.registerDeepLinkHandler { activity, url ->
+            latestPaywallActivity = activity
+            emitEvent("PaywallDeeplinkAction", url)
+        }
+    }
+
+    @ReactMethod
+    fun show() {
+        // No-op on Android
+    }
+
+    @ReactMethod
+    fun hide() {
+        // No-op on Android
+    }
+
+    @ReactMethod
+    fun isHidden(promise: Promise) {
+        promise.resolve(false)
+    }
+
+    @ReactMethod
+    fun isPaywallOpen(promise: Promise) {
+        promise.resolve(NamiPaywallManager.isPaywallOpen())
+    }
+
+    @ReactMethod
+    fun buySkuCancel() {
+        reactApplicationContext.runOnUiQueueThread {
+            latestPaywallActivity?.let {
+                NamiPaywallManager.buySkuCancel(it)
+            } ?: currentActivity?.let {
+                NamiPaywallManager.buySkuCancel(it)
+            } ?: NamiPaywallManager.buySkuCancel()
+        }
+    }
+
+    @ReactMethod
+    fun setProductDetails(productDetails: String, allowOffers: Boolean) {
+        NamiPaywallManager.setProductDetails(productDetails, allowOffers)
+    }
+
+    @ReactMethod
+    fun setAppSuppliedVideoDetails(url: String, name: String?) {
+        NamiPaywallManager.setAppSuppliedVideoDetails(url, name)
+    }
+
+    @ReactMethod
+    fun allowUserInteraction(allowed: Boolean) {
+        NamiPaywallManager.allowPaywallInteraction(allow = allowed)
+    }
+
+    @ReactMethod fun addListener(eventName: String?) {}
+    @ReactMethod fun removeListeners(count: Int?) {}
+
+    private fun emitEvent(name: String, payload: Any?) {
+        val emitter = reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        emitter.emit(name, payload)
+    }
+}

package/android/src/main/java/com/namiml/reactnative/NamiPurchaseManagerBridge.kt

@@ -0,0 +1,107 @@
+package com.namiml.reactnative
+
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+import com.namiml.billing.NamiPurchaseManager
+
+@ReactModule(name = NamiPurchaseManagerBridgeModule.NAME)
+class NamiPurchaseManagerBridgeModule internal constructor(
+    private val reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext), TurboModule {
+
+    companion object {
+        const val NAME = "RNNamiPurchaseManager"
+    }
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    fun purchases(resultsCallback: Callback) {
+        reactContext.runOnUiQueueThread {
+            val purchases = NamiPurchaseManager.allPurchases()
+            val resultArray = WritableNativeArray()
+
+            purchases.forEach { purchase ->
+                try {
+                    resultArray.pushMap(purchase.toPurchaseDict())
+                } catch (e: Exception) {
+                    Log.e(NAME, "Error converting purchase to map", e)
+                }
+            }
+
+            resultsCallback.invoke(resultArray)
+        }
+    }
+
+    @ReactMethod
+    fun skuPurchased(skuID: String, promise: Promise) {
+        val isPurchased = NamiPurchaseManager.isSKUIDPurchased(skuID)
+        promise.resolve(isPurchased)
+    }
+
+    @ReactMethod
+    fun anySkuPurchased(skuIDs: ReadableArray, promise: Promise) {
+        reactContext.runOnUiQueueThread {
+            val checkArray = mutableListOf<String>()
+
+            for (i in 0 until skuIDs.size()) {
+                if (skuIDs.getType(i) == ReadableType.String) {
+                    skuIDs.getString(i)?.takeIf { it.isNotBlank() }?.let { checkArray.add(it) }
+                }
+            }
+
+            val anyPurchased = NamiPurchaseManager.anySKUIDPurchased(checkArray)
+            promise.resolve(anyPurchased)
+        }
+    }
+
+    @ReactMethod
+    fun restorePurchases(resultsCallback: Callback) {
+        Log.w(NAME, "Restore Purchases called on Android platform; no-op.")
+
+        val resultMap = WritableNativeMap().apply {
+            putBoolean("success", false)
+            putString(
+                "error",
+                "Google Play or Amazon Appstore on Android devices do not provide a restore purchases API."
+            )
+        }
+
+        resultsCallback.invoke(resultMap)
+    }
+
+    @ReactMethod
+    fun registerPurchasesChangedHandler() {
+        NamiPurchaseManager.registerPurchasesChangedHandler { purchases, purchaseState, error ->
+            val resultPurchases = WritableNativeArray().apply {
+                purchases.forEach {
+                    try {
+                        pushMap(it.toPurchaseDict())
+                    } catch (e: Exception) {
+                        Log.e(NAME, "Failed to map purchase", e)
+                    }
+                }
+            }
+
+            val payload = Arguments.createMap().apply {
+                putArray("purchases", resultPurchases)
+                putString("purchaseState", purchaseState.toString())
+                putString("error", error)
+            }
+
+            emitEvent("PurchasesChanged", payload)
+        }
+    }
+
+    private fun emitEvent(eventName: String, payload: WritableMap) {
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, payload)
+    }
+
+    @ReactMethod fun addListener(eventName: String?) {}
+    @ReactMethod fun removeListeners(count: Int?) {}
+}

package/android/src/main/java/com/{nami/reactlibrary → namiml/reactnative}/NamiUtil.kt

@@ -1,4 +1,4 @@
-package com.nami.reactlibrary
+package com.namiml.reactnative
 
 import android.util.Log
 import com.facebook.react.bridge.Arguments
@@ -15,6 +15,41 @@ import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
 import java.util.TimeZone
+import com.namiml.paywall.model.NamiPaywallAction
+
+fun NamiPaywallAction.toRNActionString(): String {
+    return when (this) {
+        NamiPaywallAction.NAMI_BUY_SKU -> "BUY_SKU"
+        NamiPaywallAction.NAMI_SELECT_SKU -> "SELECT_SKU"
+        NamiPaywallAction.NAMI_RESTORE_PURCHASES -> "RESTORE_PURCHASES"
+        NamiPaywallAction.NAMI_SHOW_PAYWALL -> "SHOW_PAYWALL"
+        NamiPaywallAction.NAMI_CLOSE_PAYWALL -> "CLOSE_PAYWALL"
+        NamiPaywallAction.NAMI_SIGN_IN -> "SIGN_IN"
+        NamiPaywallAction.NAMI_PURCHASE_SELECTED_SKU -> "PURCHASE_SELECTED_SKU"
+        NamiPaywallAction.NAMI_PURCHASE_SUCCESS -> "PURCHASE_SUCCESS"
+        NamiPaywallAction.NAMI_PURCHASE_FAILED -> "PURCHASE_FAILED"
+        NamiPaywallAction.NAMI_PURCHASE_CANCELLED -> "PURCHASE_CANCELLED"
+        NamiPaywallAction.NAMI_PURCHASE_PENDING -> "PURCHASE_PENDING"
+        NamiPaywallAction.NAMI_PURCHASE_UNKNOWN -> "PURCHASE_UNKNOWN"
+        NamiPaywallAction.NAMI_DEEP_LINK -> "DEEPLINK"
+        NamiPaywallAction.NAMI_TOGGLE_CHANGE -> "TOGGLE_CHANGE"
+        NamiPaywallAction.NAMI_PAGE_CHANGE -> "PAGE_CHANGE"
+        NamiPaywallAction.NAMI_SLIDE_CHANGE -> "SLIDE_CHANGE"
+        NamiPaywallAction.NAMI_COLLAPSIBLE_DRAWER_OPEN -> "COLLAPSIBLE_DRAWER_OPEN"
+        NamiPaywallAction.NAMI_COLLAPSIBLE_DRAWER_CLOSE -> "COLLAPSIBLE_DRAWER_CLOSE"
+        NamiPaywallAction.NAMI_VIDEO_STARTED -> "VIDEO_STARTED"
+        NamiPaywallAction.NAMI_VIDEO_PAUSED -> "VIDEO_PAUSED"
+        NamiPaywallAction.NAMI_VIDEO_RESUMED -> "VIDEO_RESUMED"
+        NamiPaywallAction.NAMI_VIDEO_ENDED -> "VIDEO_ENDED"
+        NamiPaywallAction.NAMI_VIDEO_CHANGED -> "VIDEO_CHANGED"
+        NamiPaywallAction.NAMI_VIDEO_MUTED -> "VIDEO_MUTED"
+        NamiPaywallAction.NAMI_VIDEO_UNMUTED -> "VIDEO_UNMUTED"
+        else -> {
+            Log.w("NamiUtil", "Unhandled NamiPaywallAction: $this. This might indicate a new enum value added in the SDK.")
+            "UNKNOWN"
+        }
+    }
+}
 
 fun List<*>.toWritableArray(): WritableArray {
     val convertedArray = Arguments.createArray()
@@ -74,47 +109,50 @@ fun Map<*, *>.toWritableMap(): WritableMap {
 }
 
 fun NamiSKU.toSkuDict(): WritableMap {
-    val productDict = Arguments.createMap()
+    val productDict = WritableNativeMap()
 
-    productDict.putString("skuId", this.skuId)
     productDict.putString("id", this.id)
-    productDict.putString("type", this.type.toString())
+    productDict.putString("skuId", this.skuId)
+    productDict.putString("name", this.name ?: "")
+    productDict.putString("type", this.type?.toString() ?: "unknown")
 
-    if (this.promoId != null) {
-        productDict.putString("promoId", this.promoId)
+    this.promoId?.let {
+        productDict.putString("promoId", it)
     }
 
-    if (this.promoOfferToken != null) {
-        productDict.putString("promoToken", this.promoOfferToken)
+    this.promoOfferToken?.let {
+        productDict.putString("promoToken", it)
     }
 
     return productDict
 }
 
-// Really needs to be a NamiPurchase, when exists...
 fun NamiPurchase.toPurchaseDict(): WritableMap {
     val purchaseMap = WritableNativeMap()
 
-    val purchaseSource = purchaseSource.toString()
-    purchaseMap.putString("purchaseSource", purchaseSource)
+    purchaseMap.putString("skuId", skuId)
+    purchaseMap.putString("transactionIdentifier", transactionIdentifier.orEmpty())
 
-    val skuDict = namiSku?.toSkuDict()
-    purchaseMap.putMap("sku", skuDict)
+    purchaseSource?.let {
+        purchaseMap.putString("purchaseSource", it.toString())
+    }
 
-    purchaseMap.putString("transactionIdentifier", transactionIdentifier.orEmpty())
-    purchaseMap.putString("skuId", skuId)
+    namiSku?.let { sku ->
+        val skuMap = WritableNativeMap()
+        skuMap.putString("id", sku.id)
+        skuMap.putString("skuId", sku.skuId)
+        skuMap.putString("name", sku.name ?: "")
+        skuMap.putString("type", sku.type?.toString() ?: "unknown") // match NamiSKUType
+        skuMap.putString("promoId", sku.promoId)
+        skuMap.putString("promoToken", sku.promoOfferToken)
+        purchaseMap.putMap("sku", skuMap)
+    }
 
     expires?.let {
-        purchaseMap.putString("expires", it.toJavascriptDate())
-    }
-    val initiatedTimestamp = purchaseInitiatedTimestamp
-    val purchaseInitiatedDate = Date(initiatedTimestamp)
-    purchaseInitiatedDate.let {
-        purchaseMap.putString("purchaseInitiatedTimestamp", it.toJavascriptDate())
+        purchaseMap.putDouble("expires", it.time.toDouble())
     }
 
-    // TODO: map kotlin dictionary into arbitrary map?
-    purchaseMap.putMap("platformMetadata", WritableNativeMap())
+    purchaseMap.putDouble("purchaseInitiatedTimestamp", purchaseInitiatedTimestamp.toDouble())
 
     return purchaseMap
 }

package/{index.d.ts → dist/index.d.ts}

@@ -1,9 +1,7 @@
 export { Nami } from './src/Nami';
-export { NamiMLManager } from './src/NamiMLManager';
 export { NamiCampaignManager } from './src/NamiCampaignManager';
 export { NamiCustomerManager } from './src/NamiCustomerManager';
 export { NamiEntitlementManager } from './src/NamiEntitlementManager';
-export { NamiManager } from './src/NamiManager';
 export { NamiPurchaseManager } from './src/NamiPurchaseManager';
 export { NamiPaywallManager } from './src/NamiPaywallManager';
 export { NamiFlowManager } from './src/NamiFlowManager';

package/dist/specs/NativeNami.d.ts

@@ -0,0 +1,16 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    configure(config: {
+        appPlatformID: string;
+        logLevel: string;
+        namiCommands?: string[];
+        namiLanguageCode?: string;
+        initialConfig?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    sdkConfigured(): Promise<boolean>;
+    sdkVersion(): Promise<string>;
+}
+declare const _default: Spec;
+export default _default;

package/dist/specs/NativeNamiCampaignManager.d.ts

@@ -0,0 +1,82 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    launch(label: string | null, withUrl: string | null, context: {
+        productGroups?: string[];
+        customAttributes?: {
+            [key: string]: string;
+        };
+        customObject?: {
+            [key: string]: unknown;
+        };
+    } | null, completion: (successAction: boolean, error: number | null) => void, paywallCompletion: (event: {
+        campaignId?: string;
+        campaignName?: string;
+        campaignType?: string;
+        campaignLabel?: string;
+        campaignUrl?: string;
+        paywallId?: string;
+        paywallName?: string;
+        segmentId?: string;
+        externalSegmentId?: string;
+        action: string;
+        sku?: {
+            id?: string;
+            name?: string;
+            skuId?: string;
+            type?: string;
+            promoId?: string;
+            promoToken?: string;
+        };
+        purchaseError?: string;
+        purchases?: Array<{
+            sku?: {
+                id: string;
+                skuId: string;
+                name: string;
+                type: string;
+            };
+            skuId: string;
+            transactionIdentifier?: string;
+            purchaseToken?: string;
+            expires?: number;
+            purchaseInitiatedTimestamp: number;
+            purchaseSource?: 'CAMPAIGN' | 'MARKETPLACE' | 'UNKNOWN';
+        }>;
+        deeplinkUrl?: string;
+        componentChange?: {
+            id?: string;
+            name?: string;
+        };
+        videoMetadata?: {
+            id?: string;
+            name?: string;
+            url?: string;
+            loopVideo?: boolean;
+            muteByDefault?: boolean;
+            autoplayVideo?: boolean;
+            contentTimecode?: string;
+            contentDuration?: string;
+        };
+        timeSpentOnPaywall?: number;
+    }) => void): void;
+    allCampaigns(): Promise<{
+        id?: string;
+        rule?: string;
+        segment?: string;
+        paywall?: string;
+        type: string;
+        value?: string;
+    }[]>;
+    isCampaignAvailable(source?: string): Promise<boolean>;
+    refresh(): Promise<{
+        id?: string;
+        rule?: string;
+        segment?: string;
+        paywall?: string;
+        type: string;
+        value?: string;
+    }[]>;
+    registerAvailableCampaignsHandler(): void;
+}
+declare const _default: Spec;
+export default _default;