@advenue/react-native 0.8.0 → 1.0.0

package/dist/index.d.cts

@@ -1,226 +1,152 @@
-import { StorageAdapter, SecureStorageAdapter, DeepLink, AdvenueConfig, AdvenueClient, TrackOptions, Consent, DeviceInfo } from '@advenue/sdk-core';
-export { AdvenueConfig, Consent, DeepLink, TrackOptions } from '@advenue/sdk-core';
-
 /**
- * Minimal structural type for the bits of `react-native-mmkv`'s MMKV instance
- * we use. Declared locally so this package needs no react-native types at
- * compile time — the app injects a real `new MMKV()` instance at runtime.
+ * The types the package used to re-export from the retired TypeScript core.
+ *
+ * They live here now because the TypeScript core is retired and the native
+ * SDKs own the behaviour — but they are still the shapes apps destructure, so
+ * they must keep their names and fields exactly.
  */
-interface MMKVLike {
-    set(key: string, value: string): void;
-    getString(key: string): string | undefined;
-    delete(key: string): void;
+/** Granular ad-platform consent (Google DMA). */
+interface Consent {
+    /** Whether GDPR/EEA rules apply to this user. → Google `gdpr_applies` */
+    isUserSubjectToGDPR: boolean;
+    /** Consent to use data for advertising purposes. → Google `ad_user_data` */
+    hasConsentForDataUsage?: boolean;
+    /** Consent for personalized advertising. → Google `ad_personalization` */
+    hasConsentForAdsPersonalization?: boolean;
+    /** Consent for ad storage. → Google `ad_storage` */
+    hasConsentForAdStorage?: boolean;
 }
-/** Wraps an MMKV instance as an Advenue StorageAdapter (synchronous, fast). */
-declare function createMMKVStorage(mmkv: MMKVLike): StorageAdapter;
-
-interface InstallReferrerResult {
-    referrer: string;
-    /** Device-clock: referrerClickTimestampSeconds. */
-    clickTimestamp: number;
-    /** Device-clock: installBeginTimestampSeconds. */
-    installTimestamp: number;
-    /**
-     * Server-clock: referrerClickTimestampServerSeconds (G1 fraud trust —
-     * referrerTrust:'server'). 0 = unverified; absent on older native builds.
-     */
-    clickServerTimestamp?: number;
-    /** Server-clock: installBeginTimestampServerSeconds. 0 = unverified. */
-    installServerTimestamp?: number;
-    googlePlayInstant: boolean;
+/** A resolved deep link, deferred or direct. */
+interface DeepLink {
+    /** In-app destination, e.g. "product/123". Absent for an attributed install with no link. */
+    deepLinkValue?: string;
+    campaign?: string;
+    network?: string;
+    influencerId?: string;
+    params?: Record<string, unknown>;
+    /** Raw opening URL for direct (OS-delivered) links; absent for deferred. */
+    url?: string;
+    /** True when the link survived an install rather than arriving on an open. */
+    isDeferred: boolean;
+    /** True when this is the device's first-launch attribution (always true for deferred). */
+    isFirstLaunch: boolean;
 }
-interface MetaInstallReferrerResult {
-    installReferrer: string;
-    isClickThrough: boolean;
-    actualTimestamp: number;
-    /** Which Meta app served the referrer (e.g. com.facebook.katana). */
-    provider: string;
+/**
+ * The event types a client SDK may emit. Revenue-bearing subscription events
+ * are deliberately absent: those originate only from verified S2S sources, and
+ * the server rejects a batch that claims one.
+ */
+type ClientEventType = 'install' | 'session' | 'custom';
+/** Per-event options. Most apps never pass any of these. */
+interface TrackOptions {
+    type?: ClientEventType;
+    network?: string;
+    campaign?: string;
 }
 /**
- * Device metadata for Meta CAPI `extinfo` (Task 3n). Structurally mirrors
- * `DeviceInfo` from `@advenue/shared` — kept as a local subset type (rather
- * than importing that package) so this native-module-only package stays
- * dependency-free; the RN facade's `collectDeviceInfo()` merges it into the
- * real `DeviceInfo` shape.
+ * SDK configuration.
+ *
+ * Several options that used to shape the TypeScript core are now decided
+ * natively and are accepted but ignored — see `initialize`, which reports each
+ * one through `onError` rather than dropping it silently. Passing storage to an
+ * SDK that owns its own storage should not look like it worked.
  */
-interface AdvenueDeviceInfo {
-    model?: string;
-    locale?: string;
-    carrier?: string;
-    timezone?: string;
-    screenWidth?: number;
-    screenHeight?: number;
-    screenDensity?: number;
-    cpuCores?: number;
-    totalStorageGb?: number;
-    freeStorageGb?: number;
+interface AdvenueConfig {
+    apiKey: string;
+    endpoint?: string;
+    platform?: 'ios' | 'android' | 'web' | string;
+    appVersion?: string;
+    osVersion?: string;
+    /** Gates every event on `setTrackingConsent(true)`. */
+    requireConsent?: boolean;
+    /** Events per request. */
+    batchSize?: number;
+    /** Auto-flush period in milliseconds; 0 disables the timer. */
+    flushIntervalMs?: number;
+    /**
+     * Per-key HMAC secret. The signature provides integrity and replay
+     * protection, not authentication: anything inside an app binary can be
+     * extracted from it.
+     */
+    signingSecret?: string;
+    disableAutoSessions?: boolean;
+    /** Called when the SDK swallows a best-effort failure. Never receives PII. */
+    onError?: (context: string, cause: unknown) => void;
+    debug?: boolean;
+}
+
+type TrackingAuthorizationStatus = 'authorized' | 'denied' | 'restricted' | 'notDetermined' | 'unavailable';
+/** What `bridgeInitialize` accepts. Anything absent takes the native default. */
+interface BridgeInitOptions {
+    apiKey: string;
+    endpoint?: string;
+    appVersion?: string;
+    requireConsent: boolean;
+    batchSize?: number;
+    flushIntervalMs?: number;
+    signingSecret?: string;
+    /** Meta app id, for the Meta install referrer. Android only. */
+    fbAppId?: string;
+    autoTrackInstall: boolean;
+    /** Stamped by this package, never by the host app. */
+    sdkVersion: string;
 }
 /**
- * Raw IAB TCF v2 CMP values from the platform default store
- * (`UserDefaults.standard` / default SharedPreferences) — where TCF-compliant
- * CMPs (e.g. Google UMP) write `IABTCF_*` keys. Structurally mirrors
- * `TcfData` from `@advenue/sdk-core`.
+ * One diagnostic the SDK swallowed, on its way back to JavaScript.
+ *
+ * `context` is a stable dot-path identifier of the step that failed
+ * (`identity.deferred`, `track.rejected:name_too_long`, `flush.transport`), not
+ * a message to show a user. Never carries PII.
  */
-interface NativeTcfData {
-    gdprApplies?: number | null;
-    purposeConsents?: string | null;
+interface NativeErrorEvent {
+    context: string;
+    message: string;
 }
-interface AdvenueAndroidNativeModule {
-    /** Raw Play Install Referrer; parse with @advenue/install-referrer. */
-    getInstallReferrer(): Promise<InstallReferrerResult | null>;
-    /**
-     * Meta install referrer (null when no Facebook/Instagram app is installed);
-     * parse with parseMetaInstallReferrer from @advenue/install-referrer.
-     */
-    getMetaInstallReferrer(): Promise<MetaInstallReferrerResult | null>;
-    /** Google Advertising ID (GAID) + limit-ad-tracking flag; null when unavailable. */
-    getAdvertisingId(): Promise<{
-        id: string;
-        limitAdTracking: boolean;
-    } | null>;
-    /** App Set ID — non-advertising, developer-scoped fallback id; null when unavailable. */
-    getAppSetId(): Promise<string | null>;
-    /**
-     * Play Integrity Standard API token (G3.1n).
-     *
-     * `requestHash` MUST be sha256_hex("<appId>:<deviceId>") — lowercase hex SHA-256
-     * of the literal string "<appId>:<deviceId>". The server's mapIntegrityVerdict
-     * re-derives the same string and compares it byte-for-byte.
-     *
-     * Rejects when:
-     *  - ECONFIG: `io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER` meta-data is absent.
-     *  - EUNSUPPORTED: Play Services unavailable or provider warming failed.
-     *  - EINTEGRITY: Play returned an API-level error (network, quota, etc.).
-     *
-     * The JS bridge treats any rejection as "no attestation" and omits the token
-     * from the install event — rejection must never block the install track call.
-     */
-    getIntegrityToken(requestHash: string): Promise<string>;
-    /**
-     * Device metadata (model, locale, screen, cpu, storage, timezone) used to
-     * populate Meta CAPI `extinfo` (Task 3n). Synchronous, best-effort — the JS
-     * facade (`collectDeviceInfo`) treats a thrown error as "unavailable" and
-     * degrades to `{}` rather than blocking anything.
-     */
-    getDeviceInfo(): AdvenueDeviceInfo;
-    /**
-     * Built-in SDK storage (SharedPreferences `io.advenue.sdk`, MODE_PRIVATE) —
-     * the durable offline buffer + SDK state, so the app never supplies storage.
-     * Optional: absent on native builds predating this capability; the RN facade
-     * feature-detects and falls back to in-memory buffering. (No secure variant:
-     * Android has no reinstall-durable store — a reinstall legitimately re-fires
-     * the install, which the backend per-device window deduplicates.)
-     */
-    storageGetItem?(key: string): string | null;
-    storageSetItem?(key: string, value: string): void;
-    storageRemoveItem?(key: string): void;
-    /**
-     * Android SSAID (Settings.Secure.ANDROID_ID) — signing-key-scoped, stable
-     * across reinstalls. The RN facade reads it ONLY when no usable GAID exists
-     * (Adjust-style fallback) and it is used strictly as a first-party
-     * fraud/dedup + reinstall-detection signal, never for ad attribution (Play
-     * policy). Optional: absent on older native builds; feature-detected.
-     */
-    getAndroidId?(): string | null;
-    /**
-     * IAB TCF v2 CMP data, null when no CMP has written TCF keys. Optional:
-     * older native builds lack it — callers feature-detect (getAndroidId
-     * precedent).
-     */
-    getTcfData?(): NativeTcfData | null;
+/** The methods both native modules implement. */
+interface AdvenueBridge {
+    /** Expo's event subscription, used for `onAdvenueError`. */
+    addListener?(name: 'onAdvenueError', handler: (event: NativeErrorEvent) => void): {
+        remove(): void;
+    };
+    bridgeInitialize(options: BridgeInitOptions): void;
+    bridgeTrack(name: string, properties: Record<string, unknown> | null): void;
+    bridgeFlush(): void;
+    bridgeSetUserId(id: string | null): void;
+    bridgeSetConsent(granted: boolean): void;
+    /** Reads the persisted value; the JavaScript consent cache is seeded from it. */
+    bridgeGetConsent(): boolean;
+    bridgeSetConsentData(consent: Consent): void;
+    bridgeGetConsentData(): Consent | null;
+    bridgeSetAppInstanceId(id: string | null): void;
+    bridgeSetPushToken(token: string | null, provider: string | null): void;
+    bridgeProcessDeepLink(url: string): void;
+    bridgeForgetMe(): void;
+    bridgeShutdown(): void;
+    bridgeResolvedAppId(): string | null;
+    bridgeResolveDeferredDeepLink(): Promise<DeepLink | null>;
 }
-type TrackingAuthorizationStatus = 'notDetermined' | 'restricted' | 'denied' | 'authorized';
-interface AdvenueIosNativeModule {
-    registerAppForAttribution(): void;
+interface AdvenueIosNativeModule extends AdvenueBridge {
     /**
-     * Conversion value: fine 0–63, coarse 'low'|'medium'|'high'. Updates the
-     * SKAN 4.0 postback, and on iOS 17.4+ the AdAttributionKit postback too.
+     * The app's price string ("9.99"), not micros. The conversion to exact
+     * micros happens natively: a money computation in JavaScript is the thing
+     * this release removed.
      */
-    updateConversionValue(fineValue: number, coarse: string, lockWindow: boolean): Promise<void>;
-    /** Apple Search Ads attribution token (resolve server-side). */
-    getAttributionToken(): Promise<string | null>;
+    bridgeRecordSkanRevenue(amount: string, currency: string): void;
+    /** Resolves synchronously on the native side; a Promise across the bridge. */
+    bridgeDeviceId(): Promise<string | null>;
     /**
      * Shows the ATT consent prompt; requires NSUserTrackingUsageDescription in
      * the app's Info.plist. Resolves with the resulting status.
+     *
+     * Still a capability rather than a bridge call because the app chooses when
+     * to prompt, and that decision belongs to the app's UX, not the SDK.
      */
     requestTrackingAuthorization(): Promise<TrackingAuthorizationStatus>;
-    getTrackingAuthorizationStatus(): TrackingAuthorizationStatus;
-    getAdvertisingId(): Promise<string | null>;
-    /** Vendor-scoped device id (IDFV) — available without ATT; a fallback anchor. */
-    getIdentifierForVendor(): string | null;
-    /**
-     * G3.2n — App Attest. Generates (or reuses a keychain-cached) DCAppAttest
-     * key, computes clientDataHash = SHA-256(challenge), and calls
-     * DCAppAttestService.attestKey. Resolves { keyId, attestationObject } where
-     * attestationObject is a base64-encoded CBOR attestation for the server.
-     * Rejects with code EUNSUPPORTED on simulators (isSupported == false).
-     */
-    attestKey(challenge: string): Promise<{
-        keyId: string;
-        attestationObject: string;
-    }>;
-    /**
-     * G3.3n — DeviceCheck. Calls DCDevice.current.generateToken to obtain the
-     * opaque base64 token that identifies this physical device to the Apple
-     * DeviceCheck API. The server queries/updates the persistent 2-bit per-device
-     * flag to detect reinstall abuse. Rejects with code EUNSUPPORTED on devices
-     * where DCDevice.current.isSupported is false (simulator, Catalyst, etc.).
-     */
-    getDeviceCheckToken(): Promise<string>;
-    /**
-     * Device metadata (model, locale, screen, cpu, storage, timezone) used to
-     * populate Meta CAPI `extinfo` (Task 3n). Synchronous, best-effort — the JS
-     * facade (`collectDeviceInfo`) treats a thrown error as "unavailable" and
-     * degrades to `{}` rather than blocking anything.
-     */
-    getDeviceInfo(): AdvenueDeviceInfo;
-    /**
-     * Built-in SDK storage (UserDefaults suite `io.advenue.sdk`) — the durable
-     * offline buffer + SDK state, so the app never supplies storage. Optional:
-     * absent on native builds predating this capability; the RN facade
-     * feature-detects and falls back to in-memory buffering.
-     */
-    storageGetItem?(key: string): string | null;
-    storageSetItem?(key: string, value: string): void;
-    storageRemoveItem?(key: string): void;
-    /**
-     * Built-in secure storage (Keychain, kSecAttrAccessibleAfterFirstUnlock,
-     * ThisDeviceOnly) — survives app reinstall, which is what makes the device
-     * identity and the install guard reinstall-resilient (Adjust-style).
-     * Optional: absent on older native builds; feature-detected.
-     */
-    secureGetItem?(key: string): string | null;
-    secureSetItem?(key: string, value: string): void;
-    secureRemoveItem?(key: string): void;
-    /**
-     * IAB TCF v2 CMP data, null when no CMP has written TCF keys. Optional:
-     * older native builds lack it — callers feature-detect (getAndroidId
-     * precedent).
-     */
-    getTcfData?(): NativeTcfData | null;
 }
-
-/**
- * Minimal structural type for the bits of `expo-secure-store` we use. Declared
- * locally so this package needs no expo types at compile time — the app passes
- * the module (`import * as SecureStore from 'expo-secure-store'`) at runtime.
- */
-interface SecureStoreLike {
-    getItemAsync(key: string): Promise<string | null>;
-    setItemAsync(key: string, value: string): Promise<void>;
-    /** Optional — forwarded so GDPR erasure can wipe the durable entries. */
-    deleteItemAsync?(key: string): Promise<void>;
+interface AdvenueAndroidNativeModule extends AdvenueBridge {
+    /** Synchronous on Android: the identity is resolved before start returns. */
+    bridgeDeviceId(): string | null;
 }
-/** Wraps expo-secure-store as an Advenue SecureStorageAdapter (async, durable). */
-declare function createSecureStore(secureStore: SecureStoreLike): SecureStorageAdapter;
-
-/**
- * Parses an OS-delivered link (Universal Link, App Link, or custom scheme) into
- * the unified {@link DeepLink} shape. The `deepLinkValue` is a best-effort path
- * (host + path for custom schemes, path for http(s)); the raw `url` is always
- * provided so the host app can parse it itself when needed.
- */
-declare function parseDirectLink(url: string): DeepLink;
 
 /**
  * Lazy access to the native modules that ship inside this package (ios/ and
@@ -231,152 +157,94 @@ declare function parseDirectLink(url: string): DeepLink;
  */
 declare function getIosNative(): AdvenueIosNativeModule | null;
 declare function getAndroidNative(): AdvenueAndroidNativeModule | null;
-
-/**
- * Resolves the device advertising id (IDFA on iOS, GAID on Android), gates it
- * on ATT authorization status (iOS) / limitAdTracking flag (Android), and on
- * DMA consent when the user is subject to GDPR.  Pushes the result — or an
- * empty object to clear — into the active client via `setAdvertisingId`.
- *
- * Fire-and-forget at call sites; errors are suppressed internally.
- */
-declare function resolveAdvertisingId(): Promise<void>;
 /**
- * Reads IAB TCF v2 consent (written by a TCF-compliant CMP, e.g. Google UMP,
- * to the platform default store), maps it to the DMA Consent shape, and
- * pushes it into the active client. No-op — returning null — when consent was
- * set manually this session, the native module or its getter is absent, no
- * TCF data exists, or the freshly-mapped consent is identical to what the
- * client already has (skip-if-unchanged: avoids re-persisting to storage and
- * re-firing the ad-id resolve on every foreground when nothing changed):
- * absent/unchanged consent must stay untouched, never fabricated or re-churned.
- *
- * Must be called after `Advenue.initialize()` — like every facade method, it
- * throws via the uninitialized guard otherwise.
+ * Lazy access to React Native's Platform.OS ('ios' | 'android' | 'web' |
+ * 'windows' | 'macos'). Returns null when react-native isn't resolvable, so
+ * callers can require an explicit platform instead of guessing.
  */
-declare function resolveDmaConsent(): Consent | null;
+declare function getPlatformOS(): string | null;
+
 /**
- * Collects native device metadata (model, locale, screen, cpu, storage, timezone)
- * used to populate Meta CAPI `extinfo`. Reads from the platform-appropriate
- * native module's `getDeviceInfo()`; returns `{}` when the native module or the
- * method is unavailable (bare React Native without the native SDK, web, Expo
- * Go, or an older native build predating this method). Never throws — any
- * native-side error degrades to an empty object so callers can unconditionally
- * pass the result through.
+ * Parses an OS-delivered link (Universal Link, App Link, or custom scheme) into
+ * the unified {@link DeepLink} shape. The `deepLinkValue` is a best-effort path
+ * (host + path for custom schemes, path for http(s)); the raw `url` is always
+ * provided so the host app can parse it itself when needed.
  */
-declare function collectDeviceInfo(natives: {
-    platform: 'ios' | 'android' | string;
-    ios?: {
-        getDeviceInfo?: () => Partial<DeviceInfo>;
-    } | null;
-    android?: {
-        getDeviceInfo?: () => Partial<DeviceInfo>;
-    } | null;
-}): DeviceInfo;
-interface RNAdvenueConfig extends Omit<AdvenueConfig, 'storage' | 'platform'> {
-    /**
-     * Auto-detected from React Native's `Platform.OS` — omit it. Pass explicitly
-     * only outside a React Native runtime (tests, custom embeddings); `ios` and
-     * `android` map verbatim, any other RN target (web, desktop) reports as
-     * `web`.
-     */
-    platform?: AdvenueConfig['platform'];
+declare function parseDirectLink(url: string): DeepLink;
+
+interface RNAdvenueConfig extends AdvenueConfig {
+    /** Meta app id, for the Meta install referrer on Android. */
+    fbAppId?: string;
+    /** Fires automatically unless set to false. */
+    autoTrackInstall?: boolean;
+    /** Called when a link resolves, deferred or direct. */
+    onDeepLink?: (link: DeepLink) => void;
+    /** Firebase App Instance ID, if the app has Firebase Analytics. */
+    appInstanceIdProvider?: () => Promise<string | null>;
+    /** Accepted and ignored — the native SDKs own storage. */
+    mmkv?: unknown;
+    secureStore?: unknown;
+    sdkConfigFetcher?: unknown;
+    tcfDataCollection?: boolean;
+}
+declare const Advenue: {
     /**
-     * @internal Storage override (tests / custom embeddings). The SDK persists
-     * via its own native modules (UserDefaults/SharedPreferences) — apps never
-     * supply storage. When set, it replaces the built-in native storage.
+     * Starts the SDK. Safe to call from the app's entry point, and safe to call
+     * twice: the native side replaces its previous instance.
      */
-    mmkv?: MMKVLike;
+    initialize(config: RNAdvenueConfig): Promise<void>;
+    track(name: string, properties?: Record<string, unknown>): void;
+    /** Adds exact local revenue to Apple's conversion-value state. iOS only. */
+    recordSkanRevenue(input: {
+        amount: string;
+        currency: string;
+    }): Promise<void>;
+    setAppInstanceId(id: string | null): void;
     /**
-     * G3.1n — Play Integrity (Android) / App Attest (iOS) attestation.
-     *
-     * Your app's Advenue appId (the UUID in Settings → API Keys). When set on
-     * Android, the automatic install obtains a Play Integrity Standard token and
-     * attaches it to the install event. The requestHash is computed as
-     * `sha256Hex("<appId>:<deviceId>")`, matching the server's verification
-     * formula exactly (see `makeDecodeAndroid` in the worker).
+     * Cross-device linking: associates subsequent events with your user id.
+     * Pass null to clear.
      *
-     * Omit to run without attestation (the server field stays `unavailable`).
+     * New on this object. The previous release reached it through the client
+     * `initialize()` resolved to, and that client no longer exists — so it is
+     * promoted here rather than dropped, which is what an app following the
+     * documented cross-device recipe would otherwise hit at runtime.
      */
-    appId?: string;
+    setUserId(id: string | null): void;
     /**
-     * @internal Secure-store override (tests / custom embeddings). The SDK uses
-     * its own Keychain-backed native storage on iOS for the reinstall-resilient
-     * device identity — apps never supply a secure store. When set, it replaces
-     * the built-in Keychain adapter.
-     */
-    secureStore?: SecureStoreLike;
-    /**
-     * Unified deep-link callback (AppsFlyer UDL style). Fires for both direct
-     * Universal/App Links (the OS opened the app via a link) and deferred deep
-     * links (resolved after an attributed install). The SDK never navigates — the
-     * host app reads `link.deepLinkValue` and routes. Inspect `link.isDeferred`
-     * to distinguish the two. Omit to disable deep-link handling entirely.
-     */
-    onDeepLink?: (link: DeepLink) => void;
-    /**
-     * @internal Test hook — disables the automatic install fired by
-     * `initialize()`. Install tracking is always automatic in production (there
-     * is no public `trackInstall`); tests turn it off to exercise the internal
-     * install path deterministically.
+     * Registers the device's push token for uninstall measurement.
+     *
+     * Advenue never requests the notification permission and never displays
+     * anything: pass the token your push library already produced, on every
+     * launch and from its refresh listener. A stale token is the one thing that
+     * makes uninstall measurement report churn that did not happen.
      */
-    autoTrackInstall?: boolean;
+    setPushToken(token: string | null, provider?: "apns" | "fcm"): void;
     /**
-     * Auto-collect IAB TCF v2 consent written by a TCF-compliant CMP (e.g.
-     * Google UMP) and attach it to every event as DMA consent data (AppsFlyer
-     * `enableTCFDataCollection` parity). Read at init and re-read on each
-     * foreground, so a CMP decision made after startup lands on later events.
-     * A manual `setConsentData()` call always wins. Default false.
-     */
-    tcfDataCollection?: boolean;
-}
-/**
- * Maps a React Native AppState status to the client's session lifecycle hooks.
- * Exported for testing. 'inactive' (transient on iOS) is intentionally ignored
- * so brief interruptions (Control Center, incoming call) don't end the session.
- */
-declare function applyAppState(client: Pick<AdvenueClient, 'notifyAppActive' | 'notifyAppBackground'>, status: string): void;
-/**
- * React Native entry point. Wires MMKV-backed offline buffering automatically
- * and re-exports the same track surface as the core SDK.
- */
-declare const Advenue: {
-    initialize(config: RNAdvenueConfig): Promise<AdvenueClient>;
-    track: (name: string, properties?: Record<string, unknown>, opts?: TrackOptions) => void;
-    /**
-     * Shows the iOS ATT prompt (resolves 'authorized' immediately on Android/web,
-     * where ATT doesn't exist) and forwards the result to the consent gate.
+     * Shows the iOS ATT prompt. Where ATT does not exist (non-iOS, or the iOS
+     * module is absent) there is no prompt to show and no signal to read, so
+     * consent is left untouched and the call resolves 'unavailable'.
      */
     requestTrackingAuthorization(): Promise<TrackingAuthorizationStatus>;
     setTrackingConsent(granted: boolean): void;
     getTrackingConsent: () => boolean;
-    /** GDPR/CCPA erasure: stop tracking and wipe local identifiers/queue. */
-    forgetMe(): void;
     setConsentData(consent: Consent): void;
-    getConsentData: () => {
-        isUserSubjectToGDPR: boolean;
-        hasConsentForDataUsage?: boolean | undefined;
-        hasConsentForAdsPersonalization?: boolean | undefined;
-        hasConsentForAdStorage?: boolean | undefined;
-    } | null;
-    flush: () => Promise<void>;
-    getDeviceId: () => string;
-    /** The Advenue ID — alias of getDeviceId (see AdvenueClient.getAdvenueId). */
-    getAdvenueId: () => string;
+    getConsentData: () => Consent | null;
+    /** GDPR/CCPA erasure: stops tracking and wipes local identifiers and queue. */
+    forgetMe(): void;
+    flush(): void;
+    getDeviceId: () => Promise<string | null>;
+    /** The Advenue ID — alias of `getDeviceId`. */
+    getAdvenueId: () => Promise<string | null>;
+    /** Which app the server resolved this API key to; null until a batch lands. */
+    getResolvedAppId: () => string | null;
+    /**
+     * Resolves the deferred deep link for this install, or null for an organic
+     * one — which is most of them.
+     */
+    resolveDeferredDeepLink(): Promise<DeepLink | null>;
     shutdown(): void;
 };
-/**
- * Tracks the install event enriched with native attribution data: Play + Meta
- * install referrers on Android, SKAdNetwork registration on iOS. Fired
- * automatically by `initialize()` (or its consent deferral); when a
- * `secureStore` is wired it fires at most once per device (reinstall-resilient
- * on iOS via Keychain; Android re-fires after a reinstall, which is
- * unavoidable post-GAID).
- *
- * @internal Exported for tests only — install tracking is automatic and this
- * function is deliberately NOT on the `Advenue` facade. Do not call it from
- * app code.
- */
-declare function trackInstall(): Promise<void>;
+/** The platform this build reports, for diagnostics. */
+declare const platform: typeof getPlatformOS;
 
-export { Advenue, type AdvenueAndroidNativeModule, type AdvenueDeviceInfo, type AdvenueIosNativeModule, type InstallReferrerResult, type MMKVLike, type MetaInstallReferrerResult, type NativeTcfData, type RNAdvenueConfig, type SecureStoreLike, type TrackingAuthorizationStatus, applyAppState, collectDeviceInfo, createMMKVStorage, createSecureStore, getAndroidNative, getIosNative, parseDirectLink, resolveAdvertisingId, resolveDmaConsent, trackInstall };
+export { Advenue, type AdvenueAndroidNativeModule, type AdvenueBridge, type AdvenueConfig, type AdvenueIosNativeModule, type BridgeInitOptions, type ClientEventType, type Consent, type DeepLink, type RNAdvenueConfig, type TrackOptions, type TrackingAuthorizationStatus, getAndroidNative, getIosNative, parseDirectLink, platform };