react-native-test-adx 0.1.6 → 0.1.8

package/lib/module/AdaxonSdk.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import { AdaxonClient } from "./core/AdaxonClient.js";
-import { MEDIATION_PROVIDER, OFFER_OPENED_EVENT, RECOMMENDATION_VIEW_EVENT } from "./config/ApiConstants.js";
-import { dismissInterstitial, presentInterstitial } from "./components/InterstitialAd.js";
+import { CREATIVE_CLICK_EVENT, CREATIVE_VIEW_EVENT, MEDIATION_PROVIDER, RECOMMENDATION_EVENT_TYPE } from "./config/ApiConstants.js";
+import { dismissInterstitial, dismissOfferBrowser, presentInterstitial, presentOfferBrowser } 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";
@@ -70,7 +70,10 @@ export class AdaxonSdk {
   }
   async showAd(options = {}) {
     try {
-      const offers = await this.loadRecommendations(RECOMMENDATION_VIEW_EVENT);
+      const {
+        offers,
+        requestEventId
+      } = await this.loadRecommendations();
       if (offers.length === 0) {
         console.warn('[Adaxon] No offer available.');
         return {
@@ -91,10 +94,8 @@ export class AdaxonSdk {
         const displayed = presentInterstitial({
           offer,
           interact: () => {
-            options.onOfferClicked?.(offer.offer_id);
-            this.openOfferUrl(offer).then(() => dismissInterstitial('click')).catch(error => {
+            this.openOfferUrl(offer, requestEventId).then(() => options.onOfferClicked?.(offer.offer_id)).catch(error => {
               console.warn('[Adaxon] Failed to open offer URL.', AdaxonSdkError.messageOf(error, 'Failed to open offer.'));
-              dismissInterstitial('close');
             });
           },
           onDismiss: dismissReason => {
@@ -111,7 +112,9 @@ export class AdaxonSdk {
             shown: false,
             reason: 'not_mounted'
           });
+          return;
         }
+        this.trackRecommendationEvent(CREATIVE_VIEW_EVENT, requestEventId).catch(() => undefined);
       });
     } catch (error) {
       console.warn('[Adaxon] Failed to show ad.', AdaxonSdkError.messageOf(error, 'Failed to show ad.'));
@@ -129,33 +132,35 @@ export class AdaxonSdk {
   }
   destroy() {
     dismissInterstitial();
+    dismissOfferBrowser();
     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
-      }
+  loadRecommendations() {
+    return this.requireClient().getRecommendations({
+      mediation_provider: MEDIATION_PROVIDER,
+      test_mode: this.testMode
     });
-    return response.offers;
   }
-  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}`);
+  async openOfferUrl(offer, parentEventId) {
+    await this.trackRecommendationEvent(CREATIVE_CLICK_EVENT, parentEventId);
+    if (presentOfferBrowser(offer.offer_url)) {
+      return;
     }
     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
-    });
+    dismissInterstitial('click');
+  }
+  async trackRecommendationEvent(eventName, parentEventId) {
+    try {
+      await this.requireClient().track(eventName, {
+        parent_event_id: parentEventId
+      }, {
+        eventType: RECOMMENDATION_EVENT_TYPE
+      });
+    } catch (error) {
+      console.warn(`[Adaxon] Failed to log ${eventName}.`, AdaxonSdkError.messageOf(error, `Failed to log ${eventName}.`));
+    }
   }
   requireClient() {
     if (!this.client) {

package/lib/module/components/InterstitialAd.js

@@ -1,12 +1,35 @@
 "use strict";
 
 import { useEffect, useState } from 'react';
-import { BackHandler, Image, Platform, Pressable, SafeAreaView, StatusBar, StyleSheet, Text, View } from "../platform/reactNative.js";
+import { BackHandler, Image, Platform, Pressable, SafeAreaView, StatusBar, StyleSheet, Text, View, reactNativeUrlOpener } 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;
+function loadInAppBrowser() {
+  try {
+    const module = require('react-native-webview');
+    return module.WebView ?? null;
+  } catch {
+    return null;
+  }
+}
+const InAppBrowserView = loadInAppBrowser();
 let listener = null;
 let activeSession = null;
+let browserListener = null;
+let activeBrowserUrl = null;
+export function presentOfferBrowser(url) {
+  if (!browserListener || !InAppBrowserView) {
+    return false;
+  }
+  activeBrowserUrl = url;
+  browserListener(url);
+  return true;
+}
+export function dismissOfferBrowser() {
+  activeBrowserUrl = null;
+  browserListener?.(null);
+}
 export function presentInterstitial(session) {
   if (!listener) {
     return false;
@@ -51,83 +74,137 @@ function useTopInset() {
 }
 export function InterstitialAd() {
   const [session, setSession] = useState(null);
+  const [browserUrl, setBrowserUrl] = useState(null);
+  const [offerPageVisible, setOfferPageVisible] = useState(false);
   const [closeTone, setCloseTone] = useState('onLightSurface');
   const safeArea = useSafeAreaInsets();
   const topInset = useTopInset();
   const offerId = session?.offer.offer_id;
   useEffect(() => {
     listener = setSession;
+    browserListener = setBrowserUrl;
+    setBrowserUrl(activeBrowserUrl);
     return () => {
       if (listener === setSession) {
         listener = null;
       }
+      if (browserListener === setBrowserUrl) {
+        browserListener = null;
+      }
     };
   }, []);
   useEffect(() => {
     setCloseTone('onLightSurface');
   }, [offerId]);
   useEffect(() => {
-    if (!session) {
+    setOfferPageVisible(false);
+  }, [browserUrl]);
+  useEffect(() => {
+    if (!session && !browserUrl) {
       return;
     }
     const onBackPress = () => {
-      dismissInterstitial('back');
+      dismissOfferBrowser();
+      if (session && !offerPageVisible) {
+        dismissInterstitial('back');
+      }
       return true;
     };
     const subscription = BackHandler.addEventListener('hardwareBackPress', onBackPress);
     return () => subscription.remove();
-  }, [session]);
-  if (!session) {
+  }, [browserUrl, offerPageVisible, session]);
+  if (!session && !browserUrl) {
     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('close'),
-        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
-        })
-      })]
+  const closeButton = (label, onPress, testID) => /*#__PURE__*/_jsx(Pressable, {
+    accessibilityRole: "button",
+    accessibilityLabel: label,
+    onPress: onPress,
+    style: [styles.closeButton, closeAppearance.button, {
+      top: CLOSE_EDGE_INSET,
+      right: closeRightInset
+    }],
+    testID: testID,
+    children: /*#__PURE__*/_jsx(Text, {
+      style: [styles.closeLabel, closeAppearance.label],
+      children: "\xD7"
     })
   });
-  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, {
+  const adFrame = session ? /*#__PURE__*/_jsxs(View, {
+    style: styles.adContainer,
+    children: [/*#__PURE__*/_jsx(Pressable, {
+      accessibilityRole: "button",
+      accessibilityLabel: session.offer.offer_name,
+      onPress: session.interact,
+      style: styles.offer,
+      testID: "adaxon-interstitial-offer",
+      children: /*#__PURE__*/_jsx(OfferCreative, {
+        offer: session.offer,
+        onCloseToneChange: setCloseTone
+      })
+    }), closeButton('Close ad', () => {
+      dismissOfferBrowser();
+      dismissInterstitial('close');
+    }, 'adaxon-interstitial-close')]
+  }) : null;
+  const onOfferNavigation = request => {
+    const externalUrl = externalAppUrl(request.url);
+    if (!externalUrl) {
+      return true;
+    }
+    reactNativeUrlOpener.openURL(externalUrl).catch(() => undefined);
+    dismissOfferBrowser();
+    dismissInterstitial('click');
+    return false;
+  };
+  const onOfferPage = state => {
+    if (state.loading || !state.url || !browserUrl) {
+      return;
+    }
+    setOfferPageVisible(true);
+    dismissInterstitial('click');
+  };
+  const offerBrowser = InAppBrowserView && browserUrl ? /*#__PURE__*/_jsx(InAppBrowserView, {
+    source: {
+      uri: browserUrl
+    },
+    pointerEvents: offerPageVisible ? 'auto' : 'none',
+    style: offerPageVisible ? styles.browser : styles.hiddenBrowser,
+    originWhitelist: ['*'],
+    onShouldStartLoadWithRequest: onOfferNavigation,
+    onNavigationStateChange: onOfferPage,
+    testID: "adaxon-interstitial-browser"
+  }) : null;
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [offerBrowser && !offerPageVisible ? offerBrowser : null, session ? /*#__PURE__*/_jsx(View, {
+      style: styles.overlay,
+      testID: "adaxon-interstitial",
+      children: framed(adFrame)
+    }) : null, offerBrowser && offerPageVisible ? /*#__PURE__*/_jsx(View, {
+      style: styles.overlay,
+      testID: "adaxon-offer-browser",
+      children: framed(/*#__PURE__*/_jsxs(View, {
+        style: styles.adContainer,
+        children: [offerBrowser, closeButton('Close offer', dismissOfferBrowser, 'adaxon-offer-close')]
+      }))
+    }) : null]
+  });
+  function framed(content) {
+    if (Platform.OS === 'ios') {
+      return /*#__PURE__*/_jsx(SafeAreaView, {
+        style: styles.safeFrame,
+        children: content
+      });
+    }
+    return /*#__PURE__*/_jsx(View, {
       style: [styles.safeFrame, {
         paddingTop: topInset
       }],
-      children: adFrame
-    })
-  });
+      children: content
+    });
+  }
 }
 function OfferCreative({
   offer,
@@ -191,6 +268,37 @@ function closeButtonAppearance(tone) {
     }
   };
 }
+function externalAppUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed || trimmed === 'about:blank') {
+    return null;
+  }
+  let protocol = '';
+  try {
+    protocol = new URL(trimmed).protocol;
+  } catch {
+    return null;
+  }
+  if (protocol === 'http:' || protocol === 'https:' || protocol === 'about:' || protocol === 'blob:' || protocol === 'data:') {
+    return null;
+  }
+  if (protocol === 'intent:') {
+    return intentTarget(trimmed);
+  }
+  return trimmed;
+}
+function intentTarget(url) {
+  const fallback = /S\.browser_fallback_url=([^;]+)/.exec(url)?.[1];
+  if (fallback) {
+    return decodeURIComponent(fallback);
+  }
+  const scheme = /scheme=([^;]+)/.exec(url)?.[1];
+  const path = url.slice('intent:'.length).split('#')[0];
+  if (!scheme || !path) {
+    return url;
+  }
+  return `${scheme}:${path}`;
+}
 function remoteImageUrl(value) {
   const trimmed = value?.trim();
   if (!trimmed) {
@@ -260,6 +368,20 @@ const styles = StyleSheet.create({
     alignSelf: 'stretch',
     overflow: 'hidden'
   },
+  browser: {
+    flex: 1,
+    width: '100%',
+    backgroundColor: '#ffffff'
+  },
+  hiddenBrowser: {
+    position: 'absolute',
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    opacity: 0,
+    zIndex: 0
+  },
   creativeImage: {
     position: 'absolute',
     top: 0,

package/lib/module/config/ApiConstants.js

@@ -8,8 +8,11 @@ export const BASE_URL = 'https://mts-tracking.mobupps.com';
 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 RECOMMENDATION_EVENT_TYPE = 'recommendation';
+export const RECOMMENDATION_REQUEST_EVENT = 'recommendation_request';
+export const RECOMMENDATION_RESPONSE_EVENT = 'recommendation_response';
+export const CREATIVE_VIEW_EVENT = 'creative_view';
+export const CREATIVE_CLICK_EVENT = 'creative_click';
 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

@@ -95,8 +95,8 @@ export class AdaxonClient {
   processPendingEvents() {
     return this.batchProcessor.process();
   }
-  getRecommendations(input) {
-    return this.events.getRecommendations(input);
+  getRecommendations(properties = {}) {
+    return this.events.getRecommendations(properties);
   }
   createClickUrl(attribution) {
     this.validator.validateClickAttribution(attribution);

package/lib/module/index.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { AdaxonSdk } from "./AdaxonSdk.js";
+export { BASE_URL } from "./config/ApiConstants.js";
 export { AdaxonProvider } from "./components/AdaxonProvider.js";
 export { useAdaxon } from "./hooks/useAdaxon.js";
 export { AdaxonSdk };

package/lib/module/sdkVersion.js

@@ -1,4 +1,4 @@
 "use strict";
 
 /** Keep in sync with package.json "version" (published npm packages ship lib/ only). */
-export const SDK_VERSION = '0.1.6';
+export const SDK_VERSION = '0.1.8';

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

@@ -18,7 +18,7 @@ export class EventBuilder {
     const user = {
       anonymous_id: await deviceInfo.getUniqueId()
     };
-    return {
+    const payload = {
       event_id: input.eventId ?? createUuid(),
       event_name: input.eventName,
       event_time: input.eventTime ?? new Date().toISOString(),
@@ -32,5 +32,9 @@ export class EventBuilder {
       },
       network: await networkInfo.getNetworkInfo()
     };
+    if (input.eventType) {
+      payload.event_type = input.eventType;
+    }
+    return payload;
   }
 }

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

@@ -1,6 +1,6 @@
 "use strict";
 
-import { EVENT_TRACKING_PATH, RECOMMENDATIONS_PATH } from "../../config/ApiConstants.js";
+import { EVENT_TRACKING_PATH, RECOMMENDATION_EVENT_TYPE, RECOMMENDATION_REQUEST_EVENT, RECOMMENDATION_RESPONSE_EVENT, RECOMMENDATIONS_PATH } from "../../config/ApiConstants.js";
 import { AdaxonSdkError } from "../../errors/AdaxonSdkError.js";
 export class EventService {
   constructor(config) {
@@ -17,19 +17,33 @@ export class EventService {
     this.validator.validateBatch(payloads);
     return this.postEvents(payloads);
   }
-  async getRecommendations(input) {
-    const eventPayload = await this.builder.build(input);
-    await this.postEvents([eventPayload]);
+  async getRecommendations(properties = {}) {
+    const requestEvent = await this.builder.build({
+      eventName: RECOMMENDATION_REQUEST_EVENT,
+      eventType: RECOMMENDATION_EVENT_TYPE,
+      properties
+    });
+    await this.postEvents([requestEvent]);
     const response = await this.api.post(RECOMMENDATIONS_PATH, {
-      app_id: eventPayload.app_id,
+      app_id: requestEvent.app_id,
       device: {
-        platform: eventPayload.device.platform
+        platform: requestEvent.device.platform
       }
     });
     if (!Array.isArray(response.offers)) {
       throw new AdaxonSdkError('HTTP_ERROR', 'Adaxon recommendation response is missing the offers array.');
     }
-    return response;
+    await this.postEvents([await this.builder.build({
+      eventName: RECOMMENDATION_RESPONSE_EVENT,
+      eventType: RECOMMENDATION_EVENT_TYPE,
+      properties: {
+        parent_event_id: requestEvent.event_id
+      }
+    })]);
+    return {
+      offers: response.offers,
+      requestEventId: requestEvent.event_id
+    };
   }
   postEvents(payloads) {
     return this.api.post(EVENT_TRACKING_PATH, payloads);

package/lib/module/validation/EventValidator.js

@@ -12,6 +12,9 @@ export class EventValidator {
   }
   validateTrackInput(input) {
     this.validateEventName(input.eventName);
+    if (input.eventType) {
+      this.validateEventName(input.eventType, 'eventType');
+    }
     this.validateProperties(input.properties ?? {});
     if (input.eventId && !UUID_PATTERN.test(input.eventId)) {
       this.fail('eventId must be a valid UUID.');
@@ -20,9 +23,9 @@ export class EventValidator {
       this.fail('eventTime must be a valid ISO 8601 datetime string.');
     }
   }
-  validateEventName(eventName) {
+  validateEventName(eventName, label = 'eventName') {
     if (!eventName || eventName.length > MAX_EVENT_NAME_LENGTH || !EVENT_NAME_PATTERN.test(eventName)) {
-      this.fail(`eventName must start with a letter, contain only letters, numbers, and underscores, and be at most ${MAX_EVENT_NAME_LENGTH} characters.`);
+      this.fail(`${label} must start with a letter, contain only letters, numbers, and underscores, and be at most ${MAX_EVENT_NAME_LENGTH} characters.`);
     }
   }
   validateProperties(properties) {

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

@@ -37,6 +37,7 @@ export declare class AdaxonSdk {
     destroy(): void;
     private loadRecommendations;
     private openOfferUrl;
+    private trackRecommendationEvent;
     private requireClient;
 }
 //# sourceMappingURL=AdaxonSdk.d.ts.map

package/lib/typescript/src/components/InterstitialAd.d.ts

@@ -5,6 +5,8 @@ export interface InterstitialAdSession {
     interact: () => void;
     onDismiss?: (reason: InterstitialDismissReason) => void;
 }
+export declare function presentOfferBrowser(url: string): boolean;
+export declare function dismissOfferBrowser(): void;
 export declare function presentInterstitial(session: InterstitialAdSession): boolean;
 export declare function dismissInterstitial(reason?: InterstitialDismissReason): void;
 export declare function InterstitialAd(): import("react").JSX.Element | null;

package/lib/typescript/src/config/ApiConstants.d.ts

@@ -4,8 +4,11 @@ export declare const BASE_URL = "https://mts-tracking.mobupps.com";
 export declare const EVENT_TRACKING_PATH = "/event/tracking";
 export declare const RECOMMENDATIONS_PATH = "/api/mts/recommendations";
 export declare const CLICK_TRACKING_PATH = "/click/tracking";
-export declare const OFFER_OPENED_EVENT = "offer_opened";
-export declare const RECOMMENDATION_VIEW_EVENT = "recommendation_view";
+export declare const RECOMMENDATION_EVENT_TYPE = "recommendation";
+export declare const RECOMMENDATION_REQUEST_EVENT = "recommendation_request";
+export declare const RECOMMENDATION_RESPONSE_EVENT = "recommendation_response";
+export declare const CREATIVE_VIEW_EVENT = "creative_view";
+export declare const CREATIVE_CLICK_EVENT = "creative_click";
 export declare const DEFAULT_TIMEOUT_MS = 10000;
 export declare const PUBLIC_IP_LOOKUP_URL = "https://api.ipify.org?format=json";
 export declare const PUBLIC_IP_LOOKUP_TIMEOUT_MS = 2000;

package/lib/typescript/src/core/AdaxonClient.d.ts

@@ -1,6 +1,6 @@
 import type { AppInfoReader, DeviceInfoReader, NetworkInfoReader, NetworkStatusReader } from '../platform/types.js';
 import type { AdaxonSdkConfig } from '../types/AdaxonConfig.js';
-import type { EventIngestionResponse, RecommendationResponse } from '../types/ApiTypes.js';
+import type { EventIngestionResponse, RecommendationFlowResult } from '../types/ApiTypes.js';
 import type { AdaxonPlatform, ClickAttribution, EventProperties, TrackEventInput, TrackEventOptions } from '../types/EventTypes.js';
 import type { BatchProcessResult } from '../types/QueuedEvent.js';
 interface AdaxonClientConfig extends AdaxonSdkConfig {
@@ -26,7 +26,7 @@ export declare class AdaxonClient {
     trackBatch(events: readonly TrackEventInput[]): Promise<EventIngestionResponse>;
     enqueueEvent(eventName: string, properties?: EventProperties, options?: TrackEventOptions): Promise<void>;
     processPendingEvents(): Promise<BatchProcessResult>;
-    getRecommendations(input: TrackEventInput): Promise<RecommendationResponse>;
+    getRecommendations(properties?: EventProperties): Promise<RecommendationFlowResult>;
     createClickUrl(attribution: ClickAttribution): string;
     private toQueryString;
 }

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

@@ -1,4 +1,5 @@
 import { AdaxonSdk } from './AdaxonSdk.js';
+export { BASE_URL } from './config/ApiConstants.js';
 export { AdaxonProvider } from './components/AdaxonProvider.js';
 export type { AdaxonProviderProps } from './components/AdaxonProvider.js';
 export { useAdaxon } from './hooks/useAdaxon.js';

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

@@ -1,3 +1,3 @@
 /** Keep in sync with package.json "version" (published npm packages ship lib/ only). */
-export declare const SDK_VERSION = "0.1.6";
+export declare const SDK_VERSION = "0.1.8";
 //# sourceMappingURL=sdkVersion.d.ts.map

package/lib/typescript/src/services/event/EventService.d.ts

@@ -1,6 +1,6 @@
 import type { ApiClient } from '../network/ApiClient.js';
-import type { EventIngestionResponse, RecommendationResponse } from '../../types/ApiTypes.js';
-import type { EventPayload, TrackEventInput } from '../../types/EventTypes.js';
+import type { EventIngestionResponse, RecommendationFlowResult } from '../../types/ApiTypes.js';
+import type { EventPayload, EventProperties, TrackEventInput } from '../../types/EventTypes.js';
 import type { EventBuilder } from './EventBuilder.js';
 import type { EventValidator } from '../../validation/EventValidator.js';
 interface EventServiceConfig {
@@ -15,7 +15,7 @@ export declare class EventService {
     constructor(config: EventServiceConfig);
     trackBatch(events: readonly TrackEventInput[]): Promise<EventIngestionResponse>;
     sendPayloads(payloads: readonly EventPayload[]): Promise<EventIngestionResponse>;
-    getRecommendations(input: TrackEventInput): Promise<RecommendationResponse>;
+    getRecommendations(properties?: EventProperties): Promise<RecommendationFlowResult>;
     private postEvents;
 }
 export {};

package/lib/typescript/src/types/ApiTypes.d.ts

@@ -23,6 +23,10 @@ export interface RecommendationOffer {
 export interface RecommendationResponse {
     offers: RecommendationOffer[];
 }
+export interface RecommendationFlowResult {
+    offers: RecommendationOffer[];
+    requestEventId: string;
+}
 export interface AdaxonApiErrorBody {
     success?: boolean;
     message?: string;

package/lib/typescript/src/types/EventTypes.d.ts

@@ -32,11 +32,13 @@ export interface TrackEventInput {
     properties?: EventProperties;
     eventId?: string;
     eventTime?: string;
+    eventType?: string;
 }
 export type TrackEventOptions = Omit<TrackEventInput, 'eventName' | 'properties'>;
 export interface EventPayload {
     event_id: string;
     event_name: string;
+    event_type?: string;
     event_time: string;
     app_id: string;
     properties: EventProperties;

package/lib/typescript/src/validation/EventValidator.d.ts

@@ -4,7 +4,7 @@ export declare class EventValidator {
         readonly length: number;
     }): void;
     validateTrackInput(input: TrackEventInput): void;
-    validateEventName(eventName: string): void;
+    validateEventName(eventName: string, label?: string): void;
     validateProperties(properties: EventProperties): void;
     validateClickAttribution(attribution: ClickAttribution): void;
     private validatePositiveInteger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-test-adx",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Adaxon React Native / Expo SDK for event tracking and offer recommendations.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",