@onesignal/capacitor-plugin 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1012 @@
+import { Plugin } from "@capacitor/core";
+
+//#region src/OSNotification.d.ts
+type ReceivedEvent = Omit<OSNotification, 'display' | 'rawPayload'> & {
+  rawPayload: string | object;
+};
+declare class OSNotification {
+  body: string;
+  sound?: string;
+  title?: string;
+  launchURL?: string;
+  rawPayload: object;
+  actionButtons?: object[];
+  additionalData: object;
+  notificationId: string;
+  groupKey?: string;
+  groupMessage?: string;
+  groupedNotifications?: object[];
+  ledColor?: string;
+  priority?: number;
+  smallIcon?: string;
+  largeIcon?: string;
+  bigPicture?: string;
+  collapseId?: string;
+  fromProjectNumber?: string;
+  smallIconAccentColor?: string;
+  lockScreenVisibility?: string;
+  androidNotificationId?: number;
+  badge?: string;
+  badgeIncrement?: string;
+  category?: string;
+  threadId?: string;
+  subtitle?: string;
+  templateId?: string;
+  templateName?: string;
+  attachments?: object;
+  mutableContent?: boolean;
+  contentAvailable?: string;
+  relevanceScore?: number;
+  interruptionLevel?: string;
+  constructor(receivedEvent: ReceivedEvent);
+  /**
+   * Display the notification.
+   * @returns void
+   */
+  display(): void;
+}
+//#endregion
+//#region src/NotificationReceivedEvent.d.ts
+declare class NotificationWillDisplayEvent {
+  private notification;
+  constructor(displayEvent: OSNotification);
+  /**
+   * Call this to prevent OneSignal from displaying the notification automatically.
+   * This method can be called up to two times with false and then true, if processing time is needed.
+   * Typically this is only possible within a short
+   * time-frame (~30 seconds) after the notification is received on the device.
+   * @param discard an [preventDefault] set to true to dismiss the notification with no
+   * possibility of displaying it in the future.
+   */
+  preventDefault(discard?: boolean): void;
+  getNotification(): OSNotification;
+}
+//#endregion
+//#region src/types/NotificationClicked.d.ts
+type NotificationEventName = 'click' | 'foregroundWillDisplay' | 'permissionChange';
+type NotificationEventTypeMap = {
+  click: NotificationClickEvent;
+  foregroundWillDisplay: NotificationWillDisplayEvent;
+  permissionChange: boolean;
+};
+interface NotificationClickEvent {
+  result: NotificationClickResult;
+  notification: OSNotification;
+}
+interface NotificationClickResult {
+  actionId?: string;
+  url?: string;
+}
+//#endregion
+//#region src/NotificationsNamespace.d.ts
+declare const OSNotificationPermission: {
+  readonly NotDetermined: 0;
+  readonly Denied: 1;
+  readonly Authorized: 2;
+  readonly Provisional: 3;
+  readonly Ephemeral: 4;
+};
+type OSNotificationPermission = (typeof OSNotificationPermission)[keyof typeof OSNotificationPermission];
+declare class Notifications implements OneSignalNotificationsAPI {
+  private _plugin;
+  private _permissionObserverList;
+  private _notificationClickedListeners;
+  private _notificationWillDisplayListeners;
+  private _hasRegisteredClickListener;
+  private _hasRegisteredForegroundWillDisplayListener;
+  private _hasRegisteredPermissionListener;
+  constructor(plugin: OneSignalCapacitorPlugin);
+  private _processFunctionList;
+  /**
+   * Whether this app has push notification permission. Returns true if the user has accepted permissions,
+   * or if the app has ephemeral or provisional permission.
+   */
+  hasPermission(): Promise<boolean>;
+  /**
+   * iOS Only.
+   * Returns the native permission of the device.
+   * @returns {Promise<OSNotificationPermission>}
+   */
+  permissionNative(): Promise<OSNotificationPermission>;
+  /**
+   * Prompt the user for permission to receive push notifications.
+   * Use the fallbackToSettings parameter to prompt to open the settings app if a user has already declined push permissions.
+   * @param  {boolean} fallbackToSettings
+   * @returns {Promise<boolean>}
+   */
+  requestPermission(fallbackToSettings?: boolean): Promise<boolean>;
+  /**
+   * Whether attempting to request notification permission will show a prompt.
+   * Returns true if the device has not been prompted for push notification permission already.
+   * @returns {Promise<boolean>}
+   */
+  canRequestPermission(): Promise<boolean>;
+  /**
+   * iOS Only.
+   * Instead of having to prompt the user for permission to send them push notifications,
+   * your app can request provisional authorization.
+   * @param  {(response: boolean)=>void} handler
+   * @returns void
+   */
+  registerForProvisionalAuthorization(handler?: (response: boolean) => void): void;
+  /**
+   * Add listeners for notification events.
+   * @param event
+   * @param listener
+   * @returns
+   */
+  addEventListener<K extends NotificationEventName>(event: K, listener: (event: NotificationEventTypeMap[K]) => void): void;
+  /**
+   * Remove listeners for notification events.
+   * @param event
+   * @param listener
+   * @returns
+   */
+  removeEventListener<K extends NotificationEventName>(event: K, listener: (obj: NotificationEventTypeMap[K]) => void): void;
+  /**
+   * Removes all OneSignal notifications.
+   * @returns Promise<void>
+   */
+  clearAll(): Promise<void>;
+  /**
+   * Android only.
+   * Cancels a single OneSignal notification based on its Android notification integer ID.
+   * @param  {number} id - notification id to cancel
+   * @returns Promise<void>
+   */
+  removeNotification(id: number): Promise<void>;
+  /**
+   * Android only.
+   * Cancels a group of OneSignal notifications with the provided group key.
+   * @param  {string} id - notification group id to cancel
+   * @returns Promise<void>
+   */
+  removeGroupedNotifications(id: string): Promise<void>;
+}
+//#endregion
+//#region src/definitions.d.ts
+interface OneSignalCapacitorPlugin extends Plugin {
+  initialize(options: {
+    appId: string;
+  }): Promise<void>;
+  login(options: {
+    externalId: string;
+  }): Promise<void>;
+  logout(): Promise<void>;
+  setConsentRequired(options: {
+    required: boolean;
+  }): Promise<void>;
+  setConsentGiven(options: {
+    granted: boolean;
+  }): Promise<void>;
+  setLogLevel(options: {
+    logLevel: LogLevel;
+  }): Promise<void>;
+  setAlertLevel(options: {
+    logLevel: LogLevel;
+  }): Promise<void>;
+  setLanguage(options: {
+    language: string;
+  }): Promise<void>;
+  addAliases(options: {
+    aliases: Record<string, string>;
+  }): Promise<void>;
+  removeAliases(options: {
+    labels: string[];
+  }): Promise<void>;
+  addEmail(options: {
+    email: string;
+  }): Promise<void>;
+  removeEmail(options: {
+    email: string;
+  }): Promise<void>;
+  addSms(options: {
+    smsNumber: string;
+  }): Promise<void>;
+  removeSms(options: {
+    smsNumber: string;
+  }): Promise<void>;
+  addTags(options: {
+    tags: Record<string, string>;
+  }): Promise<void>;
+  removeTags(options: {
+    keys: string[];
+  }): Promise<void>;
+  getTags(): Promise<{
+    tags: Record<string, string>;
+  }>;
+  getOnesignalId(): Promise<{
+    onesignalId: string | null;
+  }>;
+  getExternalId(): Promise<{
+    externalId: string | null;
+  }>;
+  trackEvent(options: {
+    name: string;
+    properties?: Record<string, unknown>;
+  }): Promise<void>;
+  getPushSubscriptionId(): Promise<{
+    id: string | null;
+  }>;
+  getPushSubscriptionToken(): Promise<{
+    token: string | null;
+  }>;
+  getPushSubscriptionOptedIn(): Promise<{
+    optedIn: boolean;
+  }>;
+  optInPushSubscription(): Promise<void>;
+  optOutPushSubscription(): Promise<void>;
+  getPermission(): Promise<{
+    permission: boolean;
+  }>;
+  permissionNative(): Promise<{
+    permission: OSNotificationPermission;
+  }>;
+  requestPermission(options: {
+    fallbackToSettings: boolean;
+  }): Promise<{
+    permission: boolean;
+  }>;
+  canRequestPermission(): Promise<{
+    canRequest: boolean;
+  }>;
+  registerForProvisionalAuthorization(): Promise<{
+    accepted: boolean;
+  }>;
+  clearAllNotifications(): Promise<void>;
+  removeNotification(options: {
+    id: number;
+  }): Promise<void>;
+  removeGroupedNotifications(options: {
+    id: string;
+  }): Promise<void>;
+  preventDefault(options: {
+    notificationId: string;
+    discard: boolean;
+  }): Promise<void>;
+  proceedWithWillDisplay(options: {
+    notificationId: string;
+  }): Promise<void>;
+  displayNotification(options: {
+    notificationId: string;
+  }): Promise<void>;
+  addTriggers(options: {
+    triggers: Record<string, string>;
+  }): Promise<void>;
+  removeTriggers(options: {
+    keys: string[];
+  }): Promise<void>;
+  clearTriggers(): Promise<void>;
+  setPaused(options: {
+    pause: boolean;
+  }): Promise<void>;
+  isPaused(): Promise<{
+    paused: boolean;
+  }>;
+  addOutcome(options: {
+    name: string;
+  }): Promise<void>;
+  addUniqueOutcome(options: {
+    name: string;
+  }): Promise<void>;
+  addOutcomeWithValue(options: {
+    name: string;
+    value: number;
+  }): Promise<void>;
+  requestLocationPermission(): Promise<void>;
+  setLocationShared(options: {
+    shared: boolean;
+  }): Promise<void>;
+  isLocationShared(): Promise<{
+    shared: boolean;
+  }>;
+  enterLiveActivity(options: {
+    activityId: string;
+    token: string;
+  }): Promise<void>;
+  exitLiveActivity(options: {
+    activityId: string;
+  }): Promise<void>;
+  setPushToStartToken(options: {
+    activityType: string;
+    token: string;
+  }): Promise<void>;
+  removePushToStartToken(options: {
+    activityType: string;
+  }): Promise<void>;
+  setupDefaultLiveActivity(options?: {
+    enablePushToStart: boolean;
+    enablePushToUpdate: boolean;
+  }): Promise<void>;
+  startDefaultLiveActivity(options: {
+    activityId: string;
+    attributes: Record<string, unknown>;
+    content: Record<string, unknown>;
+  }): Promise<void>;
+}
+//#endregion
+//#region src/DebugNamespace.d.ts
+declare const LogLevel: {
+  readonly None: 0;
+  readonly Fatal: 1;
+  readonly Error: 2;
+  readonly Warn: 3;
+  readonly Info: 4;
+  readonly Debug: 5;
+  readonly Verbose: 6;
+};
+type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+declare class Debug implements OneSignalDebugAPI {
+  private _plugin;
+  constructor(plugin: OneSignalCapacitorPlugin);
+  /**
+   * Enable logging to help debug if you run into an issue setting up OneSignal.
+   * @param  {LogLevel} logLevel - Sets the logging level to print to the Android LogCat log or Xcode log.
+   * @returns void
+   */
+  setLogLevel(logLevel: LogLevel): void;
+  /**
+   * Enable logging to help debug if you run into an issue setting up OneSignal.
+   * @param  {LogLevel} visualLogLevel - Sets the logging level to show as alert dialogs.
+   * @returns void
+   */
+  setAlertLevel(visualLogLevel: LogLevel): void;
+}
+//#endregion
+//#region src/PushSubscriptionNamespace.d.ts
+interface PushSubscriptionState {
+  id?: string;
+  token?: string;
+  optedIn: boolean;
+}
+interface PushSubscriptionChangedState {
+  previous: PushSubscriptionState;
+  current: PushSubscriptionState;
+}
+declare class PushSubscription implements OneSignalPushSubscriptionAPI {
+  private _plugin;
+  private _subscriptionObserverList;
+  constructor(plugin: OneSignalCapacitorPlugin);
+  private _processFunctionList;
+  /**
+   * The readonly push subscription ID.
+   * @returns {Promise<string | null>}
+   */
+  getIdAsync(): Promise<string | null>;
+  /**
+   * The readonly push token.
+   * @returns {Promise<string | null>}
+   */
+  getTokenAsync(): Promise<string | null>;
+  /**
+   * Gets a boolean value indicating whether the current user is opted in to push notifications.
+   * This returns true when the app has notifications permission and optOut() is NOT called.
+   * Note: Does not take into account the existence of the subscription ID and push token.
+   * This boolean may return true but push notifications may still not be received by the user.
+   * @returns {Promise<boolean>}
+   */
+  getOptedInAsync(): Promise<boolean>;
+  /**
+   * Add a callback that fires when the OneSignal push subscription state changes.
+   * @param  {(event: PushSubscriptionChangedState)=>void} listener
+   * @returns void
+   */
+  addEventListener(_event: 'change', listener: (event: PushSubscriptionChangedState) => void): void;
+  /**
+   * Remove a push subscription observer that has been previously added.
+   * @param  {(event: PushSubscriptionChangedState)=>void} listener
+   * @returns void
+   */
+  removeEventListener(_event: 'change', listener: (event: PushSubscriptionChangedState) => void): void;
+  /**
+   * Call this method to receive push notifications on the device or to resume receiving of push notifications after calling optOut. If needed, this method will prompt the user for push notifications permission.
+   * @returns Promise<void>
+   */
+  optIn(): Promise<void>;
+  /**
+   * If at any point you want the user to stop receiving push notifications on the current device (regardless of system-level permission status), you can call this method to opt out.
+   * @returns Promise<void>
+   */
+  optOut(): Promise<void>;
+}
+//#endregion
+//#region src/types/InAppMessage.d.ts
+type InAppMessageEventName = 'click' | 'willDisplay' | 'didDisplay' | 'willDismiss' | 'didDismiss';
+type InAppMessageEventTypeMap = {
+  click: InAppMessageClickEvent;
+  willDisplay: InAppMessageWillDisplayEvent;
+  didDisplay: InAppMessageDidDisplayEvent;
+  willDismiss: InAppMessageWillDismissEvent;
+  didDismiss: InAppMessageDidDismissEvent;
+};
+interface InAppMessageClickEvent {
+  message: OSInAppMessage;
+  result: InAppMessageClickResult;
+}
+interface InAppMessageClickResult {
+  closingMessage: boolean;
+  actionId?: string;
+  url?: string;
+  urlTarget?: InAppMessageActionUrlType;
+}
+type InAppMessageActionUrlType = 'browser' | 'webview' | 'replacement';
+interface InAppMessageWillDisplayEvent {
+  message: OSInAppMessage;
+}
+interface InAppMessageDidDisplayEvent {
+  message: OSInAppMessage;
+}
+interface InAppMessageWillDismissEvent {
+  message: OSInAppMessage;
+}
+interface InAppMessageDidDismissEvent {
+  message: OSInAppMessage;
+}
+interface OSInAppMessage {
+  messageId: string;
+}
+//#endregion
+//#region src/types/LiveActivities.d.ts
+/**
+ * The setup options for `OneSignal.LiveActivities.setupDefault`.
+ */
+type LiveActivitySetupOptions = {
+  /**
+   * When true, OneSignal will listen for pushToStart tokens for the `OneSignalLiveActivityAttributes` structure.
+   */
+  enablePushToStart: boolean;
+  /**
+   * When true, OneSignal will listen for pushToUpdate  tokens for each start live activity that uses the
+   * `OneSignalLiveActivityAttributes` structure.
+   */
+  enablePushToUpdate: boolean;
+};
+//#endregion
+//#region src/UserNamespace.d.ts
+interface UserState {
+  onesignalId?: string;
+  externalId?: string;
+}
+interface UserChangedState {
+  current: UserState;
+}
+declare class User implements OneSignalUserAPI {
+  pushSubscription: PushSubscription;
+  private _plugin;
+  private _userStateObserverList;
+  constructor(plugin: OneSignalCapacitorPlugin);
+  private _processFunctionList;
+  /**
+   * Explicitly set a 2-character language code for the user.
+   * @param  {string} language
+   * @returns Promise<void>
+   */
+  setLanguage(language: string): Promise<void>;
+  /**
+   * Set an alias for the current user. If this alias label already exists on this user, it will be overwritten with the new alias id.
+   * @param  {string} label
+   * @param  {string} id
+   * @returns Promise<void>
+   */
+  addAlias(label: string, id: string): Promise<void>;
+  /**
+   * Set aliases for the current user. If any alias already exists, it will be overwritten to the new values.
+   * @param {object} aliases
+   * @returns Promise<void>
+   */
+  addAliases(aliases: Record<string, string>): Promise<void>;
+  /**
+   * Remove an alias from the current user.
+   * @param  {string} label
+   * @returns Promise<void>
+   */
+  removeAlias(label: string): Promise<void>;
+  /**
+   * Remove aliases from the current user.
+   * @param  {string[]} labels
+   * @returns Promise<void>
+   */
+  removeAliases(labels: string[]): Promise<void>;
+  /**
+   * Add a new email subscription to the current user.
+   * @param  {string} email
+   * @returns Promise<void>
+   */
+  addEmail(email: string): Promise<void>;
+  /**
+   * Remove an email subscription from the current user.
+   * @param {string} email
+   * @returns Promise<void>
+   */
+  removeEmail(email: string): Promise<void>;
+  /**
+   * Add a new SMS subscription to the current user.
+   * @param  {string} smsNumber
+   * @returns Promise<void>
+   */
+  addSms(smsNumber: string): Promise<void>;
+  /**
+   * Remove an SMS subscription from the current user.
+   * @param {string} smsNumber
+   * @returns Promise<void>
+   */
+  removeSms(smsNumber: string): Promise<void>;
+  /**
+   * Add a tag for the current user. Tags are key:value string pairs used as building blocks for targeting specific users and/or personalizing messages.
+   * @param  {string} key
+   * @param  {string} value
+   * @returns Promise<void>
+   */
+  addTag(key: string, value: string): Promise<void>;
+  /**
+   * Add multiple tags for the current user. Tags are key:value string pairs used as building blocks for targeting specific users and/or personalizing messages.
+   * @param  {object} tags
+   * @returns Promise<void>
+   */
+  addTags(tags: object): Promise<void>;
+  /**
+   * Remove the data tag with the provided key from the current user.
+   * @param  {string} key
+   * @returns Promise<void>
+   */
+  removeTag(key: string): Promise<void>;
+  /**
+   * Remove multiple tags with the provided keys from the current user.
+   * @param  {string[]} keys
+   * @returns Promise<void>
+   */
+  removeTags(keys: string[]): Promise<void>;
+  /**
+   * Returns the local tags for the current user.
+   * @returns Promise<{ [key: string]: string }>
+   */
+  getTags(): Promise<{
+    [key: string]: string;
+  }>;
+  /**
+   * Add a callback that fires when the OneSignal User state changes.
+   * @param  {(event: UserChangedState)=>void} listener
+   * @returns void
+   */
+  addEventListener(_event: 'change', listener: (event: UserChangedState) => void): void;
+  /**
+   * Remove a User State observer that has been previously added.
+   * @param  {(event: UserChangedState)=>void} listener
+   * @returns void
+   */
+  removeEventListener(_event: 'change', listener: (event: UserChangedState) => void): void;
+  /**
+   * Get the nullable OneSignal Id associated with the current user.
+   * @returns {Promise<string | null>}
+   */
+  getOnesignalId(): Promise<string | null>;
+  /**
+   * Get the nullable External Id associated with the current user.
+   * @returns {Promise<string | null>}
+   */
+  getExternalId(): Promise<string | null>;
+  /**
+   * Track a custom event with the provided name and optional properties.
+   * @param  {string} name - The name of the custom event
+   * @param  {object} [properties] - Optional properties to associate with the event
+   * @returns Promise<void>
+   */
+  trackEvent(name: string, properties?: object): Promise<void>;
+}
+//#endregion
+//#region src/api.d.ts
+/**
+ * Debug helpers exposed via `OneSignal.Debug`.
+ */
+interface OneSignalDebugAPI {
+  /** Set the log level printed to LogCat (Android) or the Xcode console (iOS). */
+  setLogLevel(logLevel: LogLevel): void;
+  /** Set the log level shown to the user as alert dialogs. */
+  setAlertLevel(visualLogLevel: LogLevel): void;
+}
+/**
+ * Push subscription state and controls exposed via `OneSignal.User.pushSubscription`.
+ */
+interface OneSignalPushSubscriptionAPI {
+  /** Get the current device's push subscription ID, or null if not yet assigned. */
+  getIdAsync(): Promise<string | null>;
+  /** Get the current device's push token, or null if not yet available. */
+  getTokenAsync(): Promise<string | null>;
+  /**
+   * Whether the current user is opted in to push notifications. Returns true when the app has
+   * notification permission and `optOut()` has not been called. Does not guarantee a token has
+   * been received.
+   */
+  getOptedInAsync(): Promise<boolean>;
+  /** Add a listener for push subscription state changes. */
+  addEventListener(event: 'change', listener: (event: PushSubscriptionChangedState) => void): void;
+  /** Remove a previously added push subscription state listener. */
+  removeEventListener(event: 'change', listener: (event: PushSubscriptionChangedState) => void): void;
+  /** Opt the user in to push notifications. Prompts for permission if needed. */
+  optIn(): Promise<void>;
+  /** Opt the user out of push notifications on this device. */
+  optOut(): Promise<void>;
+}
+/**
+ * Current-user operations exposed via `OneSignal.User`.
+ */
+interface OneSignalUserAPI {
+  /** Push subscription controls for the current user. */
+  pushSubscription: OneSignalPushSubscriptionAPI;
+  /** Explicitly set a 2-character language code for the current user. */
+  setLanguage(language: string): Promise<void>;
+  /** Add or overwrite a single alias on the current user. */
+  addAlias(label: string, id: string): Promise<void>;
+  /** Add or overwrite multiple aliases on the current user. */
+  addAliases(aliases: Record<string, string>): Promise<void>;
+  /** Remove a single alias by label from the current user. */
+  removeAlias(label: string): Promise<void>;
+  /** Remove multiple aliases by label from the current user. */
+  removeAliases(labels: string[]): Promise<void>;
+  /** Add a new email subscription to the current user. */
+  addEmail(email: string): Promise<void>;
+  /** Remove an email subscription from the current user. */
+  removeEmail(email: string): Promise<void>;
+  /** Add a new SMS subscription to the current user. */
+  addSms(smsNumber: string): Promise<void>;
+  /** Remove an SMS subscription from the current user. */
+  removeSms(smsNumber: string): Promise<void>;
+  /** Add a single tag (key/value) on the current user, used for targeting and personalization. */
+  addTag(key: string, value: string): Promise<void>;
+  /** Add or overwrite multiple tags on the current user. */
+  addTags(tags: object): Promise<void>;
+  /** Remove a single tag by key from the current user. */
+  removeTag(key: string): Promise<void>;
+  /** Remove multiple tags by key from the current user. */
+  removeTags(keys: string[]): Promise<void>;
+  /** Get the local tags for the current user. */
+  getTags(): Promise<{
+    [key: string]: string;
+  }>;
+  /** Add a listener for OneSignal user state changes. */
+  addEventListener(event: 'change', listener: (event: UserChangedState) => void): void;
+  /** Remove a previously added user state listener. */
+  removeEventListener(event: 'change', listener: (event: UserChangedState) => void): void;
+  /** Get the OneSignal-assigned ID for the current user, or null if not yet available. */
+  getOnesignalId(): Promise<string | null>;
+  /** Get the external ID set via `login`, or null if the user is anonymous. */
+  getExternalId(): Promise<string | null>;
+  /** Track a custom event with an optional set of JSON-serializable properties. */
+  trackEvent(name: string, properties?: object): Promise<void>;
+}
+/**
+ * Notification permission and event handling exposed via `OneSignal.Notifications`.
+ */
+interface OneSignalNotificationsAPI {
+  /** Whether the app currently has notification permission (including provisional/ephemeral). */
+  hasPermission(): Promise<boolean>;
+  /** iOS only. The native notification permission status. */
+  permissionNative(): Promise<OSNotificationPermission>;
+  /** Prompt the user for notification permission. Optionally fall back to system settings. */
+  requestPermission(fallbackToSettings?: boolean): Promise<boolean>;
+  /** Whether requesting notification permission would still show a prompt. */
+  canRequestPermission(): Promise<boolean>;
+  /** iOS only. Request provisional authorization for quiet notifications without prompting. */
+  registerForProvisionalAuthorization(handler?: (response: boolean) => void): void;
+  /** Add a listener for `click`, `foregroundWillDisplay`, or `permissionChange` events. */
+  addEventListener<K extends NotificationEventName>(event: K, listener: (event: NotificationEventTypeMap[K]) => void): void;
+  /** Remove a previously added notification event listener. */
+  removeEventListener<K extends NotificationEventName>(event: K, listener: (obj: NotificationEventTypeMap[K]) => void): void;
+  /** Remove all OneSignal notifications from the notification center. */
+  clearAll(): Promise<void>;
+  /** Android only. Cancel a single notification by its Android notification ID. */
+  removeNotification(id: number): Promise<void>;
+  /** Android only. Cancel a group of notifications by group key. */
+  removeGroupedNotifications(id: string): Promise<void>;
+}
+/**
+ * In-app message triggers and event handling exposed via `OneSignal.InAppMessages`.
+ */
+interface OneSignalInAppMessagesAPI {
+  /** Add a listener for IAM `click`, `willDisplay`, `didDisplay`, `willDismiss`, or `didDismiss` events. */
+  addEventListener<K extends InAppMessageEventName>(event: K, listener: (event: InAppMessageEventTypeMap[K]) => void): void;
+  /** Remove a previously added IAM event listener. */
+  removeEventListener<K extends InAppMessageEventName>(event: K, listener: (obj: InAppMessageEventTypeMap[K]) => void): void;
+  /** Add a single trigger (key/value) used to determine which IAMs are displayed to the user. */
+  addTrigger(key: string, value: string): Promise<void>;
+  /** Add or overwrite multiple triggers for the current user. */
+  addTriggers(triggers: {
+    [key: string]: string;
+  }): Promise<void>;
+  /** Remove a single trigger by key. */
+  removeTrigger(key: string): Promise<void>;
+  /** Remove multiple triggers by key. */
+  removeTriggers(keys: string[]): Promise<void>;
+  /** Clear all triggers from the current user. */
+  clearTriggers(): Promise<void>;
+  /** Pause or resume the display of in-app messages. */
+  setPaused(pause: boolean): void;
+  /** Whether in-app messaging is currently paused. */
+  getPaused(): Promise<boolean>;
+}
+/**
+ * Outcome reporting exposed via `OneSignal.Session`.
+ */
+interface OneSignalSessionAPI {
+  /** Record an outcome with the given name against the current session. */
+  addOutcome(name: string): Promise<void>;
+  /** Record a unique outcome with the given name against the current session. */
+  addUniqueOutcome(name: string): Promise<void>;
+  /** Record an outcome with the given name and value against the current session. */
+  addOutcomeWithValue(name: string, value: number): Promise<void>;
+}
+/**
+ * Location permission and sharing exposed via `OneSignal.Location`.
+ */
+interface OneSignalLocationAPI {
+  /** Prompt the user for location permission to enable geotagging. */
+  requestPermission(): Promise<void>;
+  /** Enable or disable sharing the device location with OneSignal. */
+  setShared(shared: boolean): void;
+  /** Whether the device location is currently shared with OneSignal. */
+  isShared(): Promise<boolean>;
+}
+/**
+ * Live activity controls exposed via `OneSignal.LiveActivities`. iOS only unless noted.
+ */
+interface OneSignalLiveActivitiesAPI {
+  /** Associate a live activity ID with a push token so OneSignal can target it. */
+  enter(activityId: string, token: string, onSuccess?: (data: unknown) => void, onFailure?: (data: unknown) => void): void;
+  /**
+   * Disassociate a live activity ID.
+   * @deprecated Currently unsupported on the native side.
+   */
+  exit(activityId: string, onSuccess?: (data: unknown) => void, onFailure?: (data: unknown) => void): void;
+  /** Register a `pushToStart` token for the given live activity attributes type. */
+  setPushToStartToken(activityType: string, token: string): Promise<void>;
+  /** Remove a previously registered `pushToStart` token for the given attributes type. */
+  removePushToStartToken(activityType: string): Promise<void>;
+  /** Set up the OneSignal default live activity, optionally enabling pushToStart/pushToUpdate. */
+  setupDefault(options?: LiveActivitySetupOptions): Promise<void>;
+  /** Start a live activity backed by the OneSignal default attributes type. */
+  startDefault(activityId: string, attributes: Record<string, unknown>, content: Record<string, unknown>): Promise<void>;
+}
+/**
+ * The public OneSignal Capacitor plugin API. This is the shape of the default `OneSignal` export.
+ */
+interface OneSignalAPI {
+  /** Debug helpers. */
+  Debug: OneSignalDebugAPI;
+  /** Current-user operations (aliases, tags, email/SMS, push subscription). */
+  User: OneSignalUserAPI;
+  /** Notification permission and click/foreground event handling. */
+  Notifications: OneSignalNotificationsAPI;
+  /** In-app message triggers and lifecycle events. */
+  InAppMessages: OneSignalInAppMessagesAPI;
+  /** Outcome reporting against the current session. */
+  Session: OneSignalSessionAPI;
+  /** Location permission and sharing. */
+  Location: OneSignalLocationAPI;
+  /** iOS live activity controls. */
+  LiveActivities: OneSignalLiveActivitiesAPI;
+  /** Initialize the SDK with your OneSignal app ID. Call during app startup. */
+  initialize(appId: string): Promise<void>;
+  /** Log in to OneSignal as the user identified by `externalId`, switching the user context. */
+  login(externalId: string): Promise<void>;
+  /** Log out the current user. The SDK will reference a new device-scoped user. */
+  logout(): Promise<void>;
+  /** Set whether user privacy consent is required before sending data to OneSignal. Call before `initialize`. */
+  setConsentRequired(required: boolean): void;
+  /** Indicate whether the user has granted privacy consent. */
+  setConsentGiven(granted: boolean): void;
+}
+//#endregion
+//#region src/InAppMessagesNamespace.d.ts
+declare class InAppMessages implements OneSignalInAppMessagesAPI {
+  private _plugin;
+  private _inAppMessageClickListeners;
+  private _willDisplayInAppMessageListeners;
+  private _didDisplayInAppMessageListeners;
+  private _willDismissInAppMessageListeners;
+  private _didDismissInAppMessageListeners;
+  constructor(plugin: OneSignalCapacitorPlugin);
+  private _processFunctionList;
+  /**
+   * Add event listeners for In-App Message click and/or lifecycle events.
+   * @param event
+   * @param listener
+   * @returns
+   */
+  addEventListener<K extends InAppMessageEventName>(event: K, listener: (event: InAppMessageEventTypeMap[K]) => void): void;
+  /**
+   * Remove event listeners for In-App Message click and/or lifecycle events.
+   * @param event
+   * @param listener
+   * @returns
+   */
+  removeEventListener<K extends InAppMessageEventName>(event: K, listener: (obj: InAppMessageEventTypeMap[K]) => void): void;
+  /**
+   * Add a trigger for the current user. Triggers are currently explicitly used to determine whether a specific IAM should be displayed to the user.
+   * @param  {string} key
+   * @param  {string} value
+   * @returns Promise<void>
+   */
+  addTrigger(key: string, value: string): Promise<void>;
+  /**
+   * Add multiple triggers for the current user.
+   * @param  {[key: string]: string} triggers
+   * @returns Promise<void>
+   */
+  addTriggers(triggers: {
+    [key: string]: string;
+  }): Promise<void>;
+  /**
+   * Remove the trigger with the provided key from the current user.
+   * @param  {string} key
+   * @returns Promise<void>
+   */
+  removeTrigger(key: string): Promise<void>;
+  /**
+   * Remove multiple triggers from the current user.
+   * @param  {string[]} keys
+   * @returns Promise<void>
+   */
+  removeTriggers(keys: string[]): Promise<void>;
+  /**
+   * Clear all triggers from the current user.
+   * @returns Promise<void>
+   */
+  clearTriggers(): Promise<void>;
+  /**
+   * Set whether in-app messaging is currently paused.
+   * @param  {boolean} pause
+   * @returns void
+   */
+  setPaused(pause: boolean): void;
+  /**
+   * Whether in-app messaging is currently paused.
+   * @returns {Promise<boolean>}
+   */
+  getPaused(): Promise<boolean>;
+}
+//#endregion
+//#region src/LiveActivitiesNamespace.d.ts
+declare class LiveActivities implements OneSignalLiveActivitiesAPI {
+  private _plugin;
+  constructor(plugin: OneSignalCapacitorPlugin);
+  /**
+   * Enter a live activity
+   * @param  {string} activityId
+   * @param  {string} token
+   * @param  {Function} onSuccess
+   * @param  {Function} onFailure
+   * @returns void
+   */
+  enter(activityId: string, token: string, onSuccess?: (data: unknown) => void, onFailure?: (data: unknown) => void): void;
+  /**
+   * Exit a live activity
+   * @param  {string} activityId
+   * @param  {Function} onSuccess
+   * @param  {Function} onFailure
+   * @returns void
+   * @deprecated Currently unsupported, avoid using this method.
+   */
+  exit(activityId: string, onSuccess?: (data: unknown) => void, onFailure?: (data: unknown) => void): void;
+  /**
+   * Indicate this device is capable of receiving pushToStart live activities for the
+   * `activityType`. Only applies to iOS.
+   * @param {string} activityType
+   * @param {string} token
+   */
+  setPushToStartToken(activityType: string, token: string): Promise<void>;
+  /**
+   * Indicate this device is no longer capable of receiving pushToStart live activities
+   * for the `activityType`. Only applies to iOS.
+   * @param {string} activityType
+   */
+  removePushToStartToken(activityType: string): Promise<void>;
+  /**
+   * Enable the OneSignalSDK to setup the default `DefaultLiveActivityAttributes` structure.
+   * Only applies to iOS.
+   * @param {LiveActivitySetupOptions} options
+   */
+  setupDefault(options?: LiveActivitySetupOptions): Promise<void>;
+  /**
+   * Start a new LiveActivity that is modelled by the default `DefaultLiveActivityAttributes`
+   * structure. Only applies to iOS.
+   * @param {string} activityId
+   * @param {object} attributes
+   * @param {object} content
+   */
+  startDefault(activityId: string, attributes: Record<string, unknown>, content: Record<string, unknown>): Promise<void>;
+}
+//#endregion
+//#region src/LocationNamespace.d.ts
+declare class Location implements OneSignalLocationAPI {
+  private _plugin;
+  constructor(plugin: OneSignalCapacitorPlugin);
+  /**
+   * Prompts the user for location permissions to allow geotagging from the OneSignal dashboard.
+   * @returns Promise<void>
+   */
+  requestPermission(): Promise<void>;
+  /**
+   * Disable or enable location collection (defaults to enabled if your app has location permission).
+   * @param  {boolean} shared
+   * @returns void
+   */
+  setShared(shared: boolean): void;
+  /**
+   * Whether location is currently shared with OneSignal.
+   * @returns {Promise<boolean>}
+   */
+  isShared(): Promise<boolean>;
+}
+//#endregion
+//#region src/SessionNamespace.d.ts
+declare class Session implements OneSignalSessionAPI {
+  private _plugin;
+  constructor(plugin: OneSignalCapacitorPlugin);
+  /**
+   * Add an outcome with the provided name, captured against the current session.
+   * @param  {string} name
+   * @returns Promise<void>
+   */
+  addOutcome(name: string): Promise<void>;
+  /**
+   * Add a unique outcome with the provided name, captured against the current session.
+   * @param  {string} name
+   * @returns Promise<void>
+   */
+  addUniqueOutcome(name: string): Promise<void>;
+  /**
+   * Add an outcome with the provided name and value, captured against the current session.
+   * @param  {string} name
+   * @param  {number} value
+   * @returns Promise<void>
+   */
+  addOutcomeWithValue(name: string, value: number): Promise<void>;
+}
+//#endregion
+//#region src/OneSignalPlugin.d.ts
+declare class OneSignalPlugin implements OneSignalAPI {
+  User: User;
+  Debug: Debug;
+  Session: Session;
+  Location: Location;
+  InAppMessages: InAppMessages;
+  Notifications: Notifications;
+  LiveActivities: LiveActivities;
+  private _plugin;
+  private _appID;
+  constructor(plugin: OneSignalCapacitorPlugin);
+  /**
+   * Initializes the OneSignal SDK. This should be called during startup of the application.
+   * @param  {string} appId
+   * @returns Promise<void>
+   */
+  initialize(appId: string): Promise<void>;
+  /**
+   * Login to OneSignal under the user identified by the [externalId] provided. The act of logging a user into the OneSignal SDK will switch the [user] context to that specific user.
+   * @param  {string} externalId
+   * @returns Promise<void>
+   */
+  login(externalId: string): Promise<void>;
+  /**
+   * Logout the user previously logged in via [login]. The [user] property now references a new device-scoped user.
+   * @returns Promise<void>
+   */
+  logout(): Promise<void>;
+  /**
+   * Determines whether a user must consent to privacy prior to their user data being sent up to OneSignal. This should be set to true prior to the invocation of initialization to ensure compliance.
+   * @param  {boolean} required
+   * @returns void
+   */
+  setConsentRequired(required: boolean): void;
+  /**
+   * Indicates whether privacy consent has been granted. This field is only relevant when the application has opted into data privacy protections.
+   * @param  {boolean} granted
+   * @returns void
+   */
+  setConsentGiven(granted: boolean): void;
+}
+//#endregion
+//#region src/index.d.ts
+declare const OneSignal: OneSignalPlugin;
+//#endregion
+export { type InAppMessageActionUrlType, type InAppMessageClickEvent, type InAppMessageClickResult, type InAppMessageDidDismissEvent, type InAppMessageDidDisplayEvent, type InAppMessageWillDismissEvent, type InAppMessageWillDisplayEvent, LogLevel, type NotificationClickEvent, type NotificationClickResult, NotificationWillDisplayEvent, type OSInAppMessage, OSNotification, OSNotificationPermission, type OneSignalCapacitorPlugin, OneSignalPlugin, type PushSubscriptionChangedState, type PushSubscriptionState, type UserChangedState, type UserState, OneSignal as default };