react-native-test-adx 0.1.3 → 0.1.4

package/lib/module/AdaxonSdk.js

@@ -1,18 +1,16 @@
 "use strict";
 
 import { AdaxonClient } from "./core/AdaxonClient.js";
-import { MEDIATION_PROVIDER, OFFER_OPENED_EVENT } from "./config/ApiConstants.js";
+import { MEDIATION_PROVIDER, OFFER_OPENED_EVENT, RECOMMENDATION_VIEW_EVENT } from "./config/ApiConstants.js";
+import { dismissInterstitial, presentInterstitial } from "./components/InterstitialAd.js";
 import { AdaxonSdkError } from "./errors/AdaxonSdkError.js";
 import { detectReactNativePlatform, reactNativeAppInfoReader, reactNativeDeviceReader, reactNativeNetworkInfoReader, reactNativeNetworkStatusReader, reactNativeUrlOpener } from "./platform/reactNative.js";
 import { buildAddToCartProperties, buildPurchaseProperties, normalizeEventValues } from "./services/event/normalizeProperties.js";
 import { AdxEvent } from "./services/event/predefined.js";
 export class AdaxonSdk {
-  static sharedInstance = new AdaxonSdk();
+  static shared = new AdaxonSdk();
   client = null;
   testMode = false;
-  static get shared() {
-    return AdaxonSdk.sharedInstance;
-  }
   isInitialized() {
     return this.client !== null;
   }
@@ -70,58 +68,67 @@ export class AdaxonSdk {
   async trackCompleteRegistration(params = {}, options = {}) {
     return this.logEvent(AdxEvent.COMPLETE_REGISTRATION, params, options);
   }
-  async loadRecommendations(eventName, properties = {}, listener) {
+  async showAd() {
     try {
-      const response = await this.requireClient().getRecommendations({
-        eventName,
-        properties: {
-          ...properties,
-          mediation_provider: MEDIATION_PROVIDER,
-          test_mode: this.testMode
-        }
-      });
-      listener?.onRecommendationsLoaded(response.offers);
-      return response.offers;
-    } catch (error) {
-      const message = AdaxonSdkError.messageOf(error, 'Failed to load recommendations.');
-      const code = error instanceof AdaxonSdkError ? error.code : undefined;
-      listener?.onRecommendationsFailedToLoad(message, code);
-      throw error;
-    }
-  }
-  async showOffer(offer, listener) {
-    try {
-      const client = this.requireClient();
-      const targetUrl = offer.offer_url;
-      const canOpen = await reactNativeUrlOpener.canOpenURL(targetUrl);
-      if (!canOpen) {
-        throw new AdaxonSdkError('VALIDATION_ERROR', `Cannot open offer URL: ${targetUrl}`);
+      const offers = await this.loadRecommendations(RECOMMENDATION_VIEW_EVENT);
+      const offer = offers[0];
+      if (!offer) {
+        console.warn('[Adaxon] No offer available.');
+        return;
+      }
+      if (!this.displayInterstitial(offer)) {
+        console.warn('[Adaxon] Interstitial host is not mounted. Wrap the app in AdaxonProvider.');
       }
-      await reactNativeUrlOpener.openURL(targetUrl);
-      await client.track(OFFER_OPENED_EVENT, {
-        offer_id: offer.offer_id,
-        offer_name: offer.offer_name,
-        ad_type: offer.ad_type,
-        mediation_provider: MEDIATION_PROVIDER
-      });
-      listener?.onOfferOpened(offer);
     } catch (error) {
-      const message = AdaxonSdkError.messageOf(error, 'Failed to open offer.');
-      listener?.onOfferFailedToOpen(offer, message);
-      throw error;
+      console.warn('[Adaxon] Failed to show ad.', AdaxonSdkError.messageOf(error, 'Failed to show ad.'));
+      if (this.testMode) {
+        throw error;
+      }
     }
   }
-  setExternalUserId(externalUserId) {
-    this.requireClient().setExternalUserId(externalUserId);
-  }
   isNetworkAvailable() {
     return this.client?.isNetworkAvailable() ?? false;
   }
   destroy() {
+    dismissInterstitial();
     this.client?.destroy();
     this.client = null;
     this.testMode = false;
   }
+  async loadRecommendations(eventName, properties = {}) {
+    const response = await this.requireClient().getRecommendations({
+      eventName,
+      properties: {
+        ...properties,
+        mediation_provider: MEDIATION_PROVIDER,
+        test_mode: this.testMode
+      }
+    });
+    return response.offers;
+  }
+  displayInterstitial(offer) {
+    return presentInterstitial({
+      offer,
+      interact: () => {
+        this.openOfferUrl(offer).then(dismissInterstitial).catch(error => {
+          console.warn('[Adaxon] Failed to open offer URL.', AdaxonSdkError.messageOf(error, 'Failed to open offer.'));
+        });
+      }
+    });
+  }
+  async openOfferUrl(offer) {
+    const client = this.requireClient();
+    if (!(await reactNativeUrlOpener.canOpenURL(offer.offer_url))) {
+      throw new AdaxonSdkError('VALIDATION_ERROR', `Cannot open offer URL: ${offer.offer_url}`);
+    }
+    await reactNativeUrlOpener.openURL(offer.offer_url);
+    await client.track(OFFER_OPENED_EVENT, {
+      offer_id: offer.offer_id,
+      offer_name: offer.offer_name,
+      ad_type: offer.ad_type,
+      mediation_provider: MEDIATION_PROVIDER
+    });
+  }
   requireClient() {
     if (!this.client) {
       throw new AdaxonSdkError('INVALID_CONFIG', 'Adaxon SDK is not initialized. Call Adaxon.initialize(...) first.');

package/lib/module/components/AdaxonProvider.js

@@ -1,10 +1,12 @@
 "use strict";
 
 import { useEffect, useMemo, useRef, useState } from 'react';
+import { StyleSheet, View } from "../platform/reactNative.js";
 import { AdaxonSdk } from "../AdaxonSdk.js";
 import { AdaxonSdkError } from "../errors/AdaxonSdkError.js";
 import { AdaxonContext } from "../state/AdaxonContext.js";
-import { jsx as _jsx } from "react/jsx-runtime";
+import { InterstitialAd } from "./InterstitialAd.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export function AdaxonProvider({
   configuration,
   listener,
@@ -44,6 +46,14 @@ export function AdaxonProvider({
   }), [initializationError, isInitialized, sdk]);
   return /*#__PURE__*/_jsx(AdaxonContext.Provider, {
     value: value,
-    children: children
+    children: /*#__PURE__*/_jsxs(View, {
+      style: styles.root,
+      children: [children, /*#__PURE__*/_jsx(InterstitialAd, {})]
+    })
   });
-}
+}
+const styles = StyleSheet.create({
+  root: {
+    flex: 1
+  }
+});

package/lib/module/components/InterstitialAd.js

@@ -0,0 +1,279 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { BackHandler, Image, Platform, Pressable, SafeAreaView, StatusBar, StyleSheet, Text, View } from "../platform/reactNative.js";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+const CLOSE_EDGE_INSET = 12;
+const CLOSE_HIT_SIZE = 44;
+let listener = null;
+export function presentInterstitial(session) {
+  if (!listener) {
+    return false;
+  }
+  listener(session);
+  return true;
+}
+export function dismissInterstitial() {
+  listener?.(null);
+}
+const emptySafeAreaInsets = {
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0
+};
+function useEmptySafeAreaInsets() {
+  return emptySafeAreaInsets;
+}
+const useSafeAreaInsets = loadUseSafeAreaInsets() ?? useEmptySafeAreaInsets;
+function loadUseSafeAreaInsets() {
+  try {
+    const module = require('react-native-safe-area-context');
+    return typeof module.useSafeAreaInsets === 'function' ? module.useSafeAreaInsets : undefined;
+  } catch {
+    return undefined;
+  }
+}
+function useTopInset() {
+  const safeArea = useSafeAreaInsets();
+  if (safeArea.top > 0) {
+    return safeArea.top;
+  }
+  if (Platform.OS === 'android') {
+    return StatusBar.currentHeight ?? 0;
+  }
+  return 0;
+}
+export function InterstitialAd() {
+  const [session, setSession] = useState(null);
+  const [closeTone, setCloseTone] = useState('onLightSurface');
+  const safeArea = useSafeAreaInsets();
+  const topInset = useTopInset();
+  const offerId = session?.offer.offer_id;
+  useEffect(() => {
+    listener = setSession;
+    return () => {
+      if (listener === setSession) {
+        listener = null;
+      }
+    };
+  }, []);
+  useEffect(() => {
+    setCloseTone('onLightSurface');
+  }, [offerId]);
+  useEffect(() => {
+    if (!session) {
+      return;
+    }
+    const onBackPress = () => {
+      dismissInterstitial();
+      return true;
+    };
+    const subscription = BackHandler.addEventListener('hardwareBackPress', onBackPress);
+    return () => subscription.remove();
+  }, [session]);
+  if (!session) {
+    return null;
+  }
+  const {
+    offer,
+    interact
+  } = session;
+  const closeAppearance = closeButtonAppearance(closeTone);
+  const closeRightInset = Platform.OS === 'android' ? CLOSE_EDGE_INSET + safeArea.right : CLOSE_EDGE_INSET;
+  const adFrame = /*#__PURE__*/_jsx(_Fragment, {
+    children: /*#__PURE__*/_jsxs(View, {
+      style: styles.adContainer,
+      children: [/*#__PURE__*/_jsx(Pressable, {
+        accessibilityRole: "button",
+        accessibilityLabel: "Close ad",
+        onPress: dismissInterstitial,
+        style: [styles.closeButton, closeAppearance.button, {
+          top: CLOSE_EDGE_INSET,
+          right: closeRightInset
+        }],
+        testID: "adaxon-interstitial-close",
+        children: /*#__PURE__*/_jsx(Text, {
+          style: [styles.closeLabel, closeAppearance.label],
+          children: "\xD7"
+        })
+      }), /*#__PURE__*/_jsx(Pressable, {
+        accessibilityRole: "button",
+        accessibilityLabel: offer.offer_name,
+        onPress: interact,
+        style: styles.offer,
+        testID: "adaxon-interstitial-offer",
+        children: /*#__PURE__*/_jsx(OfferCreative, {
+          offer: offer,
+          onCloseToneChange: setCloseTone
+        })
+      })]
+    })
+  });
+  return /*#__PURE__*/_jsx(View, {
+    style: styles.overlay,
+    testID: "adaxon-interstitial",
+    children: Platform.OS === 'ios' ? /*#__PURE__*/_jsx(SafeAreaView, {
+      style: styles.safeFrame,
+      children: adFrame
+    }) : /*#__PURE__*/_jsx(View, {
+      style: [styles.safeFrame, {
+        paddingTop: topInset
+      }],
+      children: adFrame
+    })
+  });
+}
+function OfferCreative({
+  offer,
+  onCloseToneChange
+}) {
+  const imageUrl = remoteImageUrl(offer.creative_url) ?? remoteImageUrl(offer.preview_url);
+  const [failed, setFailed] = useState(false);
+  useEffect(() => {
+    setFailed(false);
+  }, [imageUrl]);
+  useEffect(() => {
+    if (!imageUrl || failed) {
+      onCloseToneChange('onDarkSurface');
+      return;
+    }
+    onCloseToneChange('onLightSurface');
+  }, [failed, imageUrl, onCloseToneChange]);
+  if (!imageUrl || failed) {
+    return /*#__PURE__*/_jsx(View, {
+      style: styles.fallback,
+      testID: "adaxon-interstitial-fallback",
+      children: /*#__PURE__*/_jsx(Text, {
+        style: styles.offerName,
+        children: offer.offer_name
+      })
+    });
+  }
+  return /*#__PURE__*/_jsx(Image, {
+    source: {
+      uri: imageUrl
+    },
+    style: styles.creativeImage,
+    resizeMode: "contain",
+    onError: () => setFailed(true),
+    testID: "adaxon-interstitial-image"
+  });
+}
+function closeButtonAppearance(tone) {
+  if (tone === 'onDarkSurface') {
+    return {
+      button: {
+        backgroundColor: 'rgba(255, 255, 255, 0.94)',
+        borderColor: 'rgba(0, 0, 0, 0.35)'
+      },
+      label: {
+        color: '#111111',
+        textShadowColor: 'rgba(255, 255, 255, 0.85)',
+        textShadowRadius: 2
+      }
+    };
+  }
+  return {
+    button: {
+      backgroundColor: 'rgba(0, 0, 0, 0.62)',
+      borderColor: 'rgba(255, 255, 255, 0.55)'
+    },
+    label: {
+      color: '#ffffff',
+      textShadowColor: 'rgba(0, 0, 0, 0.75)',
+      textShadowRadius: 3
+    }
+  };
+}
+function remoteImageUrl(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    const url = new URL(trimmed);
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+      return null;
+    }
+    return trimmed;
+  } catch {
+    return null;
+  }
+}
+const styles = StyleSheet.create({
+  overlay: {
+    position: 'absolute',
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    zIndex: 9999,
+    elevation: 9999,
+    backgroundColor: '#000000'
+  },
+  safeFrame: {
+    flex: 1,
+    width: '100%'
+  },
+  adContainer: {
+    flex: 1,
+    width: '100%',
+    position: 'relative'
+  },
+  closeButton: {
+    position: 'absolute',
+    zIndex: 2,
+    minWidth: CLOSE_HIT_SIZE,
+    minHeight: CLOSE_HIT_SIZE,
+    width: CLOSE_HIT_SIZE,
+    height: CLOSE_HIT_SIZE,
+    alignItems: 'center',
+    justifyContent: 'center',
+    borderRadius: CLOSE_HIT_SIZE / 2,
+    borderWidth: 1.5,
+    shadowColor: '#000000',
+    shadowOffset: {
+      width: 0,
+      height: 2
+    },
+    shadowOpacity: 0.45,
+    shadowRadius: 4,
+    elevation: 8
+  },
+  closeLabel: {
+    fontSize: 32,
+    lineHeight: 36,
+    textShadowOffset: {
+      width: 0,
+      height: 0
+    }
+  },
+  offer: {
+    flex: 1,
+    width: '100%',
+    alignSelf: 'stretch',
+    overflow: 'hidden'
+  },
+  creativeImage: {
+    position: 'absolute',
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    width: '100%',
+    height: '100%'
+  },
+  fallback: {
+    flex: 1,
+    width: '100%',
+    alignItems: 'center',
+    justifyContent: 'center',
+    paddingHorizontal: 24
+  },
+  offerName: {
+    color: '#ffffff',
+    fontSize: 22,
+    textAlign: 'center'
+  }
+});

package/lib/module/config/ApiConstants.js

@@ -1,12 +1,14 @@
 "use strict";
 
-export const SDK_VERSION = '0.1.3';
+import packageJson from '../../package.json';
+export const SDK_VERSION = packageJson.version;
 export const MEDIATION_PROVIDER = 'mts';
 export const BASE_URL = 'http://localhost:3002';
 export const EVENT_TRACKING_PATH = '/event/tracking';
 export const RECOMMENDATIONS_PATH = '/api/mts/recommendations';
 export const CLICK_TRACKING_PATH = '/click/tracking';
 export const OFFER_OPENED_EVENT = 'offer_opened';
+export const RECOMMENDATION_VIEW_EVENT = 'recommendation_view';
 export const DEFAULT_TIMEOUT_MS = 10_000;
 export const PUBLIC_IP_LOOKUP_URL = 'https://api.ipify.org?format=json';
 export const PUBLIC_IP_LOOKUP_TIMEOUT_MS = 2_000;

package/lib/module/core/AdaxonClient.js

@@ -29,8 +29,7 @@ export class AdaxonClient {
       deviceInfo: new DeviceInfoService(config.platform ?? 'web', config.deviceInfoReader, config.storage, auth.appId),
       appInfo: new AppInfoService(Boolean(config.testMode), config.appInfoReader),
       networkInfo,
-      validator: this.validator,
-      externalUserId: config.externalUserId
+      validator: this.validator
     });
     this.events = new EventService({
       api,
@@ -115,9 +114,6 @@ export class AdaxonClient {
     });
     return `${BASE_URL}${CLICK_TRACKING_PATH}?${query}`;
   }
-  setExternalUserId(externalUserId) {
-    this.builder.setExternalUserId(externalUserId);
-  }
   toQueryString(params) {
     return Object.entries(params).filter(([, value]) => value !== undefined).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join('&');
   }

package/lib/module/hooks/useAdaxon.js

@@ -23,9 +23,7 @@ export function useAdaxon() {
     trackAddToCart: sdk.trackAddToCart.bind(sdk),
     trackLogin: sdk.trackLogin.bind(sdk),
     trackCompleteRegistration: sdk.trackCompleteRegistration.bind(sdk),
-    loadRecommendations: sdk.loadRecommendations.bind(sdk),
-    showOffer: sdk.showOffer.bind(sdk),
-    setExternalUserId: sdk.setExternalUserId.bind(sdk)
+    showAd: sdk.showAd.bind(sdk)
   }), [sdk]);
   return {
     isInitialized,

package/lib/module/platform/app.js

@@ -1,12 +1,53 @@
 "use strict";
 
 import { nonEmptyString, setIfPresent } from "../utils/strings.js";
-export function appFieldsFromNative(constants) {
+export function appFieldsFromNative(...sources) {
+  const value = key => lastPresent(sources, key);
+  const expo = expoConfig(value('expoConfig'), value('manifest'), value('extra'));
   const fields = {};
-  setIfPresent(fields, 'package_name', firstNonEmpty(constants.applicationId, constants.bundleId, constants.androidPackage, constants.iosBundleIdentifier));
-  setIfPresent(fields, 'app_version', firstNonEmpty(constants.nativeApplicationVersion, constants.appVersion, constants.nativeAppVersion));
+  setIfPresent(fields, 'package_name', firstNonEmpty(value('applicationId'), value('bundleId'), value('packageName'), value('androidPackage'), value('iosBundleIdentifier'), asRecord(value('android'))?.package, asRecord(value('ios'))?.bundleIdentifier, asRecord(expo?.android)?.package, asRecord(expo?.ios)?.bundleIdentifier));
+  setIfPresent(fields, 'app_version', firstNonEmpty(value('nativeApplicationVersion'), value('appVersion'), value('nativeAppVersion'), value('version'), expo?.version));
   return fields;
 }
+function expoConfig(expoConfigValue, manifestValue, extraValue) {
+  const manifest = asRecord(manifestValue);
+  return firstRecord(expoConfigValue, asRecord(manifest?.extra)?.expoClient, manifest?.expoClient, manifest, asRecord(extraValue)?.expoClient);
+}
+function lastPresent(sources, key) {
+  let found;
+  for (const source of sources) {
+    if (!source) {
+      continue;
+    }
+    const next = source[key];
+    if (next != null && next !== '') {
+      found = next;
+    }
+  }
+  return found;
+}
+function firstRecord(...values) {
+  for (const value of values) {
+    const record = asRecord(value);
+    if (record) {
+      return record;
+    }
+  }
+  return undefined;
+}
+function asRecord(value) {
+  if (typeof value === 'string') {
+    try {
+      return asRecord(JSON.parse(value));
+    } catch {
+      return undefined;
+    }
+  }
+  if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+    return value;
+  }
+  return undefined;
+}
 function firstNonEmpty(...values) {
   for (const value of values) {
     const next = nonEmptyString(value);

package/lib/module/platform/reactNative.js

@@ -1,14 +1,23 @@
 "use strict";
 
 import { Linking, NativeEventEmitter, NativeModules, Platform } from 'react-native';
+export { BackHandler, Dimensions, Image, Modal, Platform, Pressable, SafeAreaView, StatusBar, StyleSheet, Text, View } from 'react-native';
 import { nonEmptyString, setIfPresent } from "../utils/strings.js";
 import { readLocaleFields } from "../utils/locale.js";
 import { appFieldsFromNative } from "./app.js";
 import { deviceFieldsFromAndroid } from "./android.js";
 import { deviceFieldsFromIos } from "./ios.js";
 import { connectionTypeFromNativeState, ipAddressFromNativeState, isOnlineFromNativeState, usableIpAddress } from "./network.js";
+function expoNativeModule(name) {
+  try {
+    const expoGlobal = globalThis;
+    return expoGlobal.expo?.modules?.[name];
+  } catch {
+    return undefined;
+  }
+}
 function nativeModule(name) {
-  return (NativeModules ?? {})[name];
+  return (NativeModules ?? {})[name] ?? expoNativeModule(name);
 }
 async function callNative(method, arg) {
   if (typeof method !== 'function') {
@@ -53,13 +62,6 @@ async function readUniqueIdFromNative() {
   const deviceInfo = nativeModule('RNDeviceInfo');
   return nonEmptyString(await callNative(deviceInfo?.getUniqueId)) ?? '';
 }
-function readNativeAppConstants() {
-  return {
-    ...nativeModule('RNDeviceInfo'),
-    ...nativeModule('ExponentConstants'),
-    ...nativeModule('ExpoApplication')
-  };
-}
 function nativeNetworkModules() {
   return {
     netInfo: nativeModule('RNCNetInfo'),
@@ -121,7 +123,7 @@ export const reactNativeDeviceReader = {
   getUniqueId: readUniqueIdFromNative
 };
 export const reactNativeAppInfoReader = {
-  readAppInfo: () => appFieldsFromNative(readNativeAppConstants())
+  readAppInfo: () => appFieldsFromNative(nativeModule('RNDeviceInfo'), nativeModule('ExponentConstants'), nativeModule('ExpoApplication'))
 };
 export const reactNativeNetworkInfoReader = {
   readNetworkInfo: collectFromNativeNetwork

package/lib/module/services/event/EventBuilder.js

@@ -1,15 +1,10 @@
 "use strict";
 
 import { createUuid } from "../../utils/uuid.js";
-import { nonEmptyString, setIfPresent } from "../../utils/strings.js";
 export class EventBuilder {
   sessionId = createUuid();
   constructor(config) {
     this.config = config;
-    this.externalUserId = config.externalUserId;
-  }
-  setExternalUserId(externalUserId) {
-    this.externalUserId = externalUserId;
   }
   async build(input) {
     const {
@@ -23,7 +18,6 @@ export class EventBuilder {
     const user = {
       anonymous_id: await deviceInfo.getUniqueId()
     };
-    setIfPresent(user, 'external_user_id', nonEmptyString(this.externalUserId));
     return {
       event_id: input.eventId ?? createUuid(),
       event_name: input.eventName,

package/lib/module/services/event/EventService.js

@@ -19,11 +19,13 @@ export class EventService {
   }
   async getRecommendations(input) {
     const eventPayload = await this.builder.build(input);
-    const payload = {
-      ...eventPayload,
-      event_type: 'recommendation'
-    };
-    const response = await this.api.post(RECOMMENDATIONS_PATH, payload);
+    await this.postEvents([eventPayload]);
+    const response = await this.api.post(RECOMMENDATIONS_PATH, {
+      app_id: eventPayload.app_id,
+      device: {
+        platform: eventPayload.device.platform
+      }
+    });
     if (!Array.isArray(response.offers)) {
       throw new AdaxonSdkError('HTTP_ERROR', 'Adaxon recommendation response is missing the offers array.');
     }

package/lib/module/types/AdaxonConfig.js

@@ -1,3 +1 @@
-"use strict";
-
-export {};
+"use strict";

package/lib/typescript/src/AdaxonSdk.d.ts

@@ -1,13 +1,12 @@
 import { type TrackAddToCartParams, type TrackCompleteRegistrationParams, type TrackLoginParams, type TrackPurchaseParams } from './services/event/normalizeProperties.js';
-import type { AdaxonInitializationConfiguration, AdaxonInitializationListener, AdaxonOfferShowListener, AdaxonRecommendationLoadListener } from './types/AdaxonConfig.js';
-import type { EventIngestionResponse, RecommendationOffer } from './types/ApiTypes.js';
+import type { AdaxonInitializationConfiguration, AdaxonInitializationListener } from './types/AdaxonConfig.js';
+import type { EventIngestionResponse } from './types/ApiTypes.js';
 import type { EventProperties, TrackEventInput, TrackEventOptions } from './types/EventTypes.js';
 import type { BatchProcessResult } from './types/QueuedEvent.js';
 export declare class AdaxonSdk {
-    private static readonly sharedInstance;
+    static readonly shared: AdaxonSdk;
     private client;
     private testMode;
-    static get shared(): AdaxonSdk;
     isInitialized(): boolean;
     initialize(configuration: AdaxonInitializationConfiguration, listener?: AdaxonInitializationListener): Promise<void>;
     track(eventName: string, properties?: EventProperties, options?: TrackEventOptions): Promise<EventIngestionResponse>;
@@ -19,11 +18,12 @@ export declare class AdaxonSdk {
     trackAddToCart(params: TrackAddToCartParams, options?: TrackEventOptions): Promise<EventIngestionResponse>;
     trackLogin(params?: TrackLoginParams, options?: TrackEventOptions): Promise<EventIngestionResponse>;
     trackCompleteRegistration(params?: TrackCompleteRegistrationParams, options?: TrackEventOptions): Promise<EventIngestionResponse>;
-    loadRecommendations(eventName: string, properties?: EventProperties, listener?: AdaxonRecommendationLoadListener): Promise<RecommendationOffer[]>;
-    showOffer(offer: RecommendationOffer, listener?: AdaxonOfferShowListener): Promise<void>;
-    setExternalUserId(externalUserId?: string): void;
+    showAd(): Promise<void>;
     isNetworkAvailable(): boolean;
     destroy(): void;
+    private loadRecommendations;
+    private displayInterstitial;
+    private openOfferUrl;
     private requireClient;
 }
 //# sourceMappingURL=AdaxonSdk.d.ts.map