@attentive-mobile/attentive-react-native-sdk 1.0.3-beta.1 → 2.0.0-beta.1

package/lib/typescript/index.d.ts

@@ -1,34 +1,277 @@
-import type { AddToCartEvent, ProductViewEvent, PurchaseEvent, CustomEvent } from './eventTypes';
-export declare enum Mode {
-    Production = "production",
-    Debug = "debug"
-}
-export type AttentiveConfiguration = {
-    attentiveDomain: string;
-    mode: Mode;
-    skipFatigueOnCreatives?: boolean;
-};
-export type UserIdentifiers = {
-    phone?: string;
-    email?: string;
-    klaviyoId?: string;
-    shopifyId?: string;
-    clientUserId?: string;
-    customIdentifiers?: {
-        [key: string]: string;
-    };
-};
-export declare class Attentive {
-    static initialize(configuration: AttentiveConfiguration): void;
-    static identify(userIdentifiers: UserIdentifiers): void;
-    static clearUser(): void;
-    static triggerCreative(creativeId?: string | null): void;
-    static destroyCreative(): void;
-    static updateDomain(domain: string): void;
-    static recordProductViewEvent(productViewEvent: ProductViewEvent): void;
-    static recordAddToCartEvent(addToCartEvent: AddToCartEvent): void;
-    static recordPurchaseEvent(purchaseEvent: PurchaseEvent): void;
-    static recordCustomEvent(customEvent: CustomEvent): void;
-}
-export type { AddToCartEvent, ProductViewEvent, PurchaseEvent, CustomEvent };
+import type { UserIdentifiers, AttentiveSdkConfiguration, ProductView, Purchase, AddToCart, CustomEvent, Item, PushAuthorizationStatus, ApplicationState, PushNotificationUserInfo, PushRegistrationResult } from './eventTypes';
+/**
+ * Initialize the Attentive SDK with the provided configuration
+ * @param configuration - Configuration object for the Attentive SDK
+ */
+declare function initialize(configuration: AttentiveSdkConfiguration): void;
+/**
+ * Trigger a creative with an optional creative ID
+ * @param creativeId - Optional creative ID to trigger
+ */
+declare function triggerCreative(creativeId?: string): void;
+/**
+ * Destroy the current creative
+ */
+declare function destroyCreative(): void;
+/**
+ * Update the Attentive domain
+ * @param domain - New domain to use
+ */
+declare function updateDomain(domain: string): void;
+/**
+ * Identify a user with the provided identifiers
+ * @param identifiers - User identifier object containing phone, email, etc.
+ */
+declare function identify(identifiers: UserIdentifiers): void;
+/**
+ * Clear the current user identification
+ */
+declare function clearUser(): void;
+/**
+ * Record an add to cart event
+ * @param attrs - Event attributes containing items and optional deeplink
+ */
+declare function recordAddToCartEvent(attrs: AddToCart): void;
+/**
+ * Record a product view event
+ * @param attrs - Event attributes containing items and optional deeplink
+ */
+declare function recordProductViewEvent(attrs: ProductView): void;
+/**
+ * Record a purchase event
+ * @param attrs - Event attributes containing items, order ID, and optional cart details
+ */
+declare function recordPurchaseEvent(attrs: Purchase): void;
+/**
+ * Record a custom event
+ * @param attrs - Custom event attributes containing type and properties
+ */
+declare function recordCustomEvent(attrs: CustomEvent): void;
+/**
+ * Invoke the Attentive debug helper
+ */
+declare function invokeAttentiveDebugHelper(): void;
+/**
+ * Export debug logs
+ * @returns Promise that resolves to a string containing the debug logs
+ */
+declare function exportDebugLogs(): Promise<string>;
+/**
+ * Request push notification permission from the user.
+ * On iOS, this will trigger the system permission dialog.
+ * On Android, this is currently a no-op (TODO: implement FCM integration).
+ *
+ * @example
+ * ```typescript
+ * import { registerForPushNotifications } from 'attentive-react-native-sdk';
+ *
+ * // Request permission (typically called after user onboarding)
+ * registerForPushNotifications();
+ * ```
+ */
+declare function registerForPushNotifications(): void;
+/**
+ * Register the device token received from APNs/FCM with the Attentive backend.
+ * Call this from your AppDelegate's didRegisterForRemoteNotificationsWithDeviceToken.
+ *
+ * On iOS, the token should be the hex-encoded string representation of the device token Data.
+ * On Android, this is currently a no-op (TODO: implement FCM integration).
+ *
+ * @param token - The device token as a hex-encoded string
+ * @param authorizationStatus - Current push authorization status
+ *
+ * @example
+ * ```typescript
+ * import { registerDeviceToken } from 'attentive-react-native-sdk';
+ *
+ * // In your native module or push notification handler:
+ * registerDeviceToken('abc123...', 'authorized');
+ * ```
+ */
+declare function registerDeviceToken(token: string, authorizationStatus: PushAuthorizationStatus): void;
+/**
+ * Register the device token received from APNs with a callback.
+ * This is the callback-based version that allows you to handle the response from the Attentive API.
+ *
+ * On iOS, this will register the device token with the Attentive SDK and invoke the callback
+ * after the registration completes (success or failure).
+ * On Android, this is currently a no-op (TODO: implement FCM integration).
+ *
+ * @param token - The hex-encoded device token string from APNs
+ * @param authorizationStatus - Current push authorization status
+ * @param callback - Callback function invoked after registration completes
+ *
+ * @example
+ * ```typescript
+ * import { registerDeviceTokenWithCallback, handleRegularOpen } from 'attentive-react-native-sdk';
+ *
+ * // In your AppDelegate equivalent (TypeScript):
+ * registerDeviceTokenWithCallback(
+ *   deviceToken,
+ *   'authorized',
+ *   (data, url, response, error) => {
+ *     console.log('Registration complete:', { data, url, response, error });
+ *     // After registration, trigger regular open event
+ *     handleRegularOpen('authorized');
+ *   }
+ * );
+ * ```
+ */
+declare function registerDeviceTokenWithCallback(token: string, authorizationStatus: PushAuthorizationStatus, callback: (data?: Object, url?: string, response?: Object, error?: Object) => void): void;
+/**
+ * Handle regular/direct app open (not from a push notification).
+ * This should be called after device token registration to track app opens.
+ *
+ * This is the TypeScript equivalent of the native iOS AppDelegate method:
+ * ```swift
+ * func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
+ *   UNUserNotificationCenter.current().getNotificationSettings { [weak self] settings in
+ *     guard let self = self else { return }
+ *     let authStatus = settings.authorizationStatus
+ *     attentiveSdk?.registerDeviceToken(deviceToken, authorizationStatus: authStatus, callback: { data, url, response, error in
+ *       DispatchQueue.main.async {
+ *         self.attentiveSdk?.handleRegularOpen(authorizationStatus: authStatus)
+ *       }
+ *     })
+ *   }
+ * }
+ * ```
+ *
+ * On iOS, this will notify the Attentive SDK that the app was opened directly
+ * (not from a push notification tap).
+ * On Android, this is currently a no-op (TODO: implement FCM integration).
+ *
+ * @param authorizationStatus - Current push authorization status
+ *
+ * @example
+ * ```typescript
+ * import { registerDeviceTokenWithCallback, handleRegularOpen } from 'attentive-react-native-sdk';
+ * import PushNotificationIOS from '@react-native-community/push-notification-ios';
+ *
+ * // In your device token registration handler:
+ * PushNotificationIOS.addEventListener('register', (deviceToken: string) => {
+ *   PushNotificationIOS.checkPermissions((permissions) => {
+ *     let authStatus: PushAuthorizationStatus = 'notDetermined'
+ *     if (permissions.alert || permissions.badge || permissions.sound) {
+ *       authStatus = 'authorized'
+ *     }
+ *
+ *     // Register device token with callback
+ *     registerDeviceTokenWithCallback(deviceToken, authStatus, (data, url, response, error) => {
+ *       if (error) {
+ *         console.error('Registration error:', error)
+ *       }
+ *       // After registration completes, trigger regular open event
+ *       handleRegularOpen(authStatus)
+ *     })
+ *   })
+ * })
+ * ```
+ */
+declare function handleRegularOpen(authorizationStatus: PushAuthorizationStatus): void;
+/**
+ * Handle when a push notification is opened by the user.
+ * Call this from your notification handler when the user taps a notification.
+ *
+ * On iOS, this will track the push open event and handle the notification appropriately
+ * based on whether the app was in the foreground, background, or not running.
+ * On Android, this is currently a no-op (TODO: implement FCM integration).
+ *
+ * @param userInfo - The notification payload from the push notification
+ * @param applicationState - The app state when the notification was opened ('active', 'inactive', 'background')
+ * @param authorizationStatus - Current push authorization status
+ *
+ * @example
+ * ```typescript
+ * import { handlePushOpened } from 'attentive-react-native-sdk';
+ *
+ * // In your notification handler:
+ * handlePushOpened(
+ *   notification.data,
+ *   'background',
+ *   'authorized'
+ * );
+ * ```
+ */
+declare function handlePushOpened(userInfo: PushNotificationUserInfo, applicationState: ApplicationState, authorizationStatus: PushAuthorizationStatus): void;
+/**
+ * Handle when a push notification arrives while the app is in the foreground.
+ * Call this from your notification handler when a notification is received while the app is active.
+ *
+ * On iOS, this allows the Attentive SDK to track the notification event.
+ * On Android, this is currently a no-op (TODO: implement FCM integration).
+ *
+ * @param userInfo - The notification payload from the push notification
+ *
+ * @example
+ * ```typescript
+ * import { handleForegroundNotification } from 'attentive-react-native-sdk';
+ *
+ * // In your notification handler when app is in foreground:
+ * handleForegroundNotification(notification.data);
+ * ```
+ */
+declare function handleForegroundNotification(userInfo: PushNotificationUserInfo): void;
+/**
+ * Handle a push notification when the app is in the foreground (active state).
+ * This is the React Native equivalent of the native iOS handleForegroundPush method.
+ *
+ * Call this when you receive a notification response and the app state is 'active'.
+ * This is part of implementing the native iOS pattern:
+ * ```swift
+ * case .active:
+ *   self.attentiveSdk?.handleForegroundPush(response: response, authorizationStatus: authStatus)
+ * ```
+ *
+ * On iOS, this properly tracks foreground push notifications.
+ * On Android, this is currently a no-op (TODO: implement FCM integration).
+ *
+ * @param userInfo - The notification payload from the push notification
+ * @param authorizationStatus - Current push authorization status
+ *
+ * @example
+ * ```typescript
+ * import { handleForegroundPush } from 'attentive-react-native-sdk';
+ * import { AppState } from 'react-native';
+ *
+ * // In your notification handler:
+ * const appState = AppState.currentState;
+ * if (appState === 'active') {
+ *   handleForegroundPush(notification.data, 'authorized');
+ * }
+ * ```
+ */
+declare function handleForegroundPush(userInfo: PushNotificationUserInfo, authorizationStatus: PushAuthorizationStatus): void;
+/**
+ * Handle when a push notification is opened by the user (app in background/inactive state).
+ * This is the React Native equivalent of the native iOS handlePushOpen method.
+ *
+ * Call this when you receive a notification response and the app state is 'background' or 'inactive'.
+ * This is part of implementing the native iOS pattern:
+ * ```swift
+ * case .background, .inactive:
+ *   self.attentiveSdk?.handlePushOpen(response: response, authorizationStatus: authStatus)
+ * ```
+ *
+ * On iOS, this properly tracks push notification opens.
+ * On Android, this is currently a no-op (TODO: implement FCM integration).
+ *
+ * @param userInfo - The notification payload from the push notification
+ * @param authorizationStatus - Current push authorization status
+ *
+ * @example
+ * ```typescript
+ * import { handlePushOpen } from 'attentive-react-native-sdk';
+ * import { AppState } from 'react-native';
+ *
+ * // In your notification handler:
+ * const appState = AppState.currentState;
+ * if (appState === 'background' || appState === 'inactive') {
+ *   handlePushOpen(notification.data, 'authorized');
+ * }
+ * ```
+ */
+declare function handlePushOpen(userInfo: PushNotificationUserInfo, authorizationStatus: PushAuthorizationStatus): void;
+export { initialize, triggerCreative, destroyCreative, updateDomain, identify, clearUser, recordAddToCartEvent, recordProductViewEvent, recordPurchaseEvent, recordCustomEvent, invokeAttentiveDebugHelper, exportDebugLogs, registerForPushNotifications, registerDeviceToken, registerDeviceTokenWithCallback, handleRegularOpen, handlePushOpened, handleForegroundNotification, handleForegroundPush, handlePushOpen, };
+export type { UserIdentifiers, AttentiveSdkConfiguration, ProductView, Purchase, AddToCart, CustomEvent, Item, PushAuthorizationStatus, ApplicationState, PushNotificationUserInfo, PushRegistrationResult, };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,WAAW,EACZ,MAAM,cAAc,CAAC;AAmBtB,oBAAY,IAAI;IACd,UAAU,eAAe;IACzB,KAAK,UAAU;CAChB;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,IAAI,CAAC;IACX,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CAC/C,CAAC;AAEF,qBAAa,SAAS;IACpB,MAAM,CAAC,UAAU,CAAC,aAAa,EAAE,sBAAsB,GAAG,IAAI;IAI9D,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI;IAIvD,MAAM,CAAC,SAAS,IAAI,IAAI;IAIxB,MAAM,CAAC,eAAe,CAAC,UAAU,GAAE,MAAM,GAAG,IAAW,GAAG,IAAI;IAI9D,MAAM,CAAC,eAAe,IAAI,IAAI;IAI9B,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAIzC,MAAM,CAAC,sBAAsB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,IAAI;IAIvE,MAAM,CAAC,oBAAoB,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI;IAIjE,MAAM,CAAC,mBAAmB,CAAC,aAAa,EAAE,aAAa,GAAG,IAAI;IAI9D,MAAM,CAAC,iBAAiB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;CAGzD;AAED,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@attentive-mobile/attentive-react-native-sdk",
-  "version": "1.0.3-beta.1",
+  "version": "2.0.0-beta.1",
   "description": "React Native Module for the Attentive SDK",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -31,11 +31,16 @@
     "test": "jest",
     "typecheck": "tsc --noEmit",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "build": "bob build",
     "prepack": "bob build",
     "release": "release-it",
-    "example": "yarn --cwd example",
-    "bootstrap": "yarn example && yarn install && yarn example pods",
-    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build"
+    "example": "npm --prefix example",
+    "bootstrap": "npm install && npm --prefix example install && npm --prefix example run pods",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build",
+    "dev:start": "npm run build && cd example && ./reset.sh && cd .. && npm run dev",
+    "dev": "npm --prefix example run start",
+    "dev:ios": "npm --prefix example run ios",
+    "dev:android": "npm --prefix example run android"
   },
   "keywords": [
     "attentive",
@@ -63,7 +68,6 @@
     "@release-it/conventional-changelog": "^5.0.0",
     "@types/jest": "^28.1.2",
     "@types/react": "~17.0.21",
-    "@types/react-native": "0.70.0",
     "commitlint": "^17.0.2",
     "del-cli": "^5.0.0",
     "eslint": "^8.4.1",
@@ -73,7 +77,7 @@
     "pod-install": "^0.1.0",
     "prettier": "^2.0.5",
     "react": "18.2.0",
-    "react-native": "0.71.19",
+    "react-native": "0.75.5",
     "react-native-builder-bob": "^0.20.4",
     "release-it": "^15.0.0",
     "typescript": "^4.5.2"
@@ -131,7 +135,8 @@
           "singleQuote": true,
           "tabWidth": 2,
           "trailingComma": "es5",
-          "useTabs": false
+          "useTabs": false,
+          "semi": false
         }
       ]
     }
@@ -145,7 +150,8 @@
     "singleQuote": true,
     "tabWidth": 2,
     "trailingComma": "es5",
-    "useTabs": false
+    "useTabs": false,
+    "semi": false
   },
   "react-native-builder-bob": {
     "source": "src",
@@ -161,6 +167,14 @@
       ]
     ]
   },
+  "codegenConfig": {
+    "name": "AttentiveReactNativeSdkSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.attentivereactnativesdk"
+    }
+  },
   "dependencies": {
     "@babel/runtime": "^7.27.0"
   }

package/src/NativeAttentiveReactNativeSdk.ts

@@ -0,0 +1,152 @@
+import type { TurboModule } from "react-native/Libraries/TurboModule/RCTExport";
+import { TurboModuleRegistry, NativeModules } from "react-native";
+
+export interface Spec extends TurboModule {
+  initialize: (
+    attentiveDomain: string,
+    mode: string,
+    skipFatigueOnCreatives: boolean,
+    enableDebugger: boolean
+  ) => void;
+  triggerCreative: (creativeId?: string) => void;
+  destroyCreative: () => void;
+  updateDomain: (domain: string) => void;
+  identify: (
+    phone?: string,
+    email?: string,
+    klaviyoId?: string,
+    shopifyId?: string,
+    clientUserId?: string,
+    customIdentifiers?: Object
+  ) => void;
+  clearUser: () => void;
+  recordAddToCartEvent: (
+    items: Array<{
+      productId: string;
+      productVariantId: string;
+      price: string;
+      currency: string;
+      productImage?: string;
+      name?: string;
+      quantity?: number;
+      category?: string;
+    }>,
+    deeplink?: string
+  ) => void;
+  recordProductViewEvent: (
+    items: Array<{
+      productId: string;
+      productVariantId: string;
+      price: string;
+      currency: string;
+      productImage?: string;
+      name?: string;
+      quantity?: number;
+      category?: string;
+    }>,
+    deeplink?: string
+  ) => void;
+  recordPurchaseEvent: (
+    items: Array<{
+      productId: string;
+      productVariantId: string;
+      price: string;
+      currency: string;
+      productImage?: string;
+      name?: string;
+      quantity?: number;
+      category?: string;
+    }>,
+    orderId: string,
+    cartId?: string,
+    cartCoupon?: string
+  ) => void;
+  recordCustomEvent: (type: string, properties: Object) => void;
+  invokeAttentiveDebugHelper: () => void;
+  exportDebugLogs: () => Promise<string>;
+
+  // Push Notification Methods (iOS only)
+  /**
+   * Request push notification permission from the user.
+   * iOS only - Android is a no-op.
+   */
+  registerForPushNotifications: () => void;
+
+  /**
+   * Register the device token received from APNs (simple version without callback).
+   * iOS only - Android is a no-op.
+   * @param token - The hex-encoded device token string
+   * @param authorizationStatus - Current push authorization status
+   */
+  registerDeviceToken: (token: string, authorizationStatus: string) => void;
+
+  /**
+   * Register the device token received from APNs with a callback.
+   * iOS only - Android is a no-op.
+   * The callback receives the response from the Attentive API after registration.
+   * @param token - The hex-encoded device token string
+   * @param authorizationStatus - Current push authorization status
+   * @param callback - Callback invoked after registration completes
+   */
+  registerDeviceTokenWithCallback: (
+    token: string,
+    authorizationStatus: string,
+    callback: (data?: Object, url?: string, response?: Object, error?: Object) => void
+  ) => void;
+
+  /**
+   * Handle regular/direct app open (not from a push notification).
+   * iOS only - Android is a no-op.
+   * This should be called after device token registration to track app opens.
+   * @param authorizationStatus - Current push authorization status
+   */
+  handleRegularOpen: (authorizationStatus: string) => void;
+
+  /**
+   * Handle when a push notification is opened by the user.
+   * iOS only - Android is a no-op.
+   * @param userInfo - The notification payload
+   * @param applicationState - The app state when notification was opened ('active', 'inactive', 'background')
+   * @param authorizationStatus - Current push authorization status
+   */
+  handlePushOpened: (
+    userInfo: Object,
+    applicationState: string,
+    authorizationStatus: string
+  ) => void;
+
+  /**
+   * Handle when a push notification arrives while the app is in foreground.
+   * iOS only - Android is a no-op.
+   * @param userInfo - The notification payload
+   */
+  handleForegroundNotification: (userInfo: Object) => void;
+
+  /**
+   * Handle a push notification when the app is in the foreground (active state).
+   * This is the React Native equivalent of calling handleForegroundPush in native iOS.
+   * iOS only - Android is a no-op.
+   * @param userInfo - The notification payload
+   * @param authorizationStatus - Current push authorization status
+   */
+  handleForegroundPush: (userInfo: Object, authorizationStatus: string) => void;
+
+  /**
+   * Handle when a push notification is opened by the user (app in background/inactive state).
+   * This is the React Native equivalent of calling handlePushOpen in native iOS.
+   * iOS only - Android is a no-op.
+   * @param userInfo - The notification payload
+   * @param authorizationStatus - Current push authorization status
+   */
+  handlePushOpen: (userInfo: Object, authorizationStatus: string) => void;
+}
+
+// Try to load via TurboModule first (new architecture)
+// Fall back to NativeModules for old architecture
+const isTurboModuleEnabled = (global as any).__turboModuleProxy != null;
+
+const AttentiveReactNativeSdkModule = isTurboModuleEnabled
+  ? TurboModuleRegistry.get<Spec>("AttentiveReactNativeSdk")
+  : NativeModules.AttentiveReactNativeSdk;
+
+export default AttentiveReactNativeSdkModule as Spec | null;

package/src/eventTypes.tsx

@@ -1,44 +1,81 @@
+export type UserIdentifiers = {
+  phone?: string;
+  email?: string;
+  klaviyoId?: string;
+  shopifyId?: string;
+  clientUserId?: string;
+  customIdentifiers?: Record<string, string>;
+};
+
+export type AttentiveSdkConfiguration = {
+  attentiveDomain: string;
+  mode: string; // "production" or "debug"
+  skipFatigueOnCreatives?: boolean;
+  enableDebugger?: boolean;
+};
+
+// Codegen does not support nested objects inside of arrays. We must flatten the Item type.
 export type Item = {
   productId: string;
   productVariantId: string;
-  price: Price;
+  price: string;
+  currency: string;
   productImage?: string;
   name?: string;
   quantity?: number;
   category?: string;
 };
 
-export type Price = {
-  price: string;
-  currency: string;
+export type ProductView = {
+  items: Item[];
+  deeplink?: string;
 };
 
-export type Order = {
+// Codegen does not support nested objects. We must flatten the Purchase type.
+export type Purchase = {
+  items: Item[];
   orderId: string;
-};
-
-export type Cart = {
   cartId?: string;
   cartCoupon?: string;
 };
 
-export type ProductViewEvent = {
+export type AddToCart = {
   items: Item[];
   deeplink?: string;
 };
 
-export type AddToCartEvent = {
-  items: Item[];
-  deeplink?: string;
-};
-
-export type PurchaseEvent = {
-  items: Item[];
-  order: Order;
-  cart?: Cart;
-};
-
 export type CustomEvent = {
   type: string;
   properties: Record<string, string>;
 };
+
+/**
+ * Push notification authorization status
+ * Maps to UNAuthorizationStatus on iOS
+ */
+export type PushAuthorizationStatus =
+  | 'authorized'
+  | 'denied'
+  | 'notDetermined'
+  | 'provisional'
+  | 'ephemeral';
+
+/**
+ * Application state when handling push notifications
+ */
+export type ApplicationState = 'active' | 'inactive' | 'background';
+
+/**
+ * Push notification user info payload
+ * Contains data from the remote notification
+ */
+export type PushNotificationUserInfo = Record<string, unknown>;
+
+/**
+ * Result of registering for push notifications
+ */
+export type PushRegistrationResult = {
+  success: boolean;
+  token?: string;
+  error?: string;
+};