zixflow-reactnative 1.1.2 → 1.1.4

package/src/index.ts

@@ -4,6 +4,11 @@
  * Zixflow React Native SDK - A powerful SDK for building
  * customer engagement features in React Native applications.
  */
-
-// Export the Zixflow API
-export * from './zixflow';
+export * from './zixflow-cdp';
+export * from './zixflow-geofence';
+export * from './zixflow-inapp';
+export * from './zixflow-liveactivities';
+export * from './zixflow-location';
+export * from './zixflow-push';
+export * from './components';
+export * from './types';

package/src/notification-inbox.ts

@@ -46,7 +46,7 @@ export type NotificationInboxSpec =
  * Helper function to parse raw inbox message from native layer
  * @internal
  */
-function parseInboxMessage(raw: any): InboxMessage {
+export function parseInboxMessage(raw: any): InboxMessage {
   return {
     queueId: raw.queueId,
     deliveryId: raw.deliveryId ?? undefined,

package/src/specs/components/NotificationInboxBellNativeComponent.ts

@@ -0,0 +1,24 @@
+// React Native docs now recommend Codegen types should be imported from the react-native package
+// But it breaks on Expo and older React Native versions, so we import from react-native/Libraries/Types/CodegenTypes
+// for compatibility with all versions until we can fully migrate to the new import style without breaking older versions
+// https://reactnative.dev/docs/strict-typescript-api#codegen-types-should-now-be-imported-from-the-react-native-package
+
+import type { HostComponent, ViewProps } from 'react-native';
+/* eslint-disable @react-native/no-deep-imports */
+import type { DirectEventHandler } from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+
+/** Event data for inbox bell taps. Carries no payload; presence indicates a tap. */
+export interface BellTapEvent {}
+
+/** Props for the native NotificationInboxBell component. */
+export interface NativeProps extends ViewProps {
+  /** Fired when the user taps the bell. Host should present its own inbox UI. */
+  onTap?: DirectEventHandler<BellTapEvent>;
+}
+
+// React Native Codegen automatically generates the native component bridge based on the NativeProps interface.
+// Public view is NotificationInboxBellView in the components directory.
+export default codegenNativeComponent<NativeProps>(
+  'NotificationInboxBellNative'
+) as HostComponent<NativeProps>;

package/src/specs/components/NotificationInboxViewNativeComponent.ts

@@ -0,0 +1,22 @@
+// React Native docs now recommend Codegen types should be imported from the react-native package
+// But it breaks on Expo and older React Native versions, so we import from react-native/Libraries/Types/CodegenTypes
+// for compatibility with all versions until we can fully migrate to the new import style without breaking older versions
+// https://reactnative.dev/docs/strict-typescript-api#codegen-types-should-now-be-imported-from-the-react-native-package
+
+import type { HostComponent, ViewProps } from 'react-native';
+/* eslint-disable @react-native/no-deep-imports */
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+
+/**
+ * Props for the native NotificationInboxView component (the Jist-rendered message list).
+ * No required props; the host controls sizing via standard ViewProps style.
+ * Message actions are handled by the existing global InboxEventListener, so this
+ * component needs no per-component action callback.
+ */
+export interface NativeProps extends ViewProps {}
+
+// React Native Codegen automatically generates the native component bridge based on the NativeProps interface.
+// Public view is NotificationInboxView in the components directory.
+export default codegenNativeComponent<NativeProps>(
+  'NotificationInboxViewNative'
+) as HostComponent<NativeProps>;

package/src/specs/modules/NativeZixflow.ts

@@ -1,5 +1,8 @@
 import { TurboModuleRegistry, type TurboModule } from 'react-native';
-import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import type {
+  EventEmitter,
+  UnsafeObject,
+} from 'react-native/Libraries/Types/CodegenTypes';
 
 /**
  * Native module specification for Zixflow React Native SDK
@@ -41,6 +44,11 @@ export interface Spec extends TurboModule {
     config: NativeBridgeObject,
     args: NativeBridgeObject
   ): Promise<void>;
+  setDeepLinkRoutingReady(): void;
+  readonly onDeepLinkReceived: EventEmitter<UnsafeObject>;
+  registerDeepLinkHandler(): void;
+  unregisterDeepLinkHandler(): void;
+  acknowledgeDeepLink(id: string, handled: boolean): void;
   identify(params?: NativeBridgeObject): void;
   clearIdentify(): void;
   track(name: string, properties?: NativeBridgeObject): void;

package/src/specs/modules/NativeZixflowGeofence.ts

@@ -0,0 +1,14 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+/**
+ * Native module specification for Zixflow Geofence React Native SDK
+ *
+ * @see NativeZixflow.ts for detailed documentation on TurboModule patterns,
+ * Codegen compatibility, and type safety approach.
+ */
+
+export interface Spec extends TurboModule {
+  refreshFromCurrentLocation(): void;
+}
+
+export default TurboModuleRegistry.get<Spec>('NativeZixflowGeofence');

package/src/specs/modules/NativeZixflowLiveActivities.ts

@@ -0,0 +1,39 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+
+/**
+ * Native module specification for Zixflow Live Activities React Native SDK
+ *
+ * Live Activities (iOS) / Live Notifications (Android) let you show a live,
+ * updating notification driven by a built-in template (Segments, Countdown Timer)
+ * or by a custom type you render yourself.
+ *
+ * @see NativeZixflow.ts for detailed documentation on TurboModule patterns,
+ * Codegen compatibility, and type safety approach.
+ */
+
+type NativeBridgeObject = UnsafeObject;
+
+export interface Spec extends TurboModule {
+  /** Report a Live Activity open and return the destination URL to route. */
+  handleWidgetUrl(url: string): Promise<string | null>;
+  /** Start an activity. Resolves with the SDK-minted activity id. */
+  start(payload: NativeBridgeObject): Promise<string>;
+  /** Replace the whole content-state of a running activity. Pass the full desired state. */
+  update(activityId: string, payload: NativeBridgeObject): Promise<void>;
+  /**
+   * End a running activity, optionally rendering a final content-state.
+   *
+   * `payload` is iOS-only: ActivityKit keeps the last content-state on screen unless a final one
+   * is supplied. Android renders its own terminal state, so it ignores the payload.
+   */
+  end(activityId: string, payload?: NativeBridgeObject): Promise<void>;
+}
+
+// Registered unconditionally on both platforms — Android in ZixflowReactNativePackage, iOS via
+// an ObjC bridge that is always compiled. When the Live Activities pods are absent the module is
+// still present and its methods reject with `live_activity_module_unavailable`, so `getEnforcing`
+// is accurate here (unlike Location, which really can be absent and uses `get`).
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'NativeZixflowLiveActivities'
+);

package/src/specs/modules/NativeZixflowMessagingInApp.ts

@@ -14,7 +14,16 @@ import type {
 /** TurboModule interface for Zixflow In-App Messaging native operations */
 export interface Spec extends TurboModule {
   dismissMessage(): void;
+  // Carries the ZixflowColorScheme string value; the enum itself cannot cross Codegen.
+  setColorScheme(colorScheme: string): void;
   readonly onInAppEventReceived: EventEmitter<UnsafeObject>;
+  // Notification Inbox event listener methods.
+  // Registers/unregisters a native forwarder with the SDK so inbox events
+  // (action taken, shown, opened, dismissed) are emitted to JS. Distinct from
+  // onInAppEventReceived so inbox events never collide with in-app events.
+  registerInboxEventListener(): void;
+  unregisterInboxEventListener(): void;
+  readonly onInboxEventReceived: EventEmitter<UnsafeObject>;
   // Notification Inbox related methods
   setupInboxListener(): void;
   readonly subscribeToMessagesChanged: EventEmitter<UnsafeObject>;
@@ -25,6 +34,8 @@ export interface Spec extends TurboModule {
   trackMessageClicked(message: UnsafeObject, actionName?: string): void;
 }
 
-export default TurboModuleRegistry.get<Spec>(
+// Registered unconditionally on both platforms, like MessagingPush and DataPipelines — not
+// gated by an optional subspec/module flag the way Location and Geofence are.
+export default TurboModuleRegistry.getEnforcing<Spec>(
   'NativeZixflowMessagingInApp'
 );

package/src/specs/modules/NativeZixflowMessagingPush.ts

@@ -22,6 +22,8 @@ export interface Spec extends TurboModule {
   getPushPermissionStatus(): Promise<string>;
 }
 
-export default TurboModuleRegistry.get<Spec>(
+// Registered unconditionally on both platforms, like MessagingInApp and DataPipelines — not
+// gated by an optional subspec/module flag the way Location and Geofence are.
+export default TurboModuleRegistry.getEnforcing<Spec>(
   'NativeZixflowMessagingPush'
 );

package/src/types/data-pipelines.ts

@@ -1,3 +1,6 @@
+import type { ZixflowColorScheme } from './in-app';
+import type { NotificationInboxAccessibilityLabels } from './inbox';
+import type { LiveActivitiesConfig } from './live-activities';
 import type { PushClickBehaviorAndroid } from './push';
 
 /**
@@ -36,11 +39,9 @@ export interface IdentifyParams {
 /**
  * Configuration options for initializing the Zixflow SDK.
  *
- * @param cdpApiKey - Customer Data Platform API key from Zixflow dashboard
- * @param migrationSiteId - Legacy site ID for migrating from tracking API
- * @param region - Data center region (US or EU)
+ * @param apiKey - API key from Zixflow dashboard
  * @param logLevel - SDK logging verbosity level
- * @param apiHost - Override the CDP API host. Use to route SDK traffic through a first-party proxy.
+ * @param apiHost - Override the API host. Use to route SDK traffic through a first-party proxy.
  * @param cdnHost - Override the CDN host. Use to route SDK traffic through a first-party proxy.
  * @param flushAt - Number of events to batch before sending
  * @param flushInterval - Time interval (seconds) to flush events
@@ -53,9 +54,7 @@ export interface IdentifyParams {
  * @public
  */
 export type ZixflowConfig = {
-  cdpApiKey: string;
-  migrationSiteId?: string;
-  region?: ZixflowRegion;
+  apiKey: string;
   logLevel?: ZixflowLogLevel;
   apiHost?: string;
   cdnHost?: string;
@@ -65,7 +64,19 @@ export type ZixflowConfig = {
   trackApplicationLifecycleEvents?: boolean;
   autoTrackDeviceAttributes?: boolean;
   inApp?: {
-    siteId?: string; // Optional: defaults to cdpApiKey if not provided
+    /**
+     * Color scheme used to render in-app messages. Defaults to `ZixflowColorScheme.Auto`, which
+     * follows the device appearance. Set it when the app has its own appearance setting that
+     * can disagree with the operating system.
+     *
+     * Can be changed after initialization with `Zixflow.inAppMessaging.setColorScheme`.
+     */
+    colorScheme?: ZixflowColorScheme;
+    /**
+     * Accessibility labels for the Visual Notification Inbox. Optional; an omitted label leaves
+     * that element unlabeled rather than falling back to English.
+     */
+    notificationInboxAccessibilityLabels?: NotificationInboxAccessibilityLabels;
   };
   push?: {
     android?: {
@@ -73,9 +84,32 @@ export type ZixflowConfig = {
     };
   };
   location?: {
-    /** Location tracking mode. Defaults to 'manual' if location config is provided. */
     trackingMode?: ZixflowLocationTrackingMode;
   };
+  /**
+   * Geofence configuration. Providing this opts the app into geofence monitoring,
+   * which runs automatically once enabled. Enabling geofence also enables the
+   * Location module, which geofence depends on.
+   */
+  geofence?: {
+    /**
+     * How the SDK acquires location fixes for geofence monitoring. Defaults to
+     * `AUTOMATIC` (the SDK acquires location itself on identify and app launch). Use
+     * `MANUAL` to drive refreshes yourself via
+     * `Zixflow.geofence.refreshFromCurrentLocation()`.
+     */
+    locationMode?: ZixflowGeofenceLocationMode;
+  };
+  /** iOS-only SDK configuration. Has no effect on Android. */
+  ios?: {
+    /**
+     * Whether geofence transitions are delivered in real time on a background cold-wake.
+     * When unset, defaults to on if the geofence module is enabled, off otherwise.
+     */
+    allowBackgroundDelivery?: boolean;
+  };
+  /** Live Activities (iOS) / Live Notifications (Android) configuration. */
+  liveNotifications?: LiveActivitiesConfig;
 };
 
 /**
@@ -96,16 +130,6 @@ export enum ZixflowLogLevel {
   Debug = 'debug',
 }
 
-/**
- * Data center regions for Zixflow API endpoints.
- *
- * @public
- */
-export enum ZixflowRegion {
-  US = 'US',
-  EU = 'EU',
-}
-
 /**
  * Screen view tracking behavior configuration.
  *
@@ -135,6 +159,18 @@ export enum ZixflowLocationTrackingMode {
   OnAppStart = 'ON_APP_START',
 }
 
+/**
+ * How the Geofence module acquires location fixes.
+ *
+ * @public
+ */
+export enum ZixflowGeofenceLocationMode {
+  /** SDK acquires location itself (on identify and app launch). Default. */
+  Automatic = 'AUTOMATIC',
+  /** Host drives refreshes via `Zixflow.geofence.refreshFromCurrentLocation()`. */
+  Manual = 'MANUAL',
+}
+
 /**
  * Enum to specify the type of metric for tracking
  *

package/src/types/in-app.ts

@@ -27,6 +27,29 @@ export enum InAppMessageEventType {
   messageShown = 'messageShown',
 }
 
+/**
+ * Color scheme used to render in-app messages.
+ *
+ * Selects which of the light/dark variants authored in the Zixflow editor is
+ * rendered. Use it when the app has its own appearance setting that can disagree with
+ * the operating system: `Auto` follows the device, while `Light` and `Dark` pin the
+ * variant regardless of it.
+ *
+ * The string values are the wire contract shared with both native SDKs, which match
+ * them lowercase and resolve anything unrecognized to `auto` — so they must stay
+ * exactly as written here even if the members are renamed.
+ *
+ * @public
+ */
+export enum ZixflowColorScheme {
+  /** Follow the device's current appearance. The default when unset. */
+  Auto = 'auto',
+  /** Always render the light variant, whatever the device is set to. */
+  Light = 'light',
+  /** Always render the dark variant, whatever the device is set to. */
+  Dark = 'dark',
+}
+
 /**
  * Represents an inbox message for a user.
  *

package/src/types/inbox.ts

@@ -0,0 +1,110 @@
+import type { InboxMessage } from './in-app';
+
+/**
+ * Enum representing the type of event triggered by an inbox event callback.
+ *
+ * Mirrors the native `InboxEventListener` contract on iOS and Android.
+ *
+ * @public
+ */
+export enum InboxEventType {
+  /** A non-dismiss action (e.g. a button/link) was taken on an inbox message. */
+  messageActionTaken = 'messageActionTaken',
+  /** An inbox message was first shown/rendered in the visible inbox view. */
+  messageShown = 'messageShown',
+  /** An inbox message was marked opened (e.g. when the panel opens). */
+  messageOpened = 'messageOpened',
+  /** An inbox message was dismissed/removed from the inbox. */
+  messageDismissed = 'messageDismissed',
+}
+
+/**
+ * Event delivered to a registered inbox event listener.
+ *
+ * `messageActionTaken` carries `actionName`/`actionValue`; the observational
+ * events (`messageShown`, `messageOpened`, `messageDismissed`) carry only the
+ * message.
+ *
+ * @public
+ */
+export class InboxMessageEvent {
+  /** The type of inbox event. */
+  eventType: InboxEventType;
+  /** The inbox message the event relates to. */
+  message: InboxMessage;
+  /** The Jist action name (only present for `messageActionTaken`). */
+  actionName?: string;
+  /** The resolved action value, typically a url (only present for `messageActionTaken`). */
+  actionValue?: string;
+
+  constructor(
+    eventType: InboxEventType,
+    message: InboxMessage,
+    actionName?: string,
+    actionValue?: string
+  ) {
+    this.eventType = eventType;
+    this.message = message;
+    this.actionName = actionName;
+    this.actionValue = actionValue;
+  }
+}
+
+/**
+ * Host-provided accessibility labels for the Visual Notification Inbox UI.
+ *
+ * The SDK ships no text of its own in the visual inbox — the empty state is an icon and the
+ * loading state is a spinner — so accessibility labels are the one place a string is still
+ * needed. Because the SDK cannot know your app's language, every label is optional and unset by
+ * default, and an omitted label leaves that element unlabeled rather than falling back to
+ * English. Pass strings already localized for the user's language.
+ *
+ * @example
+ * ```ts
+ * Zixflow.initialize({
+ *   apiKey: '...',
+ *   inApp: {
+ *     siteId: '...',
+ *     notificationInboxAccessibilityLabels: {
+ *       bell: t('inbox.bell'),
+ *       bellWithUnreadCount: t('inbox.unread'), // e.g. "{count} unread notifications"
+ *       loadingIndicator: t('inbox.loading'),
+ *       emptyState: t('inbox.empty'),
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * @public
+ */
+export type NotificationInboxAccessibilityLabels = {
+  /**
+   * Label for the inbox bell button. Also used when the bell shows an unread badge but
+   * `bellWithUnreadCount` is not provided. Unset → the bell is announced as an unnamed button
+   * (it stays focusable and tappable; hiding it would leave screen reader users no way in).
+   */
+  bell?: string;
+  /**
+   * Label for the bell while it shows an unread badge. Include `{count}` where the number of
+   * unread messages should appear; it is substituted at render time. Unset → falls back to `bell`.
+   *
+   * The badge itself is always hidden from assistive technologies, so the count is announced
+   * only through this label, never as bare digits appended to the button.
+   *
+   * This is a template rather than a function because configuration crosses the native bridge,
+   * which carries data but not callbacks. One template cannot express languages whose plural
+   * rules need a distinct form per count.
+   */
+  bellWithUnreadCount?: string;
+  /**
+   * Label announced for the loading spinner.
+   *
+   * Unset behaves differently per platform: on Android the spinner keeps its indeterminate
+   * progress role, which TalkBack describes in the device's own language, while on iOS it is not
+   * an accessibility element at all, so VoiceOver skips it rather than focusing an unnamed
+   * control. Set a label if you want the loading state announced on both.
+   */
+  loadingIndicator?: string;
+  /** Label announced for the empty-state icon. Unset → the icon is treated as decorative. */
+  emptyState?: string;
+};

package/src/types/index.ts

@@ -1,3 +1,5 @@
 export * from './data-pipelines';
 export * from './in-app';
+export * from './inbox';
+export * from './live-activities';
 export * from './push';

package/src/types/live-activities.ts

@@ -0,0 +1,170 @@
+/**
+ * Public types for the Live Activities module.
+ *
+ * Live Activities (iOS) / Live Notifications (Android) render live, updating
+ * notifications from built-in templates. Two templates ship today: Segments and
+ * Countdown Timer. Field names and identifiers are identical across platforms.
+ */
+
+/**
+ * Built-in activity type identifiers usable from the wrapper.
+ *
+ * The values are the reverse-DNS identifiers Zixflow uses everywhere — the
+ * `notificationType` on the wire, Android's `LiveNotificationType`, and iOS's
+ * `CIOSegmentsAttributes.identifier` — so JS, both native SDKs, and the backend
+ * share one vocabulary.
+ *
+ * Use these enum members (not raw strings) for `LiveActivitiesConfig.types` and a
+ * payload's `type` to avoid typos.
+ *
+ * @public
+ */
+export enum LiveActivityTemplate {
+  Segments = 'com.zixflow.livenotifications.segments',
+  CountdownTimer = 'com.zixflow.livenotifications.countdowntimer',
+  /**
+   * Your own activity type, rendered by SwiftUI you write.
+   *
+   * Unlike the members above, this value is a marker rather than an identifier — your activity is
+   * named by {@link LiveActivitiesConfig.customType}, and the SDK reports it under that name. It
+   * belongs in a payload's `type`, never in {@link LiveActivitiesConfig.types}.
+   */
+  Custom = 'custom',
+}
+
+/**
+ * Segments template — a progress activity split into N segments.
+ * `header` is a static attribute (fixed at start); the rest are content-state.
+ *
+ * @public
+ */
+export interface LiveActivitySegmentsPayload {
+  type: LiveActivityTemplate.Segments;
+  /** Static header line (set at start, never changes). */
+  header: string;
+  /** Primary status line. */
+  status: string;
+  /** Optional secondary status line. */
+  substatus?: string;
+  /** Total number of segments. */
+  segmentsTotal: number;
+  /** Number of completed segments (clamped to 0..segmentsTotal). */
+  segmentsComplete: number;
+  /** Optional trailing text (e.g. an ETA). */
+  trailingText?: string;
+}
+
+/**
+ * Custom template — your own activity type, rendered by SwiftUI you write.
+ *
+ * Unlike the built-in templates there is no schema: `data` is an untyped map, because a bridge
+ * payload carries nothing for the SDK to validate against. Every value is a string, so your widget
+ * parses whichever ones it needs.
+ *
+ * Requires {@link LiveActivitiesConfig.customType} to be set. On iOS you must also render
+ * `CIOCustomAttributes` in your Widget Extension; on Android your `createLiveNotification`
+ * callback receives the same map.
+ *
+ * @public
+ */
+export interface LiveActivityCustomPayload {
+  type: LiveActivityTemplate.Custom;
+  /**
+   * The full content-state, re-sent in its entirety on every update. Neither platform keeps a
+   * static/dynamic split for custom types, so include anything your widget needs each time.
+   *
+   * Values must be strings. Numbers and booleans are coerced, but nested objects and arrays are
+   * not supported and the platforms disagree on them — iOS drops them, Android stringifies them —
+   * so flatten anything structured before sending it.
+   */
+  data: Record<string, string>;
+}
+
+/**
+ * Countdown Timer template — a live countdown to a target time.
+ * `header` is a static attribute (fixed at start); the rest are content-state.
+ *
+ * @public
+ */
+export interface LiveActivityCountdownTimerPayload {
+  type: LiveActivityTemplate.CountdownTimer;
+  /** Static header line (set at start, never changes). */
+  header: string;
+  /** Primary title line. */
+  title: string;
+  /** Optional status message. */
+  statusMessage?: string;
+  /** Target time as epoch **seconds**. Omit to render the finished state. */
+  endTime?: number;
+}
+
+/**
+ * Payload for {@link ZixflowLiveActivities.start} and
+ * {@link ZixflowLiveActivities.update}.
+ *
+ * Because ActivityKit replaces content-state wholesale on update, `update` takes the
+ * same full payload as `start` — pass the complete desired state each time.
+ *
+ * @public
+ */
+export type LiveActivityPayload =
+  | LiveActivitySegmentsPayload
+  | LiveActivityCountdownTimerPayload
+  | LiveActivityCustomPayload;
+
+/**
+ * Live Activities branding (Android only). On iOS, branding is compiled into the
+ * widget extension's SwiftUI, so these values are ignored there.
+ *
+ * @public
+ */
+export interface LiveActivitiesBranding {
+  /** Reserved for future use. */
+  companyName?: string;
+  /** Accent color as "#RRGGBB". */
+  accentColorHex?: string;
+  /**
+   * Bundled Android drawable resource name for the logo, resolved natively.
+   * Preferred over {@link LiveActivitiesBranding.logoUrl} when both are set — it
+   * needs no network.
+   */
+  logoResource?: string;
+  /** Remote logo URL (downloaded and cached natively). */
+  logoUrl?: string;
+  /** Android drawable resource name, resolved natively. */
+  smallIconResource?: string;
+}
+
+/**
+ * Live Activities configuration, passed under the `liveNotifications` key of the SDK config.
+ *
+ * @public
+ */
+export interface LiveActivitiesConfig {
+  /**
+   * Built-in activity types to enable. Enables the matching native type on each
+   * platform and registers push-to-start for it. Unrecognized identifiers are
+   * ignored, so a newer native template can't break an older wrapper build.
+   *
+   * `Custom` is excluded on purpose — it is enabled by {@link LiveActivitiesConfig.customType},
+   * and both platforms would silently drop it from this list.
+   */
+  types?: Exclude<LiveActivityTemplate, LiveActivityTemplate.Custom>[];
+  /**
+   * Your own reverse-DNS identifier for the custom activity type, e.g.
+   * `'com.myapp.rideshare'`. Setting it enables the custom template on both platforms.
+   *
+   * Start one with `{ type: LiveActivityTemplate.Custom, data: { … } }`; the SDK reports it
+   * under this identifier, and your campaigns target it by the same name.
+   *
+   * Singular by design: iOS resolves an activity's type from its Swift attributes type, and
+   * every custom activity shares one. A second identifier could not be told apart, so one
+   * identifier is the limit rather than a silent mis-attribution.
+   *
+   * You must also render it yourself — `CIOCustomAttributes` in an iOS Widget Extension, and
+   * the `createLiveNotification` callback on Android.
+   */
+  customType?: string;
+  /** Android Live Notification branding (ignored on iOS). */
+  branding?: LiveActivitiesBranding;
+}