react-native-test-adx 0.1.1

package/lib/module/services/network/NetworkInfoService.js

@@ -0,0 +1,69 @@
+"use strict";
+
+import { PUBLIC_IP_LOOKUP_TIMEOUT_MS, PUBLIC_IP_LOOKUP_URL } from "../../config/ApiConstants.js";
+import { isPrivateIpAddress, parsePublicIpResponse, usableIpAddress } from "../../platform/network.js";
+export function blankNetworkContext() {
+  return {
+    connection_type: '',
+    ip_address: '',
+    country: '',
+    region: '',
+    city: ''
+  };
+}
+export class NetworkInfoService {
+  constructor(reader, lookupPublicIp = lookupPublicIpAddress) {
+    this.reader = reader;
+    this.lookupPublicIp = lookupPublicIp;
+  }
+  getNetworkInfo() {
+    if (!this.cached) {
+      this.cached = this.collect();
+    }
+    return this.cached;
+  }
+  async collect() {
+    const network = blankNetworkContext();
+    let nativeIp = '';
+    try {
+      const fromReader = (await this.reader?.readNetworkInfo()) ?? {};
+      network.connection_type = fromReader.connection_type ?? '';
+      nativeIp = usableIpAddress(fromReader.ip_address) ?? '';
+    } catch {
+      // Native lookup must not fail event tracking.
+    }
+    network.ip_address = await this.resolvePublicIp(nativeIp);
+    return network;
+  }
+  async resolvePublicIp(nativeIp) {
+    if (nativeIp && !isPrivateIpAddress(nativeIp)) {
+      return nativeIp;
+    }
+    try {
+      return usableIpAddress(await this.lookupPublicIp()) ?? nativeIp;
+    } catch {
+      return nativeIp;
+    }
+  }
+}
+export async function lookupPublicIpAddress(fetchImpl = globalThis.fetch?.bind(globalThis)) {
+  if (typeof fetchImpl !== 'function') {
+    return undefined;
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), PUBLIC_IP_LOOKUP_TIMEOUT_MS);
+  try {
+    const response = await fetchImpl(PUBLIC_IP_LOOKUP_URL, {
+      method: 'GET',
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return undefined;
+    }
+    return parsePublicIpResponse(await response.text());
+  } catch {
+    return undefined;
+  } finally {
+    clearTimeout(timeout);
+  }
+}

package/lib/module/state/AdaxonContext.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { createContext } from 'react';
+
+/** Framework state only — event results are never stored here (avoids re-renders). */
+
+export const AdaxonContext = /*#__PURE__*/createContext(null);

package/lib/module/storage/AnonymousIdService.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import { ANONYMOUS_ID_KEY_PREFIX, sanitizeStorageId } from "../config/StorageKeys.js";
+import { createUuid } from "../utils/uuid.js";
+export class AnonymousIdService {
+  constructor(appId, storage) {
+    this.appId = appId;
+    this.storage = storage;
+  }
+  getAnonymousId() {
+    if (!this.anonymousIdPromise) {
+      this.anonymousIdPromise = this.loadOrCreate().catch(error => {
+        this.anonymousIdPromise = undefined;
+        throw error;
+      });
+    }
+    return this.anonymousIdPromise;
+  }
+  get storageKey() {
+    return `${ANONYMOUS_ID_KEY_PREFIX}${sanitizeStorageId(this.appId)}`;
+  }
+  async loadOrCreate() {
+    const stored = await this.storage?.getItem(this.storageKey);
+    if (stored) {
+      return stored;
+    }
+    const anonymousId = createUuid();
+    await this.storage?.setItem(this.storageKey, anonymousId);
+    return anonymousId;
+  }
+}

package/lib/module/storage/EventQueueStorage.js

@@ -0,0 +1,143 @@
+"use strict";
+
+import { EVENT_QUEUE_ITEM_KEY_PREFIX, EVENT_QUEUE_META_KEY_PREFIX, sanitizeStorageId } from "../config/StorageKeys.js";
+import { createMemoryStorage } from "./memoryStorage.js";
+const EMPTY_META = {
+  head: 0,
+  tail: 0
+};
+export class EventQueueStorage {
+  writeChain = Promise.resolve();
+  constructor(appId, storage) {
+    this.lockId = sanitizeStorageId(appId);
+    this.storage = storage ?? createMemoryStorage();
+  }
+  append(event) {
+    return this.enqueueWrite(async () => {
+      const meta = await this.readMeta();
+      const stored = {
+        ...event,
+        sequence: meta.tail
+      };
+      await this.storage.setItem(this.itemKey(stored.sequence), JSON.stringify(stored));
+      await this.writeMeta({
+        head: meta.head,
+        tail: meta.tail + 1
+      });
+      return stored;
+    });
+  }
+  getNext(limit) {
+    return this.enqueueWrite(async () => {
+      const meta = await this.readMeta();
+      const events = [];
+      let sequence = meta.head;
+      while (sequence < meta.tail && events.length < limit) {
+        const raw = await this.readItemValue(sequence);
+        if (raw !== null) {
+          const event = this.parseQueuedEvent(raw);
+          if (event) {
+            events.push(event);
+          } else {
+            await this.deleteItem(sequence);
+          }
+        }
+        sequence += 1;
+      }
+      const head = events[0]?.sequence ?? sequence;
+      if (head !== meta.head) {
+        await this.writeMeta({
+          head,
+          tail: meta.tail
+        });
+      }
+      return events;
+    });
+  }
+  remove(events) {
+    return this.enqueueWrite(async () => {
+      if (events.length === 0) {
+        return;
+      }
+      const sequences = events.map(event => event.sequence);
+      await Promise.all(sequences.map(sequence => this.deleteItem(sequence)));
+      const meta = await this.readMeta();
+      const maxRemoved = Math.max(...sequences);
+      await this.writeMeta({
+        head: Math.max(meta.head, maxRemoved + 1),
+        tail: meta.tail
+      });
+    });
+  }
+  enqueueWrite(operation) {
+    const run = this.writeChain.then(operation, operation);
+    this.writeChain = run.then(() => undefined, () => undefined);
+    return run;
+  }
+  async readMeta() {
+    const raw = await this.storage.getItem(this.metaKey);
+    if (!raw) {
+      return {
+        ...EMPTY_META
+      };
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      const head = parsed.head;
+      const tail = parsed.tail;
+      if (typeof head !== 'number' || typeof tail !== 'number' || !Number.isInteger(head) || !Number.isInteger(tail) || head < 0 || tail < head) {
+        return {
+          ...EMPTY_META
+        };
+      }
+      return {
+        head,
+        tail
+      };
+    } catch {
+      return {
+        ...EMPTY_META
+      };
+    }
+  }
+  async writeMeta(meta) {
+    await this.storage.setItem(this.metaKey, JSON.stringify(meta));
+  }
+  async readItemValue(sequence) {
+    const raw = await this.storage.getItem(this.itemKey(sequence));
+    return raw || null;
+  }
+  parseQueuedEvent(raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return null;
+    }
+    if (!this.isQueuedEvent(parsed)) {
+      return null;
+    }
+    return parsed;
+  }
+  isQueuedEvent(value) {
+    if (typeof value !== 'object' || value === null) {
+      return false;
+    }
+    const event = value;
+    return typeof event.queue_id === 'string' && event.queue_id.length > 0 && Number.isInteger(event.sequence) && Number.isInteger(event.created_at) && typeof event.payload === 'object' && event.payload !== null;
+  }
+  async deleteItem(sequence) {
+    const key = this.itemKey(sequence);
+    if (typeof this.storage.removeItem === 'function') {
+      await this.storage.removeItem(key);
+      return;
+    }
+    await this.storage.setItem(key, '');
+  }
+  get metaKey() {
+    return `${EVENT_QUEUE_META_KEY_PREFIX}${this.lockId}`;
+  }
+  itemKey(sequence) {
+    return `${EVENT_QUEUE_ITEM_KEY_PREFIX}${this.lockId}.${sequence}`;
+  }
+}

package/lib/module/storage/memoryStorage.js

@@ -0,0 +1,16 @@
+"use strict";
+
+export function createMemoryStorage() {
+  const values = new Map();
+  return {
+    async getItem(key) {
+      return values.get(key) ?? null;
+    },
+    async setItem(key, value) {
+      values.set(key, value);
+    },
+    async removeItem(key) {
+      values.delete(key);
+    }
+  };
+}

package/lib/module/types/AdaxonConfig.js

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

package/lib/module/types/ApiTypes.js

@@ -0,0 +1 @@
+"use strict";

package/lib/module/types/EventTypes.js

@@ -0,0 +1 @@
+"use strict";

package/lib/module/types/QueuedEvent.js

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

package/lib/module/utils/locale.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { nonEmptyString, setIfPresent } from "./strings.js";
+export function readLocaleFields() {
+  const fields = {};
+  try {
+    const options = Intl.DateTimeFormat().resolvedOptions();
+    const primary = options.locale?.split(/[-_]/)[0];
+    setIfPresent(fields, 'language', primary ? primary.toLowerCase() : undefined);
+    setIfPresent(fields, 'timezone', nonEmptyString(options.timeZone));
+  } catch {
+    // Intl can be missing on some runtimes.
+  }
+  return fields;
+}

package/lib/module/utils/strings.js

@@ -0,0 +1,17 @@
+"use strict";
+
+export function nonEmptyString(value) {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+export function setIfPresent(target, key, value) {
+  if (value !== undefined) {
+    target[key] = value;
+  }
+}

package/lib/module/utils/uuid.js

@@ -0,0 +1,13 @@
+"use strict";
+
+/** UUID v4. Uses Math.random so it works on Hermes without crypto. */
+export function createUuid() {
+  const bytes = new Uint8Array(16);
+  for (let index = 0; index < bytes.length; index += 1) {
+    bytes[index] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] % 16 + 64;
+  bytes[8] = bytes[8] % 64 + 128;
+  const hex = Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}

package/lib/module/validation/EventValidator.js

@@ -0,0 +1,63 @@
+"use strict";
+
+import { EVENT_NAME_PATTERN, MAX_BATCH_SIZE, MAX_EVENT_NAME_LENGTH, MAX_PROPERTIES, MAX_PROPERTY_KEY_LENGTH, MAX_PROPERTY_VALUE_LENGTH } from "../config/ApiConstants.js";
+import { AdaxonSdkError } from "../errors/AdaxonSdkError.js";
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+export class EventValidator {
+  validateBatch(events) {
+    if (events.length === 0 || events.length > MAX_BATCH_SIZE) {
+      this.fail(`Event batch must contain between 1 and ${MAX_BATCH_SIZE} events.`);
+    }
+  }
+  validateTrackInput(input) {
+    this.validateEventName(input.eventName);
+    this.validateProperties(input.properties ?? {});
+    if (input.eventId && !UUID_PATTERN.test(input.eventId)) {
+      this.fail('eventId must be a valid UUID.');
+    }
+    if (input.eventTime && !ISO_DATE_PATTERN.test(input.eventTime)) {
+      this.fail('eventTime must be a valid ISO 8601 datetime string.');
+    }
+  }
+  validateEventName(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.`);
+    }
+  }
+  validateProperties(properties) {
+    const entries = Object.entries(properties);
+    if (entries.length > MAX_PROPERTIES) {
+      this.fail(`properties must not contain more than ${MAX_PROPERTIES} entries.`);
+    }
+    for (const [key, value] of entries) {
+      if (!key || key.length > MAX_PROPERTY_KEY_LENGTH) {
+        this.fail(`Property key "${key}" is invalid.`);
+      }
+      if (value !== null && typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+        this.fail(`Property "${key}" must be a string, number, boolean, or null.`);
+      }
+      if (typeof value === 'number' && !Number.isFinite(value)) {
+        this.fail(`Property "${key}" must be a finite number.`);
+      }
+      if (typeof value === 'string' && value.length > MAX_PROPERTY_VALUE_LENGTH) {
+        this.fail(`Property "${key}" must not exceed ${MAX_PROPERTY_VALUE_LENGTH} characters.`);
+      }
+    }
+  }
+  validateClickAttribution(attribution) {
+    this.validatePositiveInteger(attribution.offerId, 'offerId');
+    this.validatePositiveInteger(attribution.affiliateId, 'affiliateId');
+    if (attribution.advertiserId !== undefined) {
+      this.validatePositiveInteger(attribution.advertiserId, 'advertiserId');
+    }
+  }
+  validatePositiveInteger(value, field) {
+    if (!Number.isInteger(value) || value < 1) {
+      this.fail(`${field} must be a positive integer.`);
+    }
+  }
+  fail(message) {
+    throw new AdaxonSdkError('VALIDATION_ERROR', message);
+  }
+}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

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

@@ -0,0 +1,28 @@
+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 { EventProperties, TrackEventInput, TrackEventOptions } from './types/EventTypes.js';
+import type { BatchProcessResult } from './types/QueuedEvent.js';
+export declare class AdaxonSdk {
+    private static readonly sharedInstance;
+    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>;
+    trackBatch(events: readonly TrackEventInput[]): Promise<EventIngestionResponse>;
+    enqueueEvent(eventName: string, properties?: EventProperties, options?: TrackEventOptions): Promise<void>;
+    processPendingEvents(): Promise<BatchProcessResult>;
+    logEvent(eventName: string, values?: Record<string, unknown>, options?: TrackEventOptions): Promise<EventIngestionResponse>;
+    trackPurchase(params: TrackPurchaseParams, options?: TrackEventOptions): Promise<EventIngestionResponse>;
+    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;
+    private requireClient;
+    private reset;
+}
+//# sourceMappingURL=AdaxonSdk.d.ts.map

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

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+import { AdaxonSdk } from '../AdaxonSdk.js';
+import type { AdaxonInitializationConfiguration, AdaxonInitializationListener } from '../types/AdaxonConfig.js';
+export interface AdaxonProviderProps {
+    configuration: AdaxonInitializationConfiguration;
+    listener?: AdaxonInitializationListener;
+    sdk?: AdaxonSdk;
+    children: ReactNode;
+}
+export declare function AdaxonProvider({ configuration, listener, sdk, children, }: AdaxonProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=AdaxonProvider.d.ts.map

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

@@ -0,0 +1,17 @@
+export declare const SDK_VERSION = "0.1.1";
+export declare const MEDIATION_PROVIDER = "mts";
+export declare const BASE_URL = "http://localhost:3002";
+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 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;
+export declare const MAX_BATCH_SIZE = 100;
+export declare const MAX_EVENT_NAME_LENGTH = 100;
+export declare const MAX_PROPERTIES = 50;
+export declare const MAX_PROPERTY_KEY_LENGTH = 100;
+export declare const MAX_PROPERTY_VALUE_LENGTH = 1000;
+export declare const EVENT_NAME_PATTERN: RegExp;
+//# sourceMappingURL=ApiConstants.d.ts.map

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

@@ -0,0 +1,5 @@
+export declare const ANONYMOUS_ID_KEY_PREFIX = "adaxon_sdk.anonymous_id.";
+export declare const EVENT_QUEUE_META_KEY_PREFIX = "adaxon_sdk.event_queue.meta.";
+export declare const EVENT_QUEUE_ITEM_KEY_PREFIX = "adaxon_sdk.event_queue.item.";
+export declare function sanitizeStorageId(appId: string): string;
+//# sourceMappingURL=StorageKeys.d.ts.map

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

@@ -0,0 +1,29 @@
+import type { AppInfoReader, DeviceInfoReader, NetworkInfoReader } from '../platform/types.js';
+import type { AdaxonSdkConfig } from '../types/AdaxonConfig.js';
+import type { EventIngestionResponse, RecommendationResponse } 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 {
+    platform?: AdaxonPlatform;
+    deviceInfoReader?: DeviceInfoReader;
+    appInfoReader?: AppInfoReader;
+    networkInfoReader?: NetworkInfoReader;
+}
+export declare class AdaxonClient {
+    private readonly events;
+    private readonly builder;
+    private readonly validator;
+    private readonly eventQueue;
+    private readonly batchProcessor;
+    constructor(config: AdaxonClientConfig);
+    track(eventName: string, properties?: EventProperties, options?: TrackEventOptions): Promise<EventIngestionResponse>;
+    trackBatch(events: readonly TrackEventInput[]): Promise<EventIngestionResponse>;
+    enqueueEvent(eventName: string, properties?: EventProperties, options?: TrackEventOptions): Promise<void>;
+    processPendingEvents(): Promise<BatchProcessResult>;
+    getRecommendations(input: TrackEventInput): Promise<RecommendationResponse>;
+    createClickUrl(attribution: ClickAttribution): string;
+    setExternalUserId(externalUserId?: string): void;
+    private toQueryString;
+}
+export {};
+//# sourceMappingURL=AdaxonClient.d.ts.map

package/lib/typescript/src/errors/AdaxonSdkError.d.ts

@@ -0,0 +1,15 @@
+import type { AdaxonApiErrorBody } from '../types/ApiTypes.js';
+export type AdaxonSdkErrorCode = 'INVALID_CONFIG' | 'VALIDATION_ERROR' | 'AUTHENTICATION_ERROR' | 'HTTP_ERROR' | 'NETWORK_ERROR' | 'TIMEOUT';
+export declare class AdaxonSdkError extends Error {
+    readonly code: AdaxonSdkErrorCode;
+    readonly status?: number;
+    readonly details?: unknown;
+    constructor(code: AdaxonSdkErrorCode, message: string, options?: {
+        status?: number;
+        details?: unknown;
+        cause?: unknown;
+    });
+    static messageOf(error: unknown, fallback: string): string;
+    static fromHttp(status: number, body: AdaxonApiErrorBody | null): AdaxonSdkError;
+}
+//# sourceMappingURL=AdaxonSdkError.d.ts.map

package/lib/typescript/src/hooks/useAdaxon.d.ts

@@ -0,0 +1,19 @@
+import type { AdaxonSdk } from '../AdaxonSdk.js';
+export interface UseAdaxonResult {
+    isInitialized: boolean;
+    initializationError: string | null;
+    track: AdaxonSdk['track'];
+    trackBatch: AdaxonSdk['trackBatch'];
+    enqueueEvent: AdaxonSdk['enqueueEvent'];
+    processPendingEvents: AdaxonSdk['processPendingEvents'];
+    logEvent: AdaxonSdk['logEvent'];
+    trackPurchase: AdaxonSdk['trackPurchase'];
+    trackAddToCart: AdaxonSdk['trackAddToCart'];
+    trackLogin: AdaxonSdk['trackLogin'];
+    trackCompleteRegistration: AdaxonSdk['trackCompleteRegistration'];
+    loadRecommendations: AdaxonSdk['loadRecommendations'];
+    showOffer: AdaxonSdk['showOffer'];
+    setExternalUserId: AdaxonSdk['setExternalUserId'];
+}
+export declare function useAdaxon(): UseAdaxonResult;
+//# sourceMappingURL=useAdaxon.d.ts.map

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

@@ -0,0 +1,19 @@
+import { AdaxonSdk } from './AdaxonSdk.js';
+export { AdaxonProvider } from './components/AdaxonProvider.js';
+export type { AdaxonProviderProps } from './components/AdaxonProvider.js';
+export { useAdaxon } from './hooks/useAdaxon.js';
+export type { UseAdaxonResult } from './hooks/useAdaxon.js';
+export { AdaxonSdk };
+export { AdaxonSdkError } from './errors/AdaxonSdkError.js';
+export type { AdaxonSdkErrorCode } from './errors/AdaxonSdkError.js';
+export { AdxEvent, AdxParam } from './services/event/predefined.js';
+export type { AdxEventName, AdxParamName } from './services/event/predefined.js';
+export type { TrackAddToCartParams, TrackCompleteRegistrationParams, TrackLoginParams, TrackPurchaseParams, } from './services/event/normalizeProperties.js';
+export type { AdaxonInitializationConfiguration, AdaxonInitializationErrorCode, AdaxonInitializationListener, AdaxonOfferShowListener, AdaxonRecommendationLoadListener, AdaxonSdkConfig, AdaxonStorageAdapter, } from './types/AdaxonConfig.js';
+export type { ClickAttribution, EventProperties, EventPropertyValue, AdaxonPlatform, TrackEventInput, TrackEventOptions, } from './types/EventTypes.js';
+export type { EventIngestionResponse, RecommendationOffer, RecommendationResponse, } from './types/ApiTypes.js';
+export type { BatchProcessResult } from './types/QueuedEvent.js';
+export type { AppInfoReader, DeviceInfoReader } from './platform/types.js';
+export declare const Adaxon: AdaxonSdk;
+export default AdaxonSdk;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/platform/android.d.ts

@@ -0,0 +1,10 @@
+import type { AdaxonDeviceContext } from '../types/EventTypes.js';
+export interface AndroidBuildConstants {
+    Release?: string;
+    Brand?: string;
+    Model?: string;
+}
+type AndroidDeviceFields = Pick<AdaxonDeviceContext, 'os_version' | 'brand' | 'model'>;
+export declare function deviceFieldsFromAndroid(constants: AndroidBuildConstants): AndroidDeviceFields;
+export {};
+//# sourceMappingURL=android.d.ts.map

package/lib/typescript/src/platform/app.d.ts

@@ -0,0 +1,14 @@
+import type { AdaxonAppContext } from '../types/EventTypes.js';
+export interface NativeAppConstants {
+    applicationId?: string | null;
+    androidPackage?: string | null;
+    iosBundleIdentifier?: string | null;
+    bundleId?: string | null;
+    nativeApplicationVersion?: string | null;
+    nativeAppVersion?: string | null;
+    appVersion?: string | null;
+}
+type NativeAppFields = Pick<AdaxonAppContext, 'package_name' | 'app_version'>;
+export declare function appFieldsFromNative(constants: NativeAppConstants): NativeAppFields;
+export {};
+//# sourceMappingURL=app.d.ts.map

package/lib/typescript/src/platform/ios.d.ts

@@ -0,0 +1,8 @@
+import type { AdaxonDeviceContext } from '../types/EventTypes.js';
+export interface IosSystemConstants {
+    osVersion?: string;
+    Version?: string | number;
+    model?: string;
+}
+export declare function deviceFieldsFromIos(constants: IosSystemConstants): Pick<AdaxonDeviceContext, 'os_version' | 'brand' | 'model'>;
+//# sourceMappingURL=ios.d.ts.map

package/lib/typescript/src/platform/network.d.ts

@@ -0,0 +1,6 @@
+export declare function connectionTypeFromNativeState(state: unknown): string | undefined;
+export declare function ipAddressFromNativeState(state: unknown): string | undefined;
+export declare function usableIpAddress(value: string | undefined): string | undefined;
+export declare function isPrivateIpAddress(ip: string): boolean;
+export declare function parsePublicIpResponse(raw: string): string | undefined;
+//# sourceMappingURL=network.d.ts.map

package/lib/typescript/src/platform/reactNative.d.ts

@@ -0,0 +1,8 @@
+import type { AdaxonPlatform } from '../types/EventTypes.js';
+import type { AppInfoReader, DeviceInfoReader, NetworkInfoReader, UrlOpener } from './types.js';
+export declare function detectReactNativePlatform(): AdaxonPlatform;
+export declare const reactNativeDeviceReader: DeviceInfoReader;
+export declare const reactNativeAppInfoReader: AppInfoReader;
+export declare const reactNativeNetworkInfoReader: NetworkInfoReader;
+export declare const reactNativeUrlOpener: UrlOpener;
+//# sourceMappingURL=reactNative.d.ts.map

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

@@ -0,0 +1,15 @@
+import type { AdaxonAppContext, AdaxonDeviceContext, AdaxonNetworkContext, AdaxonPlatform } from '../types/EventTypes.js';
+export interface DeviceInfoReader {
+    readDeviceInfo(platform: AdaxonPlatform): AdaxonDeviceContext;
+}
+export interface AppInfoReader {
+    readAppInfo(): AdaxonAppContext;
+}
+export interface NetworkInfoReader {
+    readNetworkInfo(): Promise<AdaxonNetworkContext>;
+}
+export interface UrlOpener {
+    canOpenURL(url: string): Promise<boolean>;
+    openURL(url: string): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/services/app/AppInfoService.d.ts

@@ -0,0 +1,11 @@
+import type { AdaxonAppContext } from '../../types/EventTypes.js';
+import type { AppInfoReader } from '../../platform/types.js';
+export declare class AppInfoService {
+    private readonly testMode;
+    private readonly reader?;
+    private cached?;
+    constructor(testMode: boolean, reader?: AppInfoReader | undefined);
+    getAppInfo(): AdaxonAppContext;
+    private readOptionalFields;
+}
+//# sourceMappingURL=AppInfoService.d.ts.map

package/lib/typescript/src/services/authentication/AuthenticationService.d.ts

@@ -0,0 +1,10 @@
+import type { AdaxonSdkConfig } from '../../types/AdaxonConfig.js';
+export declare class AuthenticationService {
+    readonly appId: string;
+    readonly sdkKey: string;
+    readonly timeoutMs: number;
+    constructor(config: AdaxonSdkConfig);
+    private validateConfig;
+    private fail;
+}
+//# sourceMappingURL=AuthenticationService.d.ts.map