@awesome-cordova-plugins/urbanairship 6.2.0 → 6.4.0

package/index.d.ts

@@ -798,6 +798,35 @@ export declare class UrbanAirShipOriginal extends AwesomeCordovaNativePlugin {
      * @since 13.0.0
      */
     openPreferenceCenter(prenferenceCenterId: string): Promise<any>;
+    /**
+     * Overrides the locale setting.
+     *
+     * @param {string} locale language and optional country code.
+     * @param {function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 14.3.0
+     */
+    setCurrentLocale(locale: string): Promise<any>;
+    /**
+     * Returns the currently set locale.
+     *
+     * @param {function(locale)} [success] Success callback.
+     * @param {string} success.locale The locale as a string.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 14.3.0
+     */
+    getCurrentLocale(): Promise<string>;
+    /**
+     * Resets the current locale.
+     *
+     * @param {function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 14.3.0
+     */
+    clearLocale(): Promise<any>;
 }
 
 export declare const UrbanAirShip: UrbanAirShipOriginal;

package/index.js

@@ -133,6 +133,9 @@ var UrbanAirShipOriginal = /** @class */ (function (_super) {
     UrbanAirShipOriginal.prototype.isFeatureEnabled = function (features) { return cordova(this, "isFeatureEnabled", { "successIndex": 1, "errorIndex": 2 }, arguments); };
     UrbanAirShipOriginal.prototype.getPreferenceCenterConfig = function (preferenceCenterId) { return cordova(this, "getPreferenceCenterConfig", { "successIndex": 1, "errorIndex": 2 }, arguments); };
     UrbanAirShipOriginal.prototype.openPreferenceCenter = function (prenferenceCenterId) { return cordova(this, "openPreferenceCenter", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    UrbanAirShipOriginal.prototype.setCurrentLocale = function (locale) { return cordova(this, "setCurrentLocale", {}, arguments); };
+    UrbanAirShipOriginal.prototype.getCurrentLocale = function () { return cordova(this, "getCurrentLocale", {}, arguments); };
+    UrbanAirShipOriginal.prototype.clearLocale = function () { return cordova(this, "clearLocale", {}, arguments); };
     UrbanAirShipOriginal.pluginName = "UrbanAirShip";
     UrbanAirShipOriginal.plugin = "urbanairship-cordova";
     UrbanAirShipOriginal.pluginRef = "window.UAirship";
@@ -143,4 +146,4 @@ var UrbanAirShipOriginal = /** @class */ (function (_super) {
 }(AwesomeCordovaNativePlugin));
 var UrbanAirShip = new UrbanAirShipOriginal();
 export { UrbanAirShip };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/@awesome-cordova-plugins/plugins/urbanairship/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,OAAO,uCAA+C,MAAM,+BAA+B,CAAC;AAC5F,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAwClC;;;;;GAKG;AACH,MAAM,CAAN,IAAY,gBAKX;AALD,WAAY,gBAAgB;IAC1B,uDAAQ,CAAA;IACR,yDAAS,CAAA;IACT,yDAAS,CAAA;IACT,yDAAS,CAAA;AACX,CAAC,EALW,gBAAgB,KAAhB,gBAAgB,QAK3B;AAED;;;;;GAKG;AACH,MAAM,CAAN,IAAY,mBAKX;AALD,WAAY,mBAAmB;IAC7B,6DAAQ,CAAA;IACR,+DAAS,CAAA;IACT,+DAAS,CAAA;IACT,+DAAS,CAAA;AACX,CAAC,EALW,mBAAmB,KAAnB,mBAAmB,QAK9B;;IA+BiC,gCAA0B;;;;IAa1D,iCAAU;IAkBV,qCAAc;IAcd,qCAAc;IAiBd,kCAAW;IAsBX,qCAAc;IAqBd,2CAAoB;IAuBpB,gDAAyB;IAUzB,+BAAQ;IAsBR,8BAAO,aAAC,MAAW;IAanB,mDAA4B,aAAC,MAAW;IAcxC,wDAAiC,aAAC,OAAgB;IAalD,kDAA2B,aAAC,OAAgB;IAa5C,iDAA0B;IAc1B,gDAAyB;IAazB,mCAAY;IAiBZ,4CAAqB,aAAC,KAAc;IAcpC,kCAAW,aAAC,KAAc;IAa1B,8BAAO;IAaP,8BAAO,aAAC,IAAc;IActB,+BAAQ;IAcR,+BAAQ,aAAC,KAAa;IAatB,yCAAkB;IAalB,0CAAmB,aAAC,OAAgB;IAapC,oCAAa;IAkBb,mCAAY;IAgBZ,mCAAY,aAAC,SAAiB,EAAE,WAAmB,EAAE,OAAe,EAAE,SAAiB;IAkBvF,0CAAmB,aAAC,OAAgB;IAapC,yCAAkB;IAalB,mCAAY;IAaZ,mCAAY,aAAC,SAAiB;IAe9B,gCAAS,aAAC,UAAkB,EAAE,WAAgB;IAQ9C,6CAAsB;IAQtB,2CAAoB;IAQpB,4CAAqB;IAQrB,8CAAuB;IAWvB,mDAA4B;IAW5B,mDAA4B;IAgB5B,kDAA2B;IAgB3B,kDAA2B;IAc3B,8CAAuB,aAAC,GAAW,EAAE,UAAkB;IAevD,yCAAkB,aAAC,OAAgB;IAcnC,wCAAiB;IAcjB,mDAA4B,aAAC,OAAgB;IAc7C,kDAA2B;IAY3B,2CAAoB;IAYpB,2CAAoB;IAYpB,0CAAmB;IAanB,iDAA0B;IAmB1B,uCAAgB;IAahB,2CAAoB,aAAC,SAAiB;IAatC,yCAAkB,aAAC,SAAiB;IAapC,0CAAmB,aAAC,SAAiB;IAerC,mCAAY;IAcZ,0CAAmB,aAAC,SAAiB;IAYrC,wCAAiB,aAAC,UAAkB;IAYpC,yCAAkB;IAalB,6CAAsB;IAetB,0CAAmB,aAAC,OAAgB;IAapC,qCAAc,aAAC,KAAa;IAa5B,qCAAc;IAYd,iCAAU;IAcV,2CAAoB,aAAC,KAAuB;IAc5C,6CAAsB,aAAC,OAA4B;IAenD,qCAAc;IAad,sCAAe,aAAC,OAAgB;IAahC,uCAAgB;IAahB,wCAAiB,aAAC,OAAgB;IAiBlC,qCAAc,aAAC,KAAa;IAiB5B,kCAAW,aAAC,MAAc;IAiB1B,oCAAa,aAAC,QAAkB;IAiBhC,qCAAc,aAAC,QAAkB;IAIjC;;;;;;;;OAQG;IACH,yCAAkB,GAAlB,UAAmB,QAAkB;QACnC,OAAO;IACT,CAAC;IAcD,yCAAkB;IAiBlB,uCAAgB,aAAC,QAAkB;IAiBnC,gDAAyB,aAAC,kBAA0B;IAiBpD,2CAAoB,aAAC,mBAA2B;;;;;;;uBA5pClD;EAiGkC,0BAA0B;SAA/C,YAAY","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Plugin, Cordova, AwesomeCordovaNativePlugin } from '@awesome-cordova-plugins/core';\nimport { Observable } from 'rxjs';\n\n/**\n * Interface for UAirship Tag Editor\n */\nexport interface TagGroupEditor {\n  addTags(tagGroup: string, tags: string[]): TagGroupEditor;\n  removeTags(tagGroup: string, tags: string[]): TagGroupEditor;\n  apply(success: () => void, failure: (message: string) => void): TagGroupEditor;\n}\n\n/**\n * Interface for UAirship Attributes Editor\n */\nexport interface AttributesEditor {\n  setAttribute(name: string, value: string | number | boolean | Date): AttributesEditor;\n  removeAttribute(name: string): AttributesEditor;\n  apply(success: () => void, failure: (message: string) => void): AttributesEditor;\n}\n\n/**\n * Interface for UAirship ChannelSubscriptionList Editor\n */\nexport interface ChannelSubscriptionListEditor {\n  subscribe(subscriptionListID: string): ChannelSubscriptionListEditor;\n  unsubscribe(subscriptionListID: string): ChannelSubscriptionListEditor;\n  apply(success: () => void, failure: (message: string) => void): ChannelSubscriptionListEditor;\n}\n\nexport type ContactSubscriptionScope = 'app' | 'email' | 'push' | 'sms';\n\n/**\n * Interface for UAirship ContactSubscriptionList Editor\n */\nexport interface ContactSubscriptionListEditor {\n  subscribe(subscriptionListID: string, contactScope: ContactSubscriptionScope): ContactSubscriptionListEditor;\n  unsubscribe(subscriptionListID: string, contactScope: ContactSubscriptionScope): ContactSubscriptionListEditor;\n  apply(success: () => void, failure: (message: string) => void): ContactSubscriptionListEditor;\n}\n\n/**\n * Enum for notification types.\n *\n * @readonly\n * @enum {number}\n */\nexport enum NotificationType {\n  none = 0,\n  badge = 1,\n  sound = 2,\n  alert = 4,\n}\n\n/**\n * Enum for presentation options.\n *\n * @readonly\n * @enum {number}\n */\nexport enum PresentationOptions {\n  none = 0,\n  badge = 1,\n  sound = 2,\n  alert = 4,\n}\n\n/**\n * @name UrbanAirShip\n * @description\n * This plugin does something\n * @usage\n * ```typescript\n * import { UrbanAirShip } from '@awesome-cordova-plugins/urbanairship/ngx';\n *\n *\n * constructor(private urbanAirShip: UrbanAirShip) { }\n *\n * ...\n *\n *\n * this.urbanAirShip.takeOff(config)\n *   .then((res: any) => console.log(res))\n *   .catch((error: any) => console.error(error));\n *\n * ```\n */\n@Plugin({\n  pluginName: 'UrbanAirShip',\n  plugin: 'urbanairship-cordova',\n  pluginRef: 'window.UAirship',\n  repo: 'https://www.npmjs.com/package/urbanairship-cordova',\n  install: 'ionic cordova plugin add urbanairship-cordova',\n  platforms: ['Android', 'iOS'],\n})\n@Injectable()\nexport class UrbanAirShip extends AwesomeCordovaNativePlugin {\n  /**\n   * Event fired when a new deep link is received.\n   *\n   * @event deep_link\n   * @type {object}\n   * @param {string} [deepLink] The deep link.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.deep_link',\n    element: 'document',\n  })\n  onDeepLink(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when a channel registration occurs.\n   *\n   * @event registration\n   * @type {object}\n   * @param {string} [channelID] The channel ID.\n   * @param {string} [registrationToken] The deviceToken on iOS, and the FCM/ADM token on Android.\n   * @param {string} [error] Error message if an error occurred.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.registration',\n    element: 'document',\n  })\n  onRegistration(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when the inbox is updated.\n   *\n   * @event inbox_updated\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.inbox_updated',\n    element: 'document',\n  })\n  onInboxUpdated(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when the inbox needs to be displayed. This event is only emitted if auto\n   * launch message center is disabled.\n   *\n   * @event show_inbox\n   * @type {object}\n   * @param {string} [messageId] The optional message ID.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.show_inbox',\n    element: 'document',\n  })\n  onShowInbox(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when a push is received.\n   *\n   * @event push\n   * @type {object}\n   * @param {string} message The push alert message.\n   * @param {string} title The push title.\n   * @param {string} subtitle The push subtitle.\n   * @param {object} extras Any push extras.\n   * @param {object} aps The raw aps dictionary (iOS only)\n   * @param {number} [notification_id] The Android notification ID. Deprecated in favor of notificationId.\n   * @param {string} [notificationId] The notification ID.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.push',\n    element: 'document',\n  })\n  onPushReceived(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when notification opened.\n   *\n   * @event notification_opened\n   * @type {object}\n   * @param {string} message The push alert message.\n   * @param {object} extras Any push extras.\n   * @param {number} [notification_id] The Android notification ID. Deprecated in favor of notificationId.\n   * @param {string} [notificationId] The notification ID.\n   * @param {string} [actionID] The ID of the notification action button if available.\n   * @param {boolean} isForeground Will always be true if the user taps the main notification. Otherwise its defined by the notification action button.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.notification_opened',\n    element: 'document',\n  })\n  onNotificationOpened(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when the user notification opt-in status changes.\n   *\n   * @event notification_opt_in_status\n   * @type {object}\n   * @param {boolean} optIn If the user is opted in or not to user notifications.\n   * @param {object} [authorizedNotificationSettings] iOS only. A map of authorized settings.\n   * @param {boolean} authorizedNotificationSettings.alert If alerts are authorized.\n   * @param {boolean} authorizedNotificationSettings.sound If sounds are authorized.\n   * @param {boolean} authorizedNotificationSettings.badge If badges are authorized.\n   * @param {boolean} authorizedNotificationSettings.carPlay If car play is authorized.\n   * @param {boolean} authorizedNotificationSettings.lockScreen If the lock screen is authorized.\n   * @param {boolean} authorizedNotificationSettings.notificationCenter If the notification center is authorized.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.notification_opt_in_status',\n    element: 'document',\n  })\n  onNotificationOptInStatus(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Re-attaches document event listeners in this webview\n   */\n  @Cordova({\n    sync: true,\n  })\n  reattach(): void {\n    return;\n  }\n\n  /**\n   * Initailizes Urban Airship.\n   *\n   * The plugin will automatically call takeOff during the next app init in\n   * order to properly handle incoming push. If takeOff is called multiple times\n   * in a session, or if the config is different than the previous sesssion, the\n   * new config will not be used until the next app start.\n   *\n   * @param {object}  config The Urban Airship config.\n   * @param {string}  config.site Sets the cloud site, must be either EU or US.\n   * @param {object}  config.development The Urban Airship development config.\n   * @param {string}  config.development.appKey The development appKey.\n   * @param {string}  config.development.appSecret The development appSecret.\n   * @param {object}  config.production The Urban Airship production config.\n   * @param {string}  config.production.appKey The production appKey.\n   * @param {string}  config.production.appSecret The production appSecret.\n   */\n  @Cordova()\n  takeOff(config: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the Android notification config. Values not set will fallback to any values set in the config.xml.\n   *\n   * @param {object}  config The notification config.\n   * @param {string}  [config.icon] The name of the drawable resource to use as the notification icon.\n   * @param {string}  [config.largeIcon] The name of the drawable resource to use as the notification large icon.\n   * @param {string}  [config.accentColor] The notification accent color. Format is #AARRGGBB.\n   */\n  @Cordova()\n  setAndroidNotificationConfig(config: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the default behavior when the message center is launched from a push\n   * notification. If set to false the message center must be manually launched.\n   *\n   * @param {boolean} enabled true to automatically launch the default message center, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAutoLaunchDefaultMessageCenter(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables user notifications.\n   *\n   * @param {boolean} enabled true to enable notifications, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setUserNotificationsEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if user notifications are enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if user notifications is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isUserNotificationsEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if app notifications are enabled or not. Its possible to have `userNotificationsEnabled`\n   * but app notifications being disabled if the user opted out of notifications.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if app notifications is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isAppNotificationsEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the channel ID.\n   *\n   * @param {function(ID)} success The function to call on success.\n   * @param {string} success.ID The channel ID string\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getChannelID(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the last notification that launched the application.\n   *\n   * @param {boolean} clear true to clear the notification.\n   * @param {function(push)} success The function to call on success.\n   * @param {object} success.push The push message object containing data associated with a push notification.\n   * @param {string} success.push.message The push alert message.\n   * @param {object} success.push.extras Any push extras.\n   * @param {number} [success.push.notification_id] The Android notification ID.\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getLaunchNotification(clear: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the last received deep link.\n   *\n   * @param {boolean} clear true to clear the deep link.\n   * @param {function(push)} success The function to call on success.\n   * @param {string} success.deepLink The deep link.\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getDeepLink(clear: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the tags as an array.\n   *\n   * @param {function(tags)} success The function to call on success.\n   * @param {Array} success.tags The tags as an array.\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getTags(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the tags.\n   *\n   * @param {Array} tags an array of strings.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setTags(tags: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the alias.\n   *\n   * @deprecated Deprecated since 6.7.0 - to be removed in a future version of the plugin - please use getNamedUser\n   * @param {function(currentAlias)} success The function to call on success.\n   * @param {string} success.currentAlias The alias as a string.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getAlias(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the alias.\n   *\n   * @deprecated Deprecated since 6.7.0  - to be removed in a future version of the plugin - please use setNamedUser\n   * @param {string} alias string\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAlias(alias: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if quiet time is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if quiet time is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isQuietTimeEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables quiet time.\n   *\n   * @param {boolean} enabled true to enable quiet time, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setQuietTimeEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if the device is currently in quiet time.\n   *\n   * @param {function(inQuietTime)} success Success callback.\n   * @param {boolean} success.inQuietTime Flag indicating if quiet time is currently in effect.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isInQuietTime(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the quiet time as an object with the following:\n   * \"startHour\": Number,\n   * \"startMinute\": Number,\n   * \"endHour\": Number,\n   * \"endMinute\": Number\n   *\n   * @param {function(quietTime)} success The function to call on success.\n   * @param {object} success.quietTime The quietTime object represents a timespan during\n   *        which notifications should be silenced.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getQuietTime(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the quiet time.\n   *\n   * @param {number} startHour for quiet time.\n   * @param {number} startMinute for quiet time.\n   * @param {number} endHour for quiet time.\n   * @param {number} endMinute for quiet time.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setQuietTime(startHour: number, startMinute: number, endHour: number, endMinute: number): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables analytics.\n   *\n   * Disabling analytics will delete any locally stored events\n   * and prevent any events from uploading. Features that depend on analytics being\n   * enabled may not work properly if it's disabled (reports, region triggers,\n   * location segmentation, push to local time).\n   *\n   * @param {boolean} enabled true to enable analytics, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAnalyticsEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if analytics is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if analytics is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isAnalyticsEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the named user ID.\n   *\n   * @param {function(namedUser)} success The function to call on success.\n   * @param {string} success.namedUser The named user ID as a string.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getNamedUser(): Promise<string> {\n    return;\n  }\n\n  /**\n   * Sets the named user ID.\n   *\n   * @param {string} namedUser identifier string.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setNamedUser(namedUser: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Runs an Urban Airship action.\n   *\n   * @param {string} actionName action as a string.\n   * @param {*} actionValue\n   * @param {function(result)} [success] The function to call on success.\n   * @param {object} success.result The result's value.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  runAction(actionName: string, actionValue: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the named user tag groups.\n   */\n  @Cordova({ sync: true })\n  editNamedUserTagGroups(): TagGroupEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel tag groups.\n   */\n  @Cordova({ sync: true })\n  editChannelTagGroups(): TagGroupEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel attributes.\n   */\n  @Cordova({ sync: true })\n  editChannelAttributes(): AttributesEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the named user attributes.\n   */\n  @Cordova({ sync: true })\n  editNamedUserAttributes(): AttributesEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel subscription lists.\n   *\n   * @returns {ChannelSubscriptionListEditor} A subscription list editor instance.\n   * @since 13.3.0\n   */\n  @Cordova({ sync: true })\n  editChannelSubscriptionLists(): ChannelSubscriptionListEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the contact subscription lists.\n   *\n   * @returns {ContactSubscriptionListEditor} A subscription list editor instance.\n   * @since 13.3.0\n   */\n  @Cordova({ sync: true })\n  editContactSubscriptionLists(): ContactSubscriptionListEditor {\n    return;\n  }\n\n  /**\n   * Returns the current set of subscription lists for the current channel,\n   * optionally applying pending subscription list changes that will be applied during the next channel update.\n   * An empty set indicates that this contact is not subscribed to any lists.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova({\n    successIndex: 0,\n    errorIndex: 1,\n  })\n  getChannelSubscriptionLists(): Promise<string[]> {\n    return;\n  }\n\n  /**\n   * Returns the current set of subscription lists for the current contact,\n   * optionally applying pending subscription list changes that will be applied during the next contact update.\n   * An empty set indicates that this contact is not subscribed to any lists.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova({\n    successIndex: 0,\n    errorIndex: 1,\n  })\n  getContactSubscriptionLists(): Promise<string[]> {\n    return;\n  }\n\n  /**\n   * Sets an associated identifier for the Connect data stream.\n   *\n   * @param key Custom key for identifier.\n   * @param identifier The identifier value.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAssociatedIdentifier(key: string, identifier: string): Promise<void> {\n    return;\n  }\n\n  // Location\n\n  /**\n   * Enables or disables Urban Airship location services.\n   *\n   * @param {boolean} enabled true to enable location, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setLocationEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if location is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if location is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 8.0\n   */\n  @Cordova()\n  isLocationEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables background location.\n   *\n   * @param {boolean} enabled true to enable background location, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 8.0\n   */\n  @Cordova()\n  setBackgroundLocationEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if background location is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if background location updates are enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 8.0\n   */\n  @Cordova()\n  isBackgroundLocationEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Displays the message center.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  displayMessageCenter(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Dismiss the message center.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  dismissMessageCenter(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Dismiss the inbox message.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  dismissInboxMessage(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Dismiss the inbox message in the overlay.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 10.0\n   */\n  @Cordova()\n  dismissOverlayInboxMessage(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Gets the array of inbox messages. Each message will have the following properties:\n   * \"id\": string - The messages ID. Needed to display, mark as read, or delete the message.\n   * \"title\": string - The message title.\n   * \"sentDate\": number - The message sent date in milliseconds.\n   * \"listIconUrl\": string, optional - The icon url for the message.\n   * \"isRead\": boolean - The unread/read status of the message.\n   * \"extras\": object - String to String map of any message extras.\n   *\n   * @param {function(messages)} success The function to call on success.\n   * @param {Array} success.messages The array of inbox messages.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getInboxMessages(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Marks an inbox message read.\n   *\n   * @param {string} messageId The ID of the message to mark as read.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  markInboxMessageRead(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Deletes an inbox message.\n   *\n   * @param {string} messageId The ID of the message to delete.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  deleteInboxMessage(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Displays the inbox message using a full screen view.\n   *\n   * @param {string} messageId The ID of the message to display.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  displayInboxMessage(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Forces the inbox to refresh. This is normally not needed as the inbox\n   * will automatically refresh on foreground or when a push arrives thats\n   * associated with a message, but it can be useful when providing a refresh\n   * button for the message listing.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  refreshInbox(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Displays the inbox message using an overlay display.\n   *\n   * @param {string} messageId The ID of the message to display.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 10.0\n   */\n  @Cordova()\n  overlayInboxMessage(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Clears a notification by identifier.\n   *\n   * @param {string} identifier The notification identifier.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   */\n  @Cordova()\n  clearNotification(identifier: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Clears all notifications posted by the application.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  clearNotifications(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Gets currently active notifications.\n   *\n   * Note: On Android this functionality is only supported on Android M or higher.\n   *\n   * @param {function(messages)} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   */\n  @Cordova()\n  getActiveNotifications(): Promise<any> {\n    return;\n  }\n\n  // iOS only\n\n  /**\n   * Enables or disables auto badge. Defaults to `NO`.\n   *\n   * @param {boolean} enabled true to enable auto badge, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAutobadgeEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the badge number.\n   *\n   * @param count number specified badge to set.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setBadgeNumber(count: number): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the current badge number.\n   *\n   * @param {function(badgeNumber)} success The function to call on success.\n   * @param {int} success.badgeNumber The current application badge number.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getBadgeNumber(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Clears the badge.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  resetBadge(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the iOS notification types. Specify the combination of\n   * badges, sound and alerts that are desired.\n   *\n   * @param types specified notification types.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setNotificationTypes(types: NotificationType): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the iOS presentation options. Specify the combination of\n   * badges, sound and alerts that are desired.\n   *\n   * @param options types specified presentation options.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setPresentationOptions(options: PresentationOptions): Promise<any> {\n    return;\n  }\n\n  // Android only\n\n  /**\n   * Checks if notification sound is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if sound is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isSoundEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables notification sound.\n   *\n   * @param {boolean} enabled true to enable sound, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setSoundEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if notification vibration is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if vibration is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isVibrateEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables notification vibration.\n   *\n   * @param {boolean} enabled true to enable vibration, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setVibrateEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Adds a custom event.\n   *\n   * @param {object} event The custom event object.\n   * @param {string} event.name The event's name.\n   * @param {number} [event.value] The event's value.\n   * @param {string} [event.transactionId] The event's transaction ID.\n   * @param {object} [event.properties] The event's properties. Only numbers, booleans, strings, and array of strings are supported.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  addCustomEvent(event: object): Promise<any> {\n    return;\n  }\n\n  /**\n   * Initiates screen tracking for a specific app screen, must be called once per tracked screen.\n   *\n   * @param {string} screen The screen's string identifier.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 11.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  trackScreen(screen: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables features, adding them to the set of currently enabled features.\n   *\n   * @param {Array<string>} features The features to enable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  enableFeature(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Disables features, removing them from the set of currently enabled features.\n   *\n   * @param {Array<string>} features The features to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  disableFeature(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the current enabled features, replacing any currently enabled features with the given set.\n   *\n   * @param {Array<string>} features The features to set as enabled.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  setEnabledFeatures(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Gets the current enabled features.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 0,\n    errorIndex: 1,\n  })\n  getEnabledFeatures(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if all of the given features are enabled.\n   *\n   * @param {Array<string>} features The features to check.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  isFeatureEnabled(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the configuration of the Preference Center with the given ID trough a callback method.\n   *\n   * @param {string} preferenceCenterId The preference center ID.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.3.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  getPreferenceCenterConfig(preferenceCenterId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Opens the Preference Center with the given preferenceCenterId.\n   *\n   * @param {string} prenferenceCenterId The preference center ID.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  openPreferenceCenter(prenferenceCenterId: string): Promise<any> {\n    return;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/@awesome-cordova-plugins/plugins/urbanairship/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,OAAO,uCAA+C,MAAM,+BAA+B,CAAC;AAC5F,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAwClC;;;;;GAKG;AACH,MAAM,CAAN,IAAY,gBAKX;AALD,WAAY,gBAAgB;IAC1B,uDAAQ,CAAA;IACR,yDAAS,CAAA;IACT,yDAAS,CAAA;IACT,yDAAS,CAAA;AACX,CAAC,EALW,gBAAgB,KAAhB,gBAAgB,QAK3B;AAED;;;;;GAKG;AACH,MAAM,CAAN,IAAY,mBAKX;AALD,WAAY,mBAAmB;IAC7B,6DAAQ,CAAA;IACR,+DAAS,CAAA;IACT,+DAAS,CAAA;IACT,+DAAS,CAAA;AACX,CAAC,EALW,mBAAmB,KAAnB,mBAAmB,QAK9B;;IA+BiC,gCAA0B;;;;IAa1D,iCAAU;IAkBV,qCAAc;IAcd,qCAAc;IAiBd,kCAAW;IAsBX,qCAAc;IAqBd,2CAAoB;IAuBpB,gDAAyB;IAUzB,+BAAQ;IAsBR,8BAAO,aAAC,MAAW;IAanB,mDAA4B,aAAC,MAAW;IAcxC,wDAAiC,aAAC,OAAgB;IAalD,kDAA2B,aAAC,OAAgB;IAa5C,iDAA0B;IAc1B,gDAAyB;IAazB,mCAAY;IAiBZ,4CAAqB,aAAC,KAAc;IAcpC,kCAAW,aAAC,KAAc;IAa1B,8BAAO;IAaP,8BAAO,aAAC,IAAc;IActB,+BAAQ;IAcR,+BAAQ,aAAC,KAAa;IAatB,yCAAkB;IAalB,0CAAmB,aAAC,OAAgB;IAapC,oCAAa;IAkBb,mCAAY;IAgBZ,mCAAY,aAAC,SAAiB,EAAE,WAAmB,EAAE,OAAe,EAAE,SAAiB;IAkBvF,0CAAmB,aAAC,OAAgB;IAapC,yCAAkB;IAalB,mCAAY;IAaZ,mCAAY,aAAC,SAAiB;IAe9B,gCAAS,aAAC,UAAkB,EAAE,WAAgB;IAQ9C,6CAAsB;IAQtB,2CAAoB;IAQpB,4CAAqB;IAQrB,8CAAuB;IAWvB,mDAA4B;IAW5B,mDAA4B;IAgB5B,kDAA2B;IAgB3B,kDAA2B;IAc3B,8CAAuB,aAAC,GAAW,EAAE,UAAkB;IAevD,yCAAkB,aAAC,OAAgB;IAcnC,wCAAiB;IAcjB,mDAA4B,aAAC,OAAgB;IAc7C,kDAA2B;IAY3B,2CAAoB;IAYpB,2CAAoB;IAYpB,0CAAmB;IAanB,iDAA0B;IAmB1B,uCAAgB;IAahB,2CAAoB,aAAC,SAAiB;IAatC,yCAAkB,aAAC,SAAiB;IAapC,0CAAmB,aAAC,SAAiB;IAerC,mCAAY;IAcZ,0CAAmB,aAAC,SAAiB;IAYrC,wCAAiB,aAAC,UAAkB;IAYpC,yCAAkB;IAalB,6CAAsB;IAetB,0CAAmB,aAAC,OAAgB;IAapC,qCAAc,aAAC,KAAa;IAa5B,qCAAc;IAYd,iCAAU;IAcV,2CAAoB,aAAC,KAAuB;IAc5C,6CAAsB,aAAC,OAA4B;IAenD,qCAAc;IAad,sCAAe,aAAC,OAAgB;IAahC,uCAAgB;IAahB,wCAAiB,aAAC,OAAgB;IAiBlC,qCAAc,aAAC,KAAa;IAiB5B,kCAAW,aAAC,MAAc;IAiB1B,oCAAa,aAAC,QAAkB;IAiBhC,qCAAc,aAAC,QAAkB;IAIjC;;;;;;;;OAQG;IACH,yCAAkB,GAAlB,UAAmB,QAAkB;QACnC,OAAO;IACT,CAAC;IAcD,yCAAkB;IAiBlB,uCAAgB,aAAC,QAAkB;IAiBnC,gDAAyB,aAAC,kBAA0B;IAiBpD,2CAAoB,aAAC,mBAA2B;IAchD,uCAAgB,aAAC,MAAc;IAc/B,uCAAgB;IAahB,kCAAW;;;;;;;uBArsCb;EAiGkC,0BAA0B;SAA/C,YAAY","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Plugin, Cordova, AwesomeCordovaNativePlugin } from '@awesome-cordova-plugins/core';\nimport { Observable } from 'rxjs';\n\n/**\n * Interface for UAirship Tag Editor\n */\nexport interface TagGroupEditor {\n  addTags(tagGroup: string, tags: string[]): TagGroupEditor;\n  removeTags(tagGroup: string, tags: string[]): TagGroupEditor;\n  apply(success: () => void, failure: (message: string) => void): TagGroupEditor;\n}\n\n/**\n * Interface for UAirship Attributes Editor\n */\nexport interface AttributesEditor {\n  setAttribute(name: string, value: string | number | boolean | Date): AttributesEditor;\n  removeAttribute(name: string): AttributesEditor;\n  apply(success: () => void, failure: (message: string) => void): AttributesEditor;\n}\n\n/**\n * Interface for UAirship ChannelSubscriptionList Editor\n */\nexport interface ChannelSubscriptionListEditor {\n  subscribe(subscriptionListID: string): ChannelSubscriptionListEditor;\n  unsubscribe(subscriptionListID: string): ChannelSubscriptionListEditor;\n  apply(success: () => void, failure: (message: string) => void): ChannelSubscriptionListEditor;\n}\n\nexport type ContactSubscriptionScope = 'app' | 'email' | 'push' | 'sms';\n\n/**\n * Interface for UAirship ContactSubscriptionList Editor\n */\nexport interface ContactSubscriptionListEditor {\n  subscribe(subscriptionListID: string, contactScope: ContactSubscriptionScope): ContactSubscriptionListEditor;\n  unsubscribe(subscriptionListID: string, contactScope: ContactSubscriptionScope): ContactSubscriptionListEditor;\n  apply(success: () => void, failure: (message: string) => void): ContactSubscriptionListEditor;\n}\n\n/**\n * Enum for notification types.\n *\n * @readonly\n * @enum {number}\n */\nexport enum NotificationType {\n  none = 0,\n  badge = 1,\n  sound = 2,\n  alert = 4,\n}\n\n/**\n * Enum for presentation options.\n *\n * @readonly\n * @enum {number}\n */\nexport enum PresentationOptions {\n  none = 0,\n  badge = 1,\n  sound = 2,\n  alert = 4,\n}\n\n/**\n * @name UrbanAirShip\n * @description\n * This plugin does something\n * @usage\n * ```typescript\n * import { UrbanAirShip } from '@awesome-cordova-plugins/urbanairship/ngx';\n *\n *\n * constructor(private urbanAirShip: UrbanAirShip) { }\n *\n * ...\n *\n *\n * this.urbanAirShip.takeOff(config)\n *   .then((res: any) => console.log(res))\n *   .catch((error: any) => console.error(error));\n *\n * ```\n */\n@Plugin({\n  pluginName: 'UrbanAirShip',\n  plugin: 'urbanairship-cordova',\n  pluginRef: 'window.UAirship',\n  repo: 'https://www.npmjs.com/package/urbanairship-cordova',\n  install: 'ionic cordova plugin add urbanairship-cordova',\n  platforms: ['Android', 'iOS'],\n})\n@Injectable()\nexport class UrbanAirShip extends AwesomeCordovaNativePlugin {\n  /**\n   * Event fired when a new deep link is received.\n   *\n   * @event deep_link\n   * @type {object}\n   * @param {string} [deepLink] The deep link.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.deep_link',\n    element: 'document',\n  })\n  onDeepLink(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when a channel registration occurs.\n   *\n   * @event registration\n   * @type {object}\n   * @param {string} [channelID] The channel ID.\n   * @param {string} [registrationToken] The deviceToken on iOS, and the FCM/ADM token on Android.\n   * @param {string} [error] Error message if an error occurred.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.registration',\n    element: 'document',\n  })\n  onRegistration(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when the inbox is updated.\n   *\n   * @event inbox_updated\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.inbox_updated',\n    element: 'document',\n  })\n  onInboxUpdated(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when the inbox needs to be displayed. This event is only emitted if auto\n   * launch message center is disabled.\n   *\n   * @event show_inbox\n   * @type {object}\n   * @param {string} [messageId] The optional message ID.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.show_inbox',\n    element: 'document',\n  })\n  onShowInbox(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when a push is received.\n   *\n   * @event push\n   * @type {object}\n   * @param {string} message The push alert message.\n   * @param {string} title The push title.\n   * @param {string} subtitle The push subtitle.\n   * @param {object} extras Any push extras.\n   * @param {object} aps The raw aps dictionary (iOS only)\n   * @param {number} [notification_id] The Android notification ID. Deprecated in favor of notificationId.\n   * @param {string} [notificationId] The notification ID.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.push',\n    element: 'document',\n  })\n  onPushReceived(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when notification opened.\n   *\n   * @event notification_opened\n   * @type {object}\n   * @param {string} message The push alert message.\n   * @param {object} extras Any push extras.\n   * @param {number} [notification_id] The Android notification ID. Deprecated in favor of notificationId.\n   * @param {string} [notificationId] The notification ID.\n   * @param {string} [actionID] The ID of the notification action button if available.\n   * @param {boolean} isForeground Will always be true if the user taps the main notification. Otherwise its defined by the notification action button.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.notification_opened',\n    element: 'document',\n  })\n  onNotificationOpened(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when the user notification opt-in status changes.\n   *\n   * @event notification_opt_in_status\n   * @type {object}\n   * @param {boolean} optIn If the user is opted in or not to user notifications.\n   * @param {object} [authorizedNotificationSettings] iOS only. A map of authorized settings.\n   * @param {boolean} authorizedNotificationSettings.alert If alerts are authorized.\n   * @param {boolean} authorizedNotificationSettings.sound If sounds are authorized.\n   * @param {boolean} authorizedNotificationSettings.badge If badges are authorized.\n   * @param {boolean} authorizedNotificationSettings.carPlay If car play is authorized.\n   * @param {boolean} authorizedNotificationSettings.lockScreen If the lock screen is authorized.\n   * @param {boolean} authorizedNotificationSettings.notificationCenter If the notification center is authorized.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.notification_opt_in_status',\n    element: 'document',\n  })\n  onNotificationOptInStatus(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Re-attaches document event listeners in this webview\n   */\n  @Cordova({\n    sync: true,\n  })\n  reattach(): void {\n    return;\n  }\n\n  /**\n   * Initailizes Urban Airship.\n   *\n   * The plugin will automatically call takeOff during the next app init in\n   * order to properly handle incoming push. If takeOff is called multiple times\n   * in a session, or if the config is different than the previous sesssion, the\n   * new config will not be used until the next app start.\n   *\n   * @param {object}  config The Urban Airship config.\n   * @param {string}  config.site Sets the cloud site, must be either EU or US.\n   * @param {object}  config.development The Urban Airship development config.\n   * @param {string}  config.development.appKey The development appKey.\n   * @param {string}  config.development.appSecret The development appSecret.\n   * @param {object}  config.production The Urban Airship production config.\n   * @param {string}  config.production.appKey The production appKey.\n   * @param {string}  config.production.appSecret The production appSecret.\n   */\n  @Cordova()\n  takeOff(config: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the Android notification config. Values not set will fallback to any values set in the config.xml.\n   *\n   * @param {object}  config The notification config.\n   * @param {string}  [config.icon] The name of the drawable resource to use as the notification icon.\n   * @param {string}  [config.largeIcon] The name of the drawable resource to use as the notification large icon.\n   * @param {string}  [config.accentColor] The notification accent color. Format is #AARRGGBB.\n   */\n  @Cordova()\n  setAndroidNotificationConfig(config: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the default behavior when the message center is launched from a push\n   * notification. If set to false the message center must be manually launched.\n   *\n   * @param {boolean} enabled true to automatically launch the default message center, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAutoLaunchDefaultMessageCenter(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables user notifications.\n   *\n   * @param {boolean} enabled true to enable notifications, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setUserNotificationsEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if user notifications are enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if user notifications is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isUserNotificationsEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if app notifications are enabled or not. Its possible to have `userNotificationsEnabled`\n   * but app notifications being disabled if the user opted out of notifications.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if app notifications is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isAppNotificationsEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the channel ID.\n   *\n   * @param {function(ID)} success The function to call on success.\n   * @param {string} success.ID The channel ID string\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getChannelID(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the last notification that launched the application.\n   *\n   * @param {boolean} clear true to clear the notification.\n   * @param {function(push)} success The function to call on success.\n   * @param {object} success.push The push message object containing data associated with a push notification.\n   * @param {string} success.push.message The push alert message.\n   * @param {object} success.push.extras Any push extras.\n   * @param {number} [success.push.notification_id] The Android notification ID.\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getLaunchNotification(clear: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the last received deep link.\n   *\n   * @param {boolean} clear true to clear the deep link.\n   * @param {function(push)} success The function to call on success.\n   * @param {string} success.deepLink The deep link.\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getDeepLink(clear: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the tags as an array.\n   *\n   * @param {function(tags)} success The function to call on success.\n   * @param {Array} success.tags The tags as an array.\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getTags(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the tags.\n   *\n   * @param {Array} tags an array of strings.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setTags(tags: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the alias.\n   *\n   * @deprecated Deprecated since 6.7.0 - to be removed in a future version of the plugin - please use getNamedUser\n   * @param {function(currentAlias)} success The function to call on success.\n   * @param {string} success.currentAlias The alias as a string.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getAlias(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the alias.\n   *\n   * @deprecated Deprecated since 6.7.0  - to be removed in a future version of the plugin - please use setNamedUser\n   * @param {string} alias string\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAlias(alias: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if quiet time is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if quiet time is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isQuietTimeEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables quiet time.\n   *\n   * @param {boolean} enabled true to enable quiet time, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setQuietTimeEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if the device is currently in quiet time.\n   *\n   * @param {function(inQuietTime)} success Success callback.\n   * @param {boolean} success.inQuietTime Flag indicating if quiet time is currently in effect.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isInQuietTime(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the quiet time as an object with the following:\n   * \"startHour\": Number,\n   * \"startMinute\": Number,\n   * \"endHour\": Number,\n   * \"endMinute\": Number\n   *\n   * @param {function(quietTime)} success The function to call on success.\n   * @param {object} success.quietTime The quietTime object represents a timespan during\n   *        which notifications should be silenced.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getQuietTime(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the quiet time.\n   *\n   * @param {number} startHour for quiet time.\n   * @param {number} startMinute for quiet time.\n   * @param {number} endHour for quiet time.\n   * @param {number} endMinute for quiet time.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setQuietTime(startHour: number, startMinute: number, endHour: number, endMinute: number): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables analytics.\n   *\n   * Disabling analytics will delete any locally stored events\n   * and prevent any events from uploading. Features that depend on analytics being\n   * enabled may not work properly if it's disabled (reports, region triggers,\n   * location segmentation, push to local time).\n   *\n   * @param {boolean} enabled true to enable analytics, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAnalyticsEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if analytics is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if analytics is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isAnalyticsEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the named user ID.\n   *\n   * @param {function(namedUser)} success The function to call on success.\n   * @param {string} success.namedUser The named user ID as a string.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getNamedUser(): Promise<string> {\n    return;\n  }\n\n  /**\n   * Sets the named user ID.\n   *\n   * @param {string} namedUser identifier string.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setNamedUser(namedUser: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Runs an Urban Airship action.\n   *\n   * @param {string} actionName action as a string.\n   * @param {*} actionValue\n   * @param {function(result)} [success] The function to call on success.\n   * @param {object} success.result The result's value.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  runAction(actionName: string, actionValue: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the named user tag groups.\n   */\n  @Cordova({ sync: true })\n  editNamedUserTagGroups(): TagGroupEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel tag groups.\n   */\n  @Cordova({ sync: true })\n  editChannelTagGroups(): TagGroupEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel attributes.\n   */\n  @Cordova({ sync: true })\n  editChannelAttributes(): AttributesEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the named user attributes.\n   */\n  @Cordova({ sync: true })\n  editNamedUserAttributes(): AttributesEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel subscription lists.\n   *\n   * @returns {ChannelSubscriptionListEditor} A subscription list editor instance.\n   * @since 13.3.0\n   */\n  @Cordova({ sync: true })\n  editChannelSubscriptionLists(): ChannelSubscriptionListEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the contact subscription lists.\n   *\n   * @returns {ContactSubscriptionListEditor} A subscription list editor instance.\n   * @since 13.3.0\n   */\n  @Cordova({ sync: true })\n  editContactSubscriptionLists(): ContactSubscriptionListEditor {\n    return;\n  }\n\n  /**\n   * Returns the current set of subscription lists for the current channel,\n   * optionally applying pending subscription list changes that will be applied during the next channel update.\n   * An empty set indicates that this contact is not subscribed to any lists.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova({\n    successIndex: 0,\n    errorIndex: 1,\n  })\n  getChannelSubscriptionLists(): Promise<string[]> {\n    return;\n  }\n\n  /**\n   * Returns the current set of subscription lists for the current contact,\n   * optionally applying pending subscription list changes that will be applied during the next contact update.\n   * An empty set indicates that this contact is not subscribed to any lists.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova({\n    successIndex: 0,\n    errorIndex: 1,\n  })\n  getContactSubscriptionLists(): Promise<string[]> {\n    return;\n  }\n\n  /**\n   * Sets an associated identifier for the Connect data stream.\n   *\n   * @param key Custom key for identifier.\n   * @param identifier The identifier value.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAssociatedIdentifier(key: string, identifier: string): Promise<void> {\n    return;\n  }\n\n  // Location\n\n  /**\n   * Enables or disables Urban Airship location services.\n   *\n   * @param {boolean} enabled true to enable location, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setLocationEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if location is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if location is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 8.0\n   */\n  @Cordova()\n  isLocationEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables background location.\n   *\n   * @param {boolean} enabled true to enable background location, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 8.0\n   */\n  @Cordova()\n  setBackgroundLocationEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if background location is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if background location updates are enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 8.0\n   */\n  @Cordova()\n  isBackgroundLocationEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Displays the message center.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  displayMessageCenter(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Dismiss the message center.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  dismissMessageCenter(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Dismiss the inbox message.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  dismissInboxMessage(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Dismiss the inbox message in the overlay.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 10.0\n   */\n  @Cordova()\n  dismissOverlayInboxMessage(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Gets the array of inbox messages. Each message will have the following properties:\n   * \"id\": string - The messages ID. Needed to display, mark as read, or delete the message.\n   * \"title\": string - The message title.\n   * \"sentDate\": number - The message sent date in milliseconds.\n   * \"listIconUrl\": string, optional - The icon url for the message.\n   * \"isRead\": boolean - The unread/read status of the message.\n   * \"extras\": object - String to String map of any message extras.\n   *\n   * @param {function(messages)} success The function to call on success.\n   * @param {Array} success.messages The array of inbox messages.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getInboxMessages(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Marks an inbox message read.\n   *\n   * @param {string} messageId The ID of the message to mark as read.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  markInboxMessageRead(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Deletes an inbox message.\n   *\n   * @param {string} messageId The ID of the message to delete.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  deleteInboxMessage(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Displays the inbox message using a full screen view.\n   *\n   * @param {string} messageId The ID of the message to display.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  displayInboxMessage(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Forces the inbox to refresh. This is normally not needed as the inbox\n   * will automatically refresh on foreground or when a push arrives thats\n   * associated with a message, but it can be useful when providing a refresh\n   * button for the message listing.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  refreshInbox(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Displays the inbox message using an overlay display.\n   *\n   * @param {string} messageId The ID of the message to display.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 10.0\n   */\n  @Cordova()\n  overlayInboxMessage(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Clears a notification by identifier.\n   *\n   * @param {string} identifier The notification identifier.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   */\n  @Cordova()\n  clearNotification(identifier: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Clears all notifications posted by the application.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  clearNotifications(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Gets currently active notifications.\n   *\n   * Note: On Android this functionality is only supported on Android M or higher.\n   *\n   * @param {function(messages)} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   */\n  @Cordova()\n  getActiveNotifications(): Promise<any> {\n    return;\n  }\n\n  // iOS only\n\n  /**\n   * Enables or disables auto badge. Defaults to `NO`.\n   *\n   * @param {boolean} enabled true to enable auto badge, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAutobadgeEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the badge number.\n   *\n   * @param count number specified badge to set.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setBadgeNumber(count: number): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the current badge number.\n   *\n   * @param {function(badgeNumber)} success The function to call on success.\n   * @param {int} success.badgeNumber The current application badge number.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getBadgeNumber(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Clears the badge.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  resetBadge(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the iOS notification types. Specify the combination of\n   * badges, sound and alerts that are desired.\n   *\n   * @param types specified notification types.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setNotificationTypes(types: NotificationType): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the iOS presentation options. Specify the combination of\n   * badges, sound and alerts that are desired.\n   *\n   * @param options types specified presentation options.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setPresentationOptions(options: PresentationOptions): Promise<any> {\n    return;\n  }\n\n  // Android only\n\n  /**\n   * Checks if notification sound is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if sound is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isSoundEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables notification sound.\n   *\n   * @param {boolean} enabled true to enable sound, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setSoundEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if notification vibration is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if vibration is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isVibrateEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables notification vibration.\n   *\n   * @param {boolean} enabled true to enable vibration, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setVibrateEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Adds a custom event.\n   *\n   * @param {object} event The custom event object.\n   * @param {string} event.name The event's name.\n   * @param {number} [event.value] The event's value.\n   * @param {string} [event.transactionId] The event's transaction ID.\n   * @param {object} [event.properties] The event's properties. Only numbers, booleans, strings, and array of strings are supported.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  addCustomEvent(event: object): Promise<any> {\n    return;\n  }\n\n  /**\n   * Initiates screen tracking for a specific app screen, must be called once per tracked screen.\n   *\n   * @param {string} screen The screen's string identifier.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 11.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  trackScreen(screen: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables features, adding them to the set of currently enabled features.\n   *\n   * @param {Array<string>} features The features to enable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  enableFeature(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Disables features, removing them from the set of currently enabled features.\n   *\n   * @param {Array<string>} features The features to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  disableFeature(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the current enabled features, replacing any currently enabled features with the given set.\n   *\n   * @param {Array<string>} features The features to set as enabled.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  setEnabledFeatures(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Gets the current enabled features.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 0,\n    errorIndex: 1,\n  })\n  getEnabledFeatures(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if all of the given features are enabled.\n   *\n   * @param {Array<string>} features The features to check.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  isFeatureEnabled(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the configuration of the Preference Center with the given ID trough a callback method.\n   *\n   * @param {string} preferenceCenterId The preference center ID.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.3.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  getPreferenceCenterConfig(preferenceCenterId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Opens the Preference Center with the given preferenceCenterId.\n   *\n   * @param {string} prenferenceCenterId The preference center ID.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  openPreferenceCenter(prenferenceCenterId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Overrides the locale setting.\n   *\n   * @param {string} locale language and optional country code.\n   * @param {function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 14.3.0\n   */\n  @Cordova()\n  setCurrentLocale(locale: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the currently set locale.\n   *\n   * @param {function(locale)} [success] Success callback.\n   * @param {string} success.locale The locale as a string.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 14.3.0\n   */\n  @Cordova()\n  getCurrentLocale(): Promise<string> {\n    return;\n  }\n\n  /**\n   * Resets the current locale.\n   *\n   * @param {function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 14.3.0\n   */\n  @Cordova()\n  clearLocale(): Promise<any> {\n    return;\n  }\n}\n"]}

package/ngx/bundle.js

@@ -142,6 +142,9 @@ var UrbanAirShip = /** @class */ (function (_super) {
     UrbanAirShip.prototype.isFeatureEnabled = function (features) { return core.cordova(this, "isFeatureEnabled", { "successIndex": 1, "errorIndex": 2 }, arguments); };
     UrbanAirShip.prototype.getPreferenceCenterConfig = function (preferenceCenterId) { return core.cordova(this, "getPreferenceCenterConfig", { "successIndex": 1, "errorIndex": 2 }, arguments); };
     UrbanAirShip.prototype.openPreferenceCenter = function (prenferenceCenterId) { return core.cordova(this, "openPreferenceCenter", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    UrbanAirShip.prototype.setCurrentLocale = function (locale) { return core.cordova(this, "setCurrentLocale", {}, arguments); };
+    UrbanAirShip.prototype.getCurrentLocale = function () { return core.cordova(this, "getCurrentLocale", {}, arguments); };
+    UrbanAirShip.prototype.clearLocale = function () { return core.cordova(this, "clearLocale", {}, arguments); };
     UrbanAirShip.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0__namespace, type: UrbanAirShip, deps: null, target: i0__namespace.ɵɵFactoryTarget.Injectable });
     UrbanAirShip.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0__namespace, type: UrbanAirShip });
     UrbanAirShip.pluginName = "UrbanAirShip";
@@ -155,6 +158,6 @@ var UrbanAirShip = /** @class */ (function (_super) {
 }(core.AwesomeCordovaNativePlugin));
 i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0__namespace, type: UrbanAirShip, decorators: [{
             type: i0.Injectable
-        }], propDecorators: { onDeepLink: [], onRegistration: [], onInboxUpdated: [], onShowInbox: [], onPushReceived: [], onNotificationOpened: [], onNotificationOptInStatus: [], reattach: [], takeOff: [], setAndroidNotificationConfig: [], setAutoLaunchDefaultMessageCenter: [], setUserNotificationsEnabled: [], isUserNotificationsEnabled: [], isAppNotificationsEnabled: [], getChannelID: [], getLaunchNotification: [], getDeepLink: [], getTags: [], setTags: [], getAlias: [], setAlias: [], isQuietTimeEnabled: [], setQuietTimeEnabled: [], isInQuietTime: [], getQuietTime: [], setQuietTime: [], setAnalyticsEnabled: [], isAnalyticsEnabled: [], getNamedUser: [], setNamedUser: [], runAction: [], editNamedUserTagGroups: [], editChannelTagGroups: [], editChannelAttributes: [], editNamedUserAttributes: [], editChannelSubscriptionLists: [], editContactSubscriptionLists: [], getChannelSubscriptionLists: [], getContactSubscriptionLists: [], setAssociatedIdentifier: [], setLocationEnabled: [], isLocationEnabled: [], setBackgroundLocationEnabled: [], isBackgroundLocationEnabled: [], displayMessageCenter: [], dismissMessageCenter: [], dismissInboxMessage: [], dismissOverlayInboxMessage: [], getInboxMessages: [], markInboxMessageRead: [], deleteInboxMessage: [], displayInboxMessage: [], refreshInbox: [], overlayInboxMessage: [], clearNotification: [], clearNotifications: [], getActiveNotifications: [], setAutobadgeEnabled: [], setBadgeNumber: [], getBadgeNumber: [], resetBadge: [], setNotificationTypes: [], setPresentationOptions: [], isSoundEnabled: [], setSoundEnabled: [], isVibrateEnabled: [], setVibrateEnabled: [], addCustomEvent: [], trackScreen: [], enableFeature: [], disableFeature: [], getEnabledFeatures: [], isFeatureEnabled: [], getPreferenceCenterConfig: [], openPreferenceCenter: [] } });
+        }], propDecorators: { onDeepLink: [], onRegistration: [], onInboxUpdated: [], onShowInbox: [], onPushReceived: [], onNotificationOpened: [], onNotificationOptInStatus: [], reattach: [], takeOff: [], setAndroidNotificationConfig: [], setAutoLaunchDefaultMessageCenter: [], setUserNotificationsEnabled: [], isUserNotificationsEnabled: [], isAppNotificationsEnabled: [], getChannelID: [], getLaunchNotification: [], getDeepLink: [], getTags: [], setTags: [], getAlias: [], setAlias: [], isQuietTimeEnabled: [], setQuietTimeEnabled: [], isInQuietTime: [], getQuietTime: [], setQuietTime: [], setAnalyticsEnabled: [], isAnalyticsEnabled: [], getNamedUser: [], setNamedUser: [], runAction: [], editNamedUserTagGroups: [], editChannelTagGroups: [], editChannelAttributes: [], editNamedUserAttributes: [], editChannelSubscriptionLists: [], editContactSubscriptionLists: [], getChannelSubscriptionLists: [], getContactSubscriptionLists: [], setAssociatedIdentifier: [], setLocationEnabled: [], isLocationEnabled: [], setBackgroundLocationEnabled: [], isBackgroundLocationEnabled: [], displayMessageCenter: [], dismissMessageCenter: [], dismissInboxMessage: [], dismissOverlayInboxMessage: [], getInboxMessages: [], markInboxMessageRead: [], deleteInboxMessage: [], displayInboxMessage: [], refreshInbox: [], overlayInboxMessage: [], clearNotification: [], clearNotifications: [], getActiveNotifications: [], setAutobadgeEnabled: [], setBadgeNumber: [], getBadgeNumber: [], resetBadge: [], setNotificationTypes: [], setPresentationOptions: [], isSoundEnabled: [], setSoundEnabled: [], isVibrateEnabled: [], setVibrateEnabled: [], addCustomEvent: [], trackScreen: [], enableFeature: [], disableFeature: [], getEnabledFeatures: [], isFeatureEnabled: [], getPreferenceCenterConfig: [], openPreferenceCenter: [], setCurrentLocale: [], getCurrentLocale: [], clearLocale: [] } });
 
 exports.UrbanAirShip = UrbanAirShip;

package/ngx/index.d.ts

@@ -798,4 +798,33 @@ export declare class UrbanAirShip extends AwesomeCordovaNativePlugin {
      * @since 13.0.0
      */
     openPreferenceCenter(prenferenceCenterId: string): Promise<any>;
+    /**
+     * Overrides the locale setting.
+     *
+     * @param {string} locale language and optional country code.
+     * @param {function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 14.3.0
+     */
+    setCurrentLocale(locale: string): Promise<any>;
+    /**
+     * Returns the currently set locale.
+     *
+     * @param {function(locale)} [success] Success callback.
+     * @param {string} success.locale The locale as a string.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 14.3.0
+     */
+    getCurrentLocale(): Promise<string>;
+    /**
+     * Resets the current locale.
+     *
+     * @param {function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 14.3.0
+     */
+    clearLocale(): Promise<any>;
 }

package/ngx/index.js

@@ -121,6 +121,9 @@ var UrbanAirShip = /** @class */ (function (_super) {
     UrbanAirShip.prototype.isFeatureEnabled = function (features) { return cordova(this, "isFeatureEnabled", { "successIndex": 1, "errorIndex": 2 }, arguments); };
     UrbanAirShip.prototype.getPreferenceCenterConfig = function (preferenceCenterId) { return cordova(this, "getPreferenceCenterConfig", { "successIndex": 1, "errorIndex": 2 }, arguments); };
     UrbanAirShip.prototype.openPreferenceCenter = function (prenferenceCenterId) { return cordova(this, "openPreferenceCenter", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    UrbanAirShip.prototype.setCurrentLocale = function (locale) { return cordova(this, "setCurrentLocale", {}, arguments); };
+    UrbanAirShip.prototype.getCurrentLocale = function () { return cordova(this, "getCurrentLocale", {}, arguments); };
+    UrbanAirShip.prototype.clearLocale = function () { return cordova(this, "clearLocale", {}, arguments); };
     UrbanAirShip.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: UrbanAirShip, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
     UrbanAirShip.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: UrbanAirShip });
     UrbanAirShip.pluginName = "UrbanAirShip";
@@ -135,5 +138,5 @@ var UrbanAirShip = /** @class */ (function (_super) {
 export { UrbanAirShip };
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: UrbanAirShip, decorators: [{
             type: Injectable
-        }], propDecorators: { onDeepLink: [], onRegistration: [], onInboxUpdated: [], onShowInbox: [], onPushReceived: [], onNotificationOpened: [], onNotificationOptInStatus: [], reattach: [], takeOff: [], setAndroidNotificationConfig: [], setAutoLaunchDefaultMessageCenter: [], setUserNotificationsEnabled: [], isUserNotificationsEnabled: [], isAppNotificationsEnabled: [], getChannelID: [], getLaunchNotification: [], getDeepLink: [], getTags: [], setTags: [], getAlias: [], setAlias: [], isQuietTimeEnabled: [], setQuietTimeEnabled: [], isInQuietTime: [], getQuietTime: [], setQuietTime: [], setAnalyticsEnabled: [], isAnalyticsEnabled: [], getNamedUser: [], setNamedUser: [], runAction: [], editNamedUserTagGroups: [], editChannelTagGroups: [], editChannelAttributes: [], editNamedUserAttributes: [], editChannelSubscriptionLists: [], editContactSubscriptionLists: [], getChannelSubscriptionLists: [], getContactSubscriptionLists: [], setAssociatedIdentifier: [], setLocationEnabled: [], isLocationEnabled: [], setBackgroundLocationEnabled: [], isBackgroundLocationEnabled: [], displayMessageCenter: [], dismissMessageCenter: [], dismissInboxMessage: [], dismissOverlayInboxMessage: [], getInboxMessages: [], markInboxMessageRead: [], deleteInboxMessage: [], displayInboxMessage: [], refreshInbox: [], overlayInboxMessage: [], clearNotification: [], clearNotifications: [], getActiveNotifications: [], setAutobadgeEnabled: [], setBadgeNumber: [], getBadgeNumber: [], resetBadge: [], setNotificationTypes: [], setPresentationOptions: [], isSoundEnabled: [], setSoundEnabled: [], isVibrateEnabled: [], setVibrateEnabled: [], addCustomEvent: [], trackScreen: [], enableFeature: [], disableFeature: [], getEnabledFeatures: [], isFeatureEnabled: [], getPreferenceCenterConfig: [], openPreferenceCenter: [] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/@awesome-cordova-plugins/plugins/urbanairship/ngx/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,uCAA+C,MAAM,+BAA+B,CAAC;AAC5F,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;;AAwClC;;;;;GAKG;AACH,MAAM,CAAN,IAAY,gBAKX;AALD,WAAY,gBAAgB;IAC1B,uDAAQ,CAAA;IACR,yDAAS,CAAA;IACT,yDAAS,CAAA;IACT,yDAAS,CAAA;AACX,CAAC,EALW,gBAAgB,KAAhB,gBAAgB,QAK3B;AAED;;;;;GAKG;AACH,MAAM,CAAN,IAAY,mBAKX;AALD,WAAY,mBAAmB;IAC7B,6DAAQ,CAAA;IACR,+DAAS,CAAA;IACT,+DAAS,CAAA;IACT,+DAAS,CAAA;AACX,CAAC,EALW,mBAAmB,KAAnB,mBAAmB,QAK9B;;IA+BiC,gCAA0B;;;;IAa1D,iCAAU;IAkBV,qCAAc;IAcd,qCAAc;IAiBd,kCAAW;IAsBX,qCAAc;IAqBd,2CAAoB;IAuBpB,gDAAyB;IAUzB,+BAAQ;IAsBR,8BAAO,aAAC,MAAW;IAanB,mDAA4B,aAAC,MAAW;IAcxC,wDAAiC,aAAC,OAAgB;IAalD,kDAA2B,aAAC,OAAgB;IAa5C,iDAA0B;IAc1B,gDAAyB;IAazB,mCAAY;IAiBZ,4CAAqB,aAAC,KAAc;IAcpC,kCAAW,aAAC,KAAc;IAa1B,8BAAO;IAaP,8BAAO,aAAC,IAAc;IActB,+BAAQ;IAcR,+BAAQ,aAAC,KAAa;IAatB,yCAAkB;IAalB,0CAAmB,aAAC,OAAgB;IAapC,oCAAa;IAkBb,mCAAY;IAgBZ,mCAAY,aAAC,SAAiB,EAAE,WAAmB,EAAE,OAAe,EAAE,SAAiB;IAkBvF,0CAAmB,aAAC,OAAgB;IAapC,yCAAkB;IAalB,mCAAY;IAaZ,mCAAY,aAAC,SAAiB;IAe9B,gCAAS,aAAC,UAAkB,EAAE,WAAgB;IAQ9C,6CAAsB;IAQtB,2CAAoB;IAQpB,4CAAqB;IAQrB,8CAAuB;IAWvB,mDAA4B;IAW5B,mDAA4B;IAgB5B,kDAA2B;IAgB3B,kDAA2B;IAc3B,8CAAuB,aAAC,GAAW,EAAE,UAAkB;IAevD,yCAAkB,aAAC,OAAgB;IAcnC,wCAAiB;IAcjB,mDAA4B,aAAC,OAAgB;IAc7C,kDAA2B;IAY3B,2CAAoB;IAYpB,2CAAoB;IAYpB,0CAAmB;IAanB,iDAA0B;IAmB1B,uCAAgB;IAahB,2CAAoB,aAAC,SAAiB;IAatC,yCAAkB,aAAC,SAAiB;IAapC,0CAAmB,aAAC,SAAiB;IAerC,mCAAY;IAcZ,0CAAmB,aAAC,SAAiB;IAYrC,wCAAiB,aAAC,UAAkB;IAYpC,yCAAkB;IAalB,6CAAsB;IAetB,0CAAmB,aAAC,OAAgB;IAapC,qCAAc,aAAC,KAAa;IAa5B,qCAAc;IAYd,iCAAU;IAcV,2CAAoB,aAAC,KAAuB;IAc5C,6CAAsB,aAAC,OAA4B;IAenD,qCAAc;IAad,sCAAe,aAAC,OAAgB;IAahC,uCAAgB;IAahB,wCAAiB,aAAC,OAAgB;IAiBlC,qCAAc,aAAC,KAAa;IAiB5B,kCAAW,aAAC,MAAc;IAiB1B,oCAAa,aAAC,QAAkB;IAiBhC,qCAAc,aAAC,QAAkB;IAIjC;;;;;;;;OAQG;IACH,yCAAkB,GAAlB,UAAmB,QAAkB;QACnC,OAAO;IACT,CAAC;IAcD,yCAAkB;IAiBlB,uCAAgB,aAAC,QAAkB;IAiBnC,gDAAyB,aAAC,kBAA0B;IAiBpD,2CAAoB,aAAC,mBAA2B;8GA3jCrC,YAAY;kHAAZ,YAAY;;;;;;;IAAZ,YAAY,kBAAZ,YAAY;uBAjGzB;EAiGkC,0BAA0B;SAA/C,YAAY;4FAAZ,YAAY;kBADxB,UAAU;8BAcT,UAAU,MAkBV,cAAc,MAcd,cAAc,MAiBd,WAAW,MAsBX,cAAc,MAqBd,oBAAoB,MAuBpB,yBAAyB,MAUzB,QAAQ,MAsBR,OAAO,MAaP,4BAA4B,MAc5B,iCAAiC,MAajC,2BAA2B,MAa3B,0BAA0B,MAc1B,yBAAyB,MAazB,YAAY,MAiBZ,qBAAqB,MAcrB,WAAW,MAaX,OAAO,MAaP,OAAO,MAcP,QAAQ,MAcR,QAAQ,MAaR,kBAAkB,MAalB,mBAAmB,MAanB,aAAa,MAkBb,YAAY,MAgBZ,YAAY,MAkBZ,mBAAmB,MAanB,kBAAkB,MAalB,YAAY,MAaZ,YAAY,MAeZ,SAAS,MAQT,sBAAsB,MAQtB,oBAAoB,MAQpB,qBAAqB,MAQrB,uBAAuB,MAWvB,4BAA4B,MAW5B,4BAA4B,MAgB5B,2BAA2B,MAgB3B,2BAA2B,MAc3B,uBAAuB,MAevB,kBAAkB,MAclB,iBAAiB,MAcjB,4BAA4B,MAc5B,2BAA2B,MAY3B,oBAAoB,MAYpB,oBAAoB,MAYpB,mBAAmB,MAanB,0BAA0B,MAmB1B,gBAAgB,MAahB,oBAAoB,MAapB,kBAAkB,MAalB,mBAAmB,MAenB,YAAY,MAcZ,mBAAmB,MAYnB,iBAAiB,MAYjB,kBAAkB,MAalB,sBAAsB,MAetB,mBAAmB,MAanB,cAAc,MAad,cAAc,MAYd,UAAU,MAcV,oBAAoB,MAcpB,sBAAsB,MAetB,cAAc,MAad,eAAe,MAaf,gBAAgB,MAahB,iBAAiB,MAiBjB,cAAc,MAiBd,WAAW,MAiBX,aAAa,MAiBb,cAAc,MA6Bd,kBAAkB,MAiBlB,gBAAgB,MAiBhB,yBAAyB,MAiBzB,oBAAoB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Plugin, Cordova, AwesomeCordovaNativePlugin } from '@awesome-cordova-plugins/core';\nimport { Observable } from 'rxjs';\n\n/**\n * Interface for UAirship Tag Editor\n */\nexport interface TagGroupEditor {\n  addTags(tagGroup: string, tags: string[]): TagGroupEditor;\n  removeTags(tagGroup: string, tags: string[]): TagGroupEditor;\n  apply(success: () => void, failure: (message: string) => void): TagGroupEditor;\n}\n\n/**\n * Interface for UAirship Attributes Editor\n */\nexport interface AttributesEditor {\n  setAttribute(name: string, value: string | number | boolean | Date): AttributesEditor;\n  removeAttribute(name: string): AttributesEditor;\n  apply(success: () => void, failure: (message: string) => void): AttributesEditor;\n}\n\n/**\n * Interface for UAirship ChannelSubscriptionList Editor\n */\nexport interface ChannelSubscriptionListEditor {\n  subscribe(subscriptionListID: string): ChannelSubscriptionListEditor;\n  unsubscribe(subscriptionListID: string): ChannelSubscriptionListEditor;\n  apply(success: () => void, failure: (message: string) => void): ChannelSubscriptionListEditor;\n}\n\nexport type ContactSubscriptionScope = 'app' | 'email' | 'push' | 'sms';\n\n/**\n * Interface for UAirship ContactSubscriptionList Editor\n */\nexport interface ContactSubscriptionListEditor {\n  subscribe(subscriptionListID: string, contactScope: ContactSubscriptionScope): ContactSubscriptionListEditor;\n  unsubscribe(subscriptionListID: string, contactScope: ContactSubscriptionScope): ContactSubscriptionListEditor;\n  apply(success: () => void, failure: (message: string) => void): ContactSubscriptionListEditor;\n}\n\n/**\n * Enum for notification types.\n *\n * @readonly\n * @enum {number}\n */\nexport enum NotificationType {\n  none = 0,\n  badge = 1,\n  sound = 2,\n  alert = 4,\n}\n\n/**\n * Enum for presentation options.\n *\n * @readonly\n * @enum {number}\n */\nexport enum PresentationOptions {\n  none = 0,\n  badge = 1,\n  sound = 2,\n  alert = 4,\n}\n\n/**\n * @name UrbanAirShip\n * @description\n * This plugin does something\n * @usage\n * ```typescript\n * import { UrbanAirShip } from '@awesome-cordova-plugins/urbanairship/ngx';\n *\n *\n * constructor(private urbanAirShip: UrbanAirShip) { }\n *\n * ...\n *\n *\n * this.urbanAirShip.takeOff(config)\n *   .then((res: any) => console.log(res))\n *   .catch((error: any) => console.error(error));\n *\n * ```\n */\n@Plugin({\n  pluginName: 'UrbanAirShip',\n  plugin: 'urbanairship-cordova',\n  pluginRef: 'window.UAirship',\n  repo: 'https://www.npmjs.com/package/urbanairship-cordova',\n  install: 'ionic cordova plugin add urbanairship-cordova',\n  platforms: ['Android', 'iOS'],\n})\n@Injectable()\nexport class UrbanAirShip extends AwesomeCordovaNativePlugin {\n  /**\n   * Event fired when a new deep link is received.\n   *\n   * @event deep_link\n   * @type {object}\n   * @param {string} [deepLink] The deep link.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.deep_link',\n    element: 'document',\n  })\n  onDeepLink(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when a channel registration occurs.\n   *\n   * @event registration\n   * @type {object}\n   * @param {string} [channelID] The channel ID.\n   * @param {string} [registrationToken] The deviceToken on iOS, and the FCM/ADM token on Android.\n   * @param {string} [error] Error message if an error occurred.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.registration',\n    element: 'document',\n  })\n  onRegistration(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when the inbox is updated.\n   *\n   * @event inbox_updated\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.inbox_updated',\n    element: 'document',\n  })\n  onInboxUpdated(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when the inbox needs to be displayed. This event is only emitted if auto\n   * launch message center is disabled.\n   *\n   * @event show_inbox\n   * @type {object}\n   * @param {string} [messageId] The optional message ID.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.show_inbox',\n    element: 'document',\n  })\n  onShowInbox(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when a push is received.\n   *\n   * @event push\n   * @type {object}\n   * @param {string} message The push alert message.\n   * @param {string} title The push title.\n   * @param {string} subtitle The push subtitle.\n   * @param {object} extras Any push extras.\n   * @param {object} aps The raw aps dictionary (iOS only)\n   * @param {number} [notification_id] The Android notification ID. Deprecated in favor of notificationId.\n   * @param {string} [notificationId] The notification ID.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.push',\n    element: 'document',\n  })\n  onPushReceived(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when notification opened.\n   *\n   * @event notification_opened\n   * @type {object}\n   * @param {string} message The push alert message.\n   * @param {object} extras Any push extras.\n   * @param {number} [notification_id] The Android notification ID. Deprecated in favor of notificationId.\n   * @param {string} [notificationId] The notification ID.\n   * @param {string} [actionID] The ID of the notification action button if available.\n   * @param {boolean} isForeground Will always be true if the user taps the main notification. Otherwise its defined by the notification action button.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.notification_opened',\n    element: 'document',\n  })\n  onNotificationOpened(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when the user notification opt-in status changes.\n   *\n   * @event notification_opt_in_status\n   * @type {object}\n   * @param {boolean} optIn If the user is opted in or not to user notifications.\n   * @param {object} [authorizedNotificationSettings] iOS only. A map of authorized settings.\n   * @param {boolean} authorizedNotificationSettings.alert If alerts are authorized.\n   * @param {boolean} authorizedNotificationSettings.sound If sounds are authorized.\n   * @param {boolean} authorizedNotificationSettings.badge If badges are authorized.\n   * @param {boolean} authorizedNotificationSettings.carPlay If car play is authorized.\n   * @param {boolean} authorizedNotificationSettings.lockScreen If the lock screen is authorized.\n   * @param {boolean} authorizedNotificationSettings.notificationCenter If the notification center is authorized.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.notification_opt_in_status',\n    element: 'document',\n  })\n  onNotificationOptInStatus(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Re-attaches document event listeners in this webview\n   */\n  @Cordova({\n    sync: true,\n  })\n  reattach(): void {\n    return;\n  }\n\n  /**\n   * Initailizes Urban Airship.\n   *\n   * The plugin will automatically call takeOff during the next app init in\n   * order to properly handle incoming push. If takeOff is called multiple times\n   * in a session, or if the config is different than the previous sesssion, the\n   * new config will not be used until the next app start.\n   *\n   * @param {object}  config The Urban Airship config.\n   * @param {string}  config.site Sets the cloud site, must be either EU or US.\n   * @param {object}  config.development The Urban Airship development config.\n   * @param {string}  config.development.appKey The development appKey.\n   * @param {string}  config.development.appSecret The development appSecret.\n   * @param {object}  config.production The Urban Airship production config.\n   * @param {string}  config.production.appKey The production appKey.\n   * @param {string}  config.production.appSecret The production appSecret.\n   */\n  @Cordova()\n  takeOff(config: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the Android notification config. Values not set will fallback to any values set in the config.xml.\n   *\n   * @param {object}  config The notification config.\n   * @param {string}  [config.icon] The name of the drawable resource to use as the notification icon.\n   * @param {string}  [config.largeIcon] The name of the drawable resource to use as the notification large icon.\n   * @param {string}  [config.accentColor] The notification accent color. Format is #AARRGGBB.\n   */\n  @Cordova()\n  setAndroidNotificationConfig(config: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the default behavior when the message center is launched from a push\n   * notification. If set to false the message center must be manually launched.\n   *\n   * @param {boolean} enabled true to automatically launch the default message center, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAutoLaunchDefaultMessageCenter(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables user notifications.\n   *\n   * @param {boolean} enabled true to enable notifications, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setUserNotificationsEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if user notifications are enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if user notifications is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isUserNotificationsEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if app notifications are enabled or not. Its possible to have `userNotificationsEnabled`\n   * but app notifications being disabled if the user opted out of notifications.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if app notifications is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isAppNotificationsEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the channel ID.\n   *\n   * @param {function(ID)} success The function to call on success.\n   * @param {string} success.ID The channel ID string\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getChannelID(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the last notification that launched the application.\n   *\n   * @param {boolean} clear true to clear the notification.\n   * @param {function(push)} success The function to call on success.\n   * @param {object} success.push The push message object containing data associated with a push notification.\n   * @param {string} success.push.message The push alert message.\n   * @param {object} success.push.extras Any push extras.\n   * @param {number} [success.push.notification_id] The Android notification ID.\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getLaunchNotification(clear: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the last received deep link.\n   *\n   * @param {boolean} clear true to clear the deep link.\n   * @param {function(push)} success The function to call on success.\n   * @param {string} success.deepLink The deep link.\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getDeepLink(clear: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the tags as an array.\n   *\n   * @param {function(tags)} success The function to call on success.\n   * @param {Array} success.tags The tags as an array.\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getTags(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the tags.\n   *\n   * @param {Array} tags an array of strings.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setTags(tags: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the alias.\n   *\n   * @deprecated Deprecated since 6.7.0 - to be removed in a future version of the plugin - please use getNamedUser\n   * @param {function(currentAlias)} success The function to call on success.\n   * @param {string} success.currentAlias The alias as a string.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getAlias(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the alias.\n   *\n   * @deprecated Deprecated since 6.7.0  - to be removed in a future version of the plugin - please use setNamedUser\n   * @param {string} alias string\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAlias(alias: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if quiet time is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if quiet time is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isQuietTimeEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables quiet time.\n   *\n   * @param {boolean} enabled true to enable quiet time, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setQuietTimeEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if the device is currently in quiet time.\n   *\n   * @param {function(inQuietTime)} success Success callback.\n   * @param {boolean} success.inQuietTime Flag indicating if quiet time is currently in effect.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isInQuietTime(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the quiet time as an object with the following:\n   * \"startHour\": Number,\n   * \"startMinute\": Number,\n   * \"endHour\": Number,\n   * \"endMinute\": Number\n   *\n   * @param {function(quietTime)} success The function to call on success.\n   * @param {object} success.quietTime The quietTime object represents a timespan during\n   *        which notifications should be silenced.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getQuietTime(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the quiet time.\n   *\n   * @param {number} startHour for quiet time.\n   * @param {number} startMinute for quiet time.\n   * @param {number} endHour for quiet time.\n   * @param {number} endMinute for quiet time.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setQuietTime(startHour: number, startMinute: number, endHour: number, endMinute: number): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables analytics.\n   *\n   * Disabling analytics will delete any locally stored events\n   * and prevent any events from uploading. Features that depend on analytics being\n   * enabled may not work properly if it's disabled (reports, region triggers,\n   * location segmentation, push to local time).\n   *\n   * @param {boolean} enabled true to enable analytics, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAnalyticsEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if analytics is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if analytics is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isAnalyticsEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the named user ID.\n   *\n   * @param {function(namedUser)} success The function to call on success.\n   * @param {string} success.namedUser The named user ID as a string.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getNamedUser(): Promise<string> {\n    return;\n  }\n\n  /**\n   * Sets the named user ID.\n   *\n   * @param {string} namedUser identifier string.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setNamedUser(namedUser: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Runs an Urban Airship action.\n   *\n   * @param {string} actionName action as a string.\n   * @param {*} actionValue\n   * @param {function(result)} [success] The function to call on success.\n   * @param {object} success.result The result's value.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  runAction(actionName: string, actionValue: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the named user tag groups.\n   */\n  @Cordova({ sync: true })\n  editNamedUserTagGroups(): TagGroupEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel tag groups.\n   */\n  @Cordova({ sync: true })\n  editChannelTagGroups(): TagGroupEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel attributes.\n   */\n  @Cordova({ sync: true })\n  editChannelAttributes(): AttributesEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the named user attributes.\n   */\n  @Cordova({ sync: true })\n  editNamedUserAttributes(): AttributesEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel subscription lists.\n   *\n   * @returns {ChannelSubscriptionListEditor} A subscription list editor instance.\n   * @since 13.3.0\n   */\n  @Cordova({ sync: true })\n  editChannelSubscriptionLists(): ChannelSubscriptionListEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the contact subscription lists.\n   *\n   * @returns {ContactSubscriptionListEditor} A subscription list editor instance.\n   * @since 13.3.0\n   */\n  @Cordova({ sync: true })\n  editContactSubscriptionLists(): ContactSubscriptionListEditor {\n    return;\n  }\n\n  /**\n   * Returns the current set of subscription lists for the current channel,\n   * optionally applying pending subscription list changes that will be applied during the next channel update.\n   * An empty set indicates that this contact is not subscribed to any lists.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova({\n    successIndex: 0,\n    errorIndex: 1,\n  })\n  getChannelSubscriptionLists(): Promise<string[]> {\n    return;\n  }\n\n  /**\n   * Returns the current set of subscription lists for the current contact,\n   * optionally applying pending subscription list changes that will be applied during the next contact update.\n   * An empty set indicates that this contact is not subscribed to any lists.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova({\n    successIndex: 0,\n    errorIndex: 1,\n  })\n  getContactSubscriptionLists(): Promise<string[]> {\n    return;\n  }\n\n  /**\n   * Sets an associated identifier for the Connect data stream.\n   *\n   * @param key Custom key for identifier.\n   * @param identifier The identifier value.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAssociatedIdentifier(key: string, identifier: string): Promise<void> {\n    return;\n  }\n\n  // Location\n\n  /**\n   * Enables or disables Urban Airship location services.\n   *\n   * @param {boolean} enabled true to enable location, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setLocationEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if location is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if location is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 8.0\n   */\n  @Cordova()\n  isLocationEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables background location.\n   *\n   * @param {boolean} enabled true to enable background location, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 8.0\n   */\n  @Cordova()\n  setBackgroundLocationEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if background location is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if background location updates are enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 8.0\n   */\n  @Cordova()\n  isBackgroundLocationEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Displays the message center.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  displayMessageCenter(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Dismiss the message center.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  dismissMessageCenter(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Dismiss the inbox message.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  dismissInboxMessage(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Dismiss the inbox message in the overlay.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 10.0\n   */\n  @Cordova()\n  dismissOverlayInboxMessage(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Gets the array of inbox messages. Each message will have the following properties:\n   * \"id\": string - The messages ID. Needed to display, mark as read, or delete the message.\n   * \"title\": string - The message title.\n   * \"sentDate\": number - The message sent date in milliseconds.\n   * \"listIconUrl\": string, optional - The icon url for the message.\n   * \"isRead\": boolean - The unread/read status of the message.\n   * \"extras\": object - String to String map of any message extras.\n   *\n   * @param {function(messages)} success The function to call on success.\n   * @param {Array} success.messages The array of inbox messages.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getInboxMessages(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Marks an inbox message read.\n   *\n   * @param {string} messageId The ID of the message to mark as read.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  markInboxMessageRead(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Deletes an inbox message.\n   *\n   * @param {string} messageId The ID of the message to delete.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  deleteInboxMessage(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Displays the inbox message using a full screen view.\n   *\n   * @param {string} messageId The ID of the message to display.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  displayInboxMessage(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Forces the inbox to refresh. This is normally not needed as the inbox\n   * will automatically refresh on foreground or when a push arrives thats\n   * associated with a message, but it can be useful when providing a refresh\n   * button for the message listing.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  refreshInbox(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Displays the inbox message using an overlay display.\n   *\n   * @param {string} messageId The ID of the message to display.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 10.0\n   */\n  @Cordova()\n  overlayInboxMessage(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Clears a notification by identifier.\n   *\n   * @param {string} identifier The notification identifier.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   */\n  @Cordova()\n  clearNotification(identifier: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Clears all notifications posted by the application.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  clearNotifications(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Gets currently active notifications.\n   *\n   * Note: On Android this functionality is only supported on Android M or higher.\n   *\n   * @param {function(messages)} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   */\n  @Cordova()\n  getActiveNotifications(): Promise<any> {\n    return;\n  }\n\n  // iOS only\n\n  /**\n   * Enables or disables auto badge. Defaults to `NO`.\n   *\n   * @param {boolean} enabled true to enable auto badge, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAutobadgeEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the badge number.\n   *\n   * @param count number specified badge to set.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setBadgeNumber(count: number): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the current badge number.\n   *\n   * @param {function(badgeNumber)} success The function to call on success.\n   * @param {int} success.badgeNumber The current application badge number.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getBadgeNumber(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Clears the badge.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  resetBadge(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the iOS notification types. Specify the combination of\n   * badges, sound and alerts that are desired.\n   *\n   * @param types specified notification types.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setNotificationTypes(types: NotificationType): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the iOS presentation options. Specify the combination of\n   * badges, sound and alerts that are desired.\n   *\n   * @param options types specified presentation options.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setPresentationOptions(options: PresentationOptions): Promise<any> {\n    return;\n  }\n\n  // Android only\n\n  /**\n   * Checks if notification sound is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if sound is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isSoundEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables notification sound.\n   *\n   * @param {boolean} enabled true to enable sound, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setSoundEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if notification vibration is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if vibration is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isVibrateEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables notification vibration.\n   *\n   * @param {boolean} enabled true to enable vibration, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setVibrateEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Adds a custom event.\n   *\n   * @param {object} event The custom event object.\n   * @param {string} event.name The event's name.\n   * @param {number} [event.value] The event's value.\n   * @param {string} [event.transactionId] The event's transaction ID.\n   * @param {object} [event.properties] The event's properties. Only numbers, booleans, strings, and array of strings are supported.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  addCustomEvent(event: object): Promise<any> {\n    return;\n  }\n\n  /**\n   * Initiates screen tracking for a specific app screen, must be called once per tracked screen.\n   *\n   * @param {string} screen The screen's string identifier.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 11.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  trackScreen(screen: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables features, adding them to the set of currently enabled features.\n   *\n   * @param {Array<string>} features The features to enable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  enableFeature(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Disables features, removing them from the set of currently enabled features.\n   *\n   * @param {Array<string>} features The features to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  disableFeature(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the current enabled features, replacing any currently enabled features with the given set.\n   *\n   * @param {Array<string>} features The features to set as enabled.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  setEnabledFeatures(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Gets the current enabled features.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 0,\n    errorIndex: 1,\n  })\n  getEnabledFeatures(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if all of the given features are enabled.\n   *\n   * @param {Array<string>} features The features to check.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  isFeatureEnabled(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the configuration of the Preference Center with the given ID trough a callback method.\n   *\n   * @param {string} preferenceCenterId The preference center ID.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.3.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  getPreferenceCenterConfig(preferenceCenterId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Opens the Preference Center with the given preferenceCenterId.\n   *\n   * @param {string} prenferenceCenterId The preference center ID.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  openPreferenceCenter(prenferenceCenterId: string): Promise<any> {\n    return;\n  }\n}\n"]}
+        }], propDecorators: { onDeepLink: [], onRegistration: [], onInboxUpdated: [], onShowInbox: [], onPushReceived: [], onNotificationOpened: [], onNotificationOptInStatus: [], reattach: [], takeOff: [], setAndroidNotificationConfig: [], setAutoLaunchDefaultMessageCenter: [], setUserNotificationsEnabled: [], isUserNotificationsEnabled: [], isAppNotificationsEnabled: [], getChannelID: [], getLaunchNotification: [], getDeepLink: [], getTags: [], setTags: [], getAlias: [], setAlias: [], isQuietTimeEnabled: [], setQuietTimeEnabled: [], isInQuietTime: [], getQuietTime: [], setQuietTime: [], setAnalyticsEnabled: [], isAnalyticsEnabled: [], getNamedUser: [], setNamedUser: [], runAction: [], editNamedUserTagGroups: [], editChannelTagGroups: [], editChannelAttributes: [], editNamedUserAttributes: [], editChannelSubscriptionLists: [], editContactSubscriptionLists: [], getChannelSubscriptionLists: [], getContactSubscriptionLists: [], setAssociatedIdentifier: [], setLocationEnabled: [], isLocationEnabled: [], setBackgroundLocationEnabled: [], isBackgroundLocationEnabled: [], displayMessageCenter: [], dismissMessageCenter: [], dismissInboxMessage: [], dismissOverlayInboxMessage: [], getInboxMessages: [], markInboxMessageRead: [], deleteInboxMessage: [], displayInboxMessage: [], refreshInbox: [], overlayInboxMessage: [], clearNotification: [], clearNotifications: [], getActiveNotifications: [], setAutobadgeEnabled: [], setBadgeNumber: [], getBadgeNumber: [], resetBadge: [], setNotificationTypes: [], setPresentationOptions: [], isSoundEnabled: [], setSoundEnabled: [], isVibrateEnabled: [], setVibrateEnabled: [], addCustomEvent: [], trackScreen: [], enableFeature: [], disableFeature: [], getEnabledFeatures: [], isFeatureEnabled: [], getPreferenceCenterConfig: [], openPreferenceCenter: [], setCurrentLocale: [], getCurrentLocale: [], clearLocale: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/@awesome-cordova-plugins/plugins/urbanairship/ngx/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,uCAA+C,MAAM,+BAA+B,CAAC;AAC5F,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;;AAwClC;;;;;GAKG;AACH,MAAM,CAAN,IAAY,gBAKX;AALD,WAAY,gBAAgB;IAC1B,uDAAQ,CAAA;IACR,yDAAS,CAAA;IACT,yDAAS,CAAA;IACT,yDAAS,CAAA;AACX,CAAC,EALW,gBAAgB,KAAhB,gBAAgB,QAK3B;AAED;;;;;GAKG;AACH,MAAM,CAAN,IAAY,mBAKX;AALD,WAAY,mBAAmB;IAC7B,6DAAQ,CAAA;IACR,+DAAS,CAAA;IACT,+DAAS,CAAA;IACT,+DAAS,CAAA;AACX,CAAC,EALW,mBAAmB,KAAnB,mBAAmB,QAK9B;;IA+BiC,gCAA0B;;;;IAa1D,iCAAU;IAkBV,qCAAc;IAcd,qCAAc;IAiBd,kCAAW;IAsBX,qCAAc;IAqBd,2CAAoB;IAuBpB,gDAAyB;IAUzB,+BAAQ;IAsBR,8BAAO,aAAC,MAAW;IAanB,mDAA4B,aAAC,MAAW;IAcxC,wDAAiC,aAAC,OAAgB;IAalD,kDAA2B,aAAC,OAAgB;IAa5C,iDAA0B;IAc1B,gDAAyB;IAazB,mCAAY;IAiBZ,4CAAqB,aAAC,KAAc;IAcpC,kCAAW,aAAC,KAAc;IAa1B,8BAAO;IAaP,8BAAO,aAAC,IAAc;IActB,+BAAQ;IAcR,+BAAQ,aAAC,KAAa;IAatB,yCAAkB;IAalB,0CAAmB,aAAC,OAAgB;IAapC,oCAAa;IAkBb,mCAAY;IAgBZ,mCAAY,aAAC,SAAiB,EAAE,WAAmB,EAAE,OAAe,EAAE,SAAiB;IAkBvF,0CAAmB,aAAC,OAAgB;IAapC,yCAAkB;IAalB,mCAAY;IAaZ,mCAAY,aAAC,SAAiB;IAe9B,gCAAS,aAAC,UAAkB,EAAE,WAAgB;IAQ9C,6CAAsB;IAQtB,2CAAoB;IAQpB,4CAAqB;IAQrB,8CAAuB;IAWvB,mDAA4B;IAW5B,mDAA4B;IAgB5B,kDAA2B;IAgB3B,kDAA2B;IAc3B,8CAAuB,aAAC,GAAW,EAAE,UAAkB;IAevD,yCAAkB,aAAC,OAAgB;IAcnC,wCAAiB;IAcjB,mDAA4B,aAAC,OAAgB;IAc7C,kDAA2B;IAY3B,2CAAoB;IAYpB,2CAAoB;IAYpB,0CAAmB;IAanB,iDAA0B;IAmB1B,uCAAgB;IAahB,2CAAoB,aAAC,SAAiB;IAatC,yCAAkB,aAAC,SAAiB;IAapC,0CAAmB,aAAC,SAAiB;IAerC,mCAAY;IAcZ,0CAAmB,aAAC,SAAiB;IAYrC,wCAAiB,aAAC,UAAkB;IAYpC,yCAAkB;IAalB,6CAAsB;IAetB,0CAAmB,aAAC,OAAgB;IAapC,qCAAc,aAAC,KAAa;IAa5B,qCAAc;IAYd,iCAAU;IAcV,2CAAoB,aAAC,KAAuB;IAc5C,6CAAsB,aAAC,OAA4B;IAenD,qCAAc;IAad,sCAAe,aAAC,OAAgB;IAahC,uCAAgB;IAahB,wCAAiB,aAAC,OAAgB;IAiBlC,qCAAc,aAAC,KAAa;IAiB5B,kCAAW,aAAC,MAAc;IAiB1B,oCAAa,aAAC,QAAkB;IAiBhC,qCAAc,aAAC,QAAkB;IAIjC;;;;;;;;OAQG;IACH,yCAAkB,GAAlB,UAAmB,QAAkB;QACnC,OAAO;IACT,CAAC;IAcD,yCAAkB;IAiBlB,uCAAgB,aAAC,QAAkB;IAiBnC,gDAAyB,aAAC,kBAA0B;IAiBpD,2CAAoB,aAAC,mBAA2B;IAchD,uCAAgB,aAAC,MAAc;IAc/B,uCAAgB;IAahB,kCAAW;8GApmCA,YAAY;kHAAZ,YAAY;;;;;;;IAAZ,YAAY,kBAAZ,YAAY;uBAjGzB;EAiGkC,0BAA0B;SAA/C,YAAY;4FAAZ,YAAY;kBADxB,UAAU;8BAcT,UAAU,MAkBV,cAAc,MAcd,cAAc,MAiBd,WAAW,MAsBX,cAAc,MAqBd,oBAAoB,MAuBpB,yBAAyB,MAUzB,QAAQ,MAsBR,OAAO,MAaP,4BAA4B,MAc5B,iCAAiC,MAajC,2BAA2B,MAa3B,0BAA0B,MAc1B,yBAAyB,MAazB,YAAY,MAiBZ,qBAAqB,MAcrB,WAAW,MAaX,OAAO,MAaP,OAAO,MAcP,QAAQ,MAcR,QAAQ,MAaR,kBAAkB,MAalB,mBAAmB,MAanB,aAAa,MAkBb,YAAY,MAgBZ,YAAY,MAkBZ,mBAAmB,MAanB,kBAAkB,MAalB,YAAY,MAaZ,YAAY,MAeZ,SAAS,MAQT,sBAAsB,MAQtB,oBAAoB,MAQpB,qBAAqB,MAQrB,uBAAuB,MAWvB,4BAA4B,MAW5B,4BAA4B,MAgB5B,2BAA2B,MAgB3B,2BAA2B,MAc3B,uBAAuB,MAevB,kBAAkB,MAclB,iBAAiB,MAcjB,4BAA4B,MAc5B,2BAA2B,MAY3B,oBAAoB,MAYpB,oBAAoB,MAYpB,mBAAmB,MAanB,0BAA0B,MAmB1B,gBAAgB,MAahB,oBAAoB,MAapB,kBAAkB,MAalB,mBAAmB,MAenB,YAAY,MAcZ,mBAAmB,MAYnB,iBAAiB,MAYjB,kBAAkB,MAalB,sBAAsB,MAetB,mBAAmB,MAanB,cAAc,MAad,cAAc,MAYd,UAAU,MAcV,oBAAoB,MAcpB,sBAAsB,MAetB,cAAc,MAad,eAAe,MAaf,gBAAgB,MAahB,iBAAiB,MAiBjB,cAAc,MAiBd,WAAW,MAiBX,aAAa,MAiBb,cAAc,MA6Bd,kBAAkB,MAiBlB,gBAAgB,MAiBhB,yBAAyB,MAiBzB,oBAAoB,MAcpB,gBAAgB,MAchB,gBAAgB,MAahB,WAAW","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Plugin, Cordova, AwesomeCordovaNativePlugin } from '@awesome-cordova-plugins/core';\nimport { Observable } from 'rxjs';\n\n/**\n * Interface for UAirship Tag Editor\n */\nexport interface TagGroupEditor {\n  addTags(tagGroup: string, tags: string[]): TagGroupEditor;\n  removeTags(tagGroup: string, tags: string[]): TagGroupEditor;\n  apply(success: () => void, failure: (message: string) => void): TagGroupEditor;\n}\n\n/**\n * Interface for UAirship Attributes Editor\n */\nexport interface AttributesEditor {\n  setAttribute(name: string, value: string | number | boolean | Date): AttributesEditor;\n  removeAttribute(name: string): AttributesEditor;\n  apply(success: () => void, failure: (message: string) => void): AttributesEditor;\n}\n\n/**\n * Interface for UAirship ChannelSubscriptionList Editor\n */\nexport interface ChannelSubscriptionListEditor {\n  subscribe(subscriptionListID: string): ChannelSubscriptionListEditor;\n  unsubscribe(subscriptionListID: string): ChannelSubscriptionListEditor;\n  apply(success: () => void, failure: (message: string) => void): ChannelSubscriptionListEditor;\n}\n\nexport type ContactSubscriptionScope = 'app' | 'email' | 'push' | 'sms';\n\n/**\n * Interface for UAirship ContactSubscriptionList Editor\n */\nexport interface ContactSubscriptionListEditor {\n  subscribe(subscriptionListID: string, contactScope: ContactSubscriptionScope): ContactSubscriptionListEditor;\n  unsubscribe(subscriptionListID: string, contactScope: ContactSubscriptionScope): ContactSubscriptionListEditor;\n  apply(success: () => void, failure: (message: string) => void): ContactSubscriptionListEditor;\n}\n\n/**\n * Enum for notification types.\n *\n * @readonly\n * @enum {number}\n */\nexport enum NotificationType {\n  none = 0,\n  badge = 1,\n  sound = 2,\n  alert = 4,\n}\n\n/**\n * Enum for presentation options.\n *\n * @readonly\n * @enum {number}\n */\nexport enum PresentationOptions {\n  none = 0,\n  badge = 1,\n  sound = 2,\n  alert = 4,\n}\n\n/**\n * @name UrbanAirShip\n * @description\n * This plugin does something\n * @usage\n * ```typescript\n * import { UrbanAirShip } from '@awesome-cordova-plugins/urbanairship/ngx';\n *\n *\n * constructor(private urbanAirShip: UrbanAirShip) { }\n *\n * ...\n *\n *\n * this.urbanAirShip.takeOff(config)\n *   .then((res: any) => console.log(res))\n *   .catch((error: any) => console.error(error));\n *\n * ```\n */\n@Plugin({\n  pluginName: 'UrbanAirShip',\n  plugin: 'urbanairship-cordova',\n  pluginRef: 'window.UAirship',\n  repo: 'https://www.npmjs.com/package/urbanairship-cordova',\n  install: 'ionic cordova plugin add urbanairship-cordova',\n  platforms: ['Android', 'iOS'],\n})\n@Injectable()\nexport class UrbanAirShip extends AwesomeCordovaNativePlugin {\n  /**\n   * Event fired when a new deep link is received.\n   *\n   * @event deep_link\n   * @type {object}\n   * @param {string} [deepLink] The deep link.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.deep_link',\n    element: 'document',\n  })\n  onDeepLink(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when a channel registration occurs.\n   *\n   * @event registration\n   * @type {object}\n   * @param {string} [channelID] The channel ID.\n   * @param {string} [registrationToken] The deviceToken on iOS, and the FCM/ADM token on Android.\n   * @param {string} [error] Error message if an error occurred.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.registration',\n    element: 'document',\n  })\n  onRegistration(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when the inbox is updated.\n   *\n   * @event inbox_updated\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.inbox_updated',\n    element: 'document',\n  })\n  onInboxUpdated(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when the inbox needs to be displayed. This event is only emitted if auto\n   * launch message center is disabled.\n   *\n   * @event show_inbox\n   * @type {object}\n   * @param {string} [messageId] The optional message ID.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.show_inbox',\n    element: 'document',\n  })\n  onShowInbox(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when a push is received.\n   *\n   * @event push\n   * @type {object}\n   * @param {string} message The push alert message.\n   * @param {string} title The push title.\n   * @param {string} subtitle The push subtitle.\n   * @param {object} extras Any push extras.\n   * @param {object} aps The raw aps dictionary (iOS only)\n   * @param {number} [notification_id] The Android notification ID. Deprecated in favor of notificationId.\n   * @param {string} [notificationId] The notification ID.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.push',\n    element: 'document',\n  })\n  onPushReceived(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when notification opened.\n   *\n   * @event notification_opened\n   * @type {object}\n   * @param {string} message The push alert message.\n   * @param {object} extras Any push extras.\n   * @param {number} [notification_id] The Android notification ID. Deprecated in favor of notificationId.\n   * @param {string} [notificationId] The notification ID.\n   * @param {string} [actionID] The ID of the notification action button if available.\n   * @param {boolean} isForeground Will always be true if the user taps the main notification. Otherwise its defined by the notification action button.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.notification_opened',\n    element: 'document',\n  })\n  onNotificationOpened(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Event fired when the user notification opt-in status changes.\n   *\n   * @event notification_opt_in_status\n   * @type {object}\n   * @param {boolean} optIn If the user is opted in or not to user notifications.\n   * @param {object} [authorizedNotificationSettings] iOS only. A map of authorized settings.\n   * @param {boolean} authorizedNotificationSettings.alert If alerts are authorized.\n   * @param {boolean} authorizedNotificationSettings.sound If sounds are authorized.\n   * @param {boolean} authorizedNotificationSettings.badge If badges are authorized.\n   * @param {boolean} authorizedNotificationSettings.carPlay If car play is authorized.\n   * @param {boolean} authorizedNotificationSettings.lockScreen If the lock screen is authorized.\n   * @param {boolean} authorizedNotificationSettings.notificationCenter If the notification center is authorized.\n   */\n  @Cordova({\n    eventObservable: true,\n    event: 'urbanairship.notification_opt_in_status',\n    element: 'document',\n  })\n  onNotificationOptInStatus(): Observable<any> {\n    return;\n  }\n\n  /**\n   * Re-attaches document event listeners in this webview\n   */\n  @Cordova({\n    sync: true,\n  })\n  reattach(): void {\n    return;\n  }\n\n  /**\n   * Initailizes Urban Airship.\n   *\n   * The plugin will automatically call takeOff during the next app init in\n   * order to properly handle incoming push. If takeOff is called multiple times\n   * in a session, or if the config is different than the previous sesssion, the\n   * new config will not be used until the next app start.\n   *\n   * @param {object}  config The Urban Airship config.\n   * @param {string}  config.site Sets the cloud site, must be either EU or US.\n   * @param {object}  config.development The Urban Airship development config.\n   * @param {string}  config.development.appKey The development appKey.\n   * @param {string}  config.development.appSecret The development appSecret.\n   * @param {object}  config.production The Urban Airship production config.\n   * @param {string}  config.production.appKey The production appKey.\n   * @param {string}  config.production.appSecret The production appSecret.\n   */\n  @Cordova()\n  takeOff(config: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the Android notification config. Values not set will fallback to any values set in the config.xml.\n   *\n   * @param {object}  config The notification config.\n   * @param {string}  [config.icon] The name of the drawable resource to use as the notification icon.\n   * @param {string}  [config.largeIcon] The name of the drawable resource to use as the notification large icon.\n   * @param {string}  [config.accentColor] The notification accent color. Format is #AARRGGBB.\n   */\n  @Cordova()\n  setAndroidNotificationConfig(config: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the default behavior when the message center is launched from a push\n   * notification. If set to false the message center must be manually launched.\n   *\n   * @param {boolean} enabled true to automatically launch the default message center, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAutoLaunchDefaultMessageCenter(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables user notifications.\n   *\n   * @param {boolean} enabled true to enable notifications, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setUserNotificationsEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if user notifications are enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if user notifications is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isUserNotificationsEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if app notifications are enabled or not. Its possible to have `userNotificationsEnabled`\n   * but app notifications being disabled if the user opted out of notifications.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if app notifications is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isAppNotificationsEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the channel ID.\n   *\n   * @param {function(ID)} success The function to call on success.\n   * @param {string} success.ID The channel ID string\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getChannelID(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the last notification that launched the application.\n   *\n   * @param {boolean} clear true to clear the notification.\n   * @param {function(push)} success The function to call on success.\n   * @param {object} success.push The push message object containing data associated with a push notification.\n   * @param {string} success.push.message The push alert message.\n   * @param {object} success.push.extras Any push extras.\n   * @param {number} [success.push.notification_id] The Android notification ID.\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getLaunchNotification(clear: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the last received deep link.\n   *\n   * @param {boolean} clear true to clear the deep link.\n   * @param {function(push)} success The function to call on success.\n   * @param {string} success.deepLink The deep link.\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getDeepLink(clear: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the tags as an array.\n   *\n   * @param {function(tags)} success The function to call on success.\n   * @param {Array} success.tags The tags as an array.\n   * @param {failureCallback} [failure] The function to call on failure.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getTags(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the tags.\n   *\n   * @param {Array} tags an array of strings.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setTags(tags: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the alias.\n   *\n   * @deprecated Deprecated since 6.7.0 - to be removed in a future version of the plugin - please use getNamedUser\n   * @param {function(currentAlias)} success The function to call on success.\n   * @param {string} success.currentAlias The alias as a string.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getAlias(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the alias.\n   *\n   * @deprecated Deprecated since 6.7.0  - to be removed in a future version of the plugin - please use setNamedUser\n   * @param {string} alias string\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAlias(alias: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if quiet time is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if quiet time is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isQuietTimeEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables quiet time.\n   *\n   * @param {boolean} enabled true to enable quiet time, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setQuietTimeEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if the device is currently in quiet time.\n   *\n   * @param {function(inQuietTime)} success Success callback.\n   * @param {boolean} success.inQuietTime Flag indicating if quiet time is currently in effect.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isInQuietTime(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the quiet time as an object with the following:\n   * \"startHour\": Number,\n   * \"startMinute\": Number,\n   * \"endHour\": Number,\n   * \"endMinute\": Number\n   *\n   * @param {function(quietTime)} success The function to call on success.\n   * @param {object} success.quietTime The quietTime object represents a timespan during\n   *        which notifications should be silenced.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getQuietTime(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the quiet time.\n   *\n   * @param {number} startHour for quiet time.\n   * @param {number} startMinute for quiet time.\n   * @param {number} endHour for quiet time.\n   * @param {number} endMinute for quiet time.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setQuietTime(startHour: number, startMinute: number, endHour: number, endMinute: number): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables analytics.\n   *\n   * Disabling analytics will delete any locally stored events\n   * and prevent any events from uploading. Features that depend on analytics being\n   * enabled may not work properly if it's disabled (reports, region triggers,\n   * location segmentation, push to local time).\n   *\n   * @param {boolean} enabled true to enable analytics, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAnalyticsEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if analytics is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if analytics is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isAnalyticsEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the named user ID.\n   *\n   * @param {function(namedUser)} success The function to call on success.\n   * @param {string} success.namedUser The named user ID as a string.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getNamedUser(): Promise<string> {\n    return;\n  }\n\n  /**\n   * Sets the named user ID.\n   *\n   * @param {string} namedUser identifier string.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setNamedUser(namedUser: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Runs an Urban Airship action.\n   *\n   * @param {string} actionName action as a string.\n   * @param {*} actionValue\n   * @param {function(result)} [success] The function to call on success.\n   * @param {object} success.result The result's value.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  runAction(actionName: string, actionValue: any): Promise<any> {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the named user tag groups.\n   */\n  @Cordova({ sync: true })\n  editNamedUserTagGroups(): TagGroupEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel tag groups.\n   */\n  @Cordova({ sync: true })\n  editChannelTagGroups(): TagGroupEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel attributes.\n   */\n  @Cordova({ sync: true })\n  editChannelAttributes(): AttributesEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the named user attributes.\n   */\n  @Cordova({ sync: true })\n  editNamedUserAttributes(): AttributesEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel subscription lists.\n   *\n   * @returns {ChannelSubscriptionListEditor} A subscription list editor instance.\n   * @since 13.3.0\n   */\n  @Cordova({ sync: true })\n  editChannelSubscriptionLists(): ChannelSubscriptionListEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the contact subscription lists.\n   *\n   * @returns {ContactSubscriptionListEditor} A subscription list editor instance.\n   * @since 13.3.0\n   */\n  @Cordova({ sync: true })\n  editContactSubscriptionLists(): ContactSubscriptionListEditor {\n    return;\n  }\n\n  /**\n   * Returns the current set of subscription lists for the current channel,\n   * optionally applying pending subscription list changes that will be applied during the next channel update.\n   * An empty set indicates that this contact is not subscribed to any lists.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova({\n    successIndex: 0,\n    errorIndex: 1,\n  })\n  getChannelSubscriptionLists(): Promise<string[]> {\n    return;\n  }\n\n  /**\n   * Returns the current set of subscription lists for the current contact,\n   * optionally applying pending subscription list changes that will be applied during the next contact update.\n   * An empty set indicates that this contact is not subscribed to any lists.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova({\n    successIndex: 0,\n    errorIndex: 1,\n  })\n  getContactSubscriptionLists(): Promise<string[]> {\n    return;\n  }\n\n  /**\n   * Sets an associated identifier for the Connect data stream.\n   *\n   * @param key Custom key for identifier.\n   * @param identifier The identifier value.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAssociatedIdentifier(key: string, identifier: string): Promise<void> {\n    return;\n  }\n\n  // Location\n\n  /**\n   * Enables or disables Urban Airship location services.\n   *\n   * @param {boolean} enabled true to enable location, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setLocationEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if location is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if location is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 8.0\n   */\n  @Cordova()\n  isLocationEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables background location.\n   *\n   * @param {boolean} enabled true to enable background location, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 8.0\n   */\n  @Cordova()\n  setBackgroundLocationEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if background location is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if background location updates are enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 8.0\n   */\n  @Cordova()\n  isBackgroundLocationEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Displays the message center.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  displayMessageCenter(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Dismiss the message center.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  dismissMessageCenter(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Dismiss the inbox message.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  dismissInboxMessage(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Dismiss the inbox message in the overlay.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 10.0\n   */\n  @Cordova()\n  dismissOverlayInboxMessage(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Gets the array of inbox messages. Each message will have the following properties:\n   * \"id\": string - The messages ID. Needed to display, mark as read, or delete the message.\n   * \"title\": string - The message title.\n   * \"sentDate\": number - The message sent date in milliseconds.\n   * \"listIconUrl\": string, optional - The icon url for the message.\n   * \"isRead\": boolean - The unread/read status of the message.\n   * \"extras\": object - String to String map of any message extras.\n   *\n   * @param {function(messages)} success The function to call on success.\n   * @param {Array} success.messages The array of inbox messages.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getInboxMessages(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Marks an inbox message read.\n   *\n   * @param {string} messageId The ID of the message to mark as read.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  markInboxMessageRead(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Deletes an inbox message.\n   *\n   * @param {string} messageId The ID of the message to delete.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  deleteInboxMessage(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Displays the inbox message using a full screen view.\n   *\n   * @param {string} messageId The ID of the message to display.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  displayInboxMessage(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Forces the inbox to refresh. This is normally not needed as the inbox\n   * will automatically refresh on foreground or when a push arrives thats\n   * associated with a message, but it can be useful when providing a refresh\n   * button for the message listing.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  refreshInbox(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Displays the inbox message using an overlay display.\n   *\n   * @param {string} messageId The ID of the message to display.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @deprecated removed in version 10.0\n   */\n  @Cordova()\n  overlayInboxMessage(messageId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Clears a notification by identifier.\n   *\n   * @param {string} identifier The notification identifier.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   */\n  @Cordova()\n  clearNotification(identifier: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Clears all notifications posted by the application.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  clearNotifications(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Gets currently active notifications.\n   *\n   * Note: On Android this functionality is only supported on Android M or higher.\n   *\n   * @param {function(messages)} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   */\n  @Cordova()\n  getActiveNotifications(): Promise<any> {\n    return;\n  }\n\n  // iOS only\n\n  /**\n   * Enables or disables auto badge. Defaults to `NO`.\n   *\n   * @param {boolean} enabled true to enable auto badge, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setAutobadgeEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the badge number.\n   *\n   * @param count number specified badge to set.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setBadgeNumber(count: number): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the current badge number.\n   *\n   * @param {function(badgeNumber)} success The function to call on success.\n   * @param {int} success.badgeNumber The current application badge number.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  getBadgeNumber(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Clears the badge.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  resetBadge(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the iOS notification types. Specify the combination of\n   * badges, sound and alerts that are desired.\n   *\n   * @param types specified notification types.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setNotificationTypes(types: NotificationType): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the iOS presentation options. Specify the combination of\n   * badges, sound and alerts that are desired.\n   *\n   * @param options types specified presentation options.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setPresentationOptions(options: PresentationOptions): Promise<any> {\n    return;\n  }\n\n  // Android only\n\n  /**\n   * Checks if notification sound is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if sound is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isSoundEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables notification sound.\n   *\n   * @param {boolean} enabled true to enable sound, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setSoundEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if notification vibration is enabled or not.\n   *\n   * @param {function(enabled)} success Success callback.\n   * @param {boolean} success.enabled Flag indicating if vibration is enabled or not.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  isVibrateEnabled(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables or disables notification vibration.\n   *\n   * @param {boolean} enabled true to enable vibration, false to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  setVibrateEnabled(enabled: boolean): Promise<any> {\n    return;\n  }\n\n  /**\n   * Adds a custom event.\n   *\n   * @param {object} event The custom event object.\n   * @param {string} event.name The event's name.\n   * @param {number} [event.value] The event's value.\n   * @param {string} [event.transactionId] The event's transaction ID.\n   * @param {object} [event.properties] The event's properties. Only numbers, booleans, strings, and array of strings are supported.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   */\n  @Cordova()\n  addCustomEvent(event: object): Promise<any> {\n    return;\n  }\n\n  /**\n   * Initiates screen tracking for a specific app screen, must be called once per tracked screen.\n   *\n   * @param {string} screen The screen's string identifier.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 11.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  trackScreen(screen: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Enables features, adding them to the set of currently enabled features.\n   *\n   * @param {Array<string>} features The features to enable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  enableFeature(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Disables features, removing them from the set of currently enabled features.\n   *\n   * @param {Array<string>} features The features to disable.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  disableFeature(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Sets the current enabled features, replacing any currently enabled features with the given set.\n   *\n   * @param {Array<string>} features The features to set as enabled.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  setEnabledFeatures(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Gets the current enabled features.\n   *\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 0,\n    errorIndex: 1,\n  })\n  getEnabledFeatures(): Promise<any> {\n    return;\n  }\n\n  /**\n   * Checks if all of the given features are enabled.\n   *\n   * @param {Array<string>} features The features to check.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  isFeatureEnabled(features: string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the configuration of the Preference Center with the given ID trough a callback method.\n   *\n   * @param {string} preferenceCenterId The preference center ID.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.3.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  getPreferenceCenterConfig(preferenceCenterId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Opens the Preference Center with the given preferenceCenterId.\n   *\n   * @param {string} prenferenceCenterId The preference center ID.\n   * @param {Function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 13.0.0\n   */\n  @Cordova({\n    successIndex: 1,\n    errorIndex: 2,\n  })\n  openPreferenceCenter(prenferenceCenterId: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Overrides the locale setting.\n   *\n   * @param {string} locale language and optional country code.\n   * @param {function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 14.3.0\n   */\n  @Cordova()\n  setCurrentLocale(locale: string): Promise<any> {\n    return;\n  }\n\n  /**\n   * Returns the currently set locale.\n   *\n   * @param {function(locale)} [success] Success callback.\n   * @param {string} success.locale The locale as a string.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 14.3.0\n   */\n  @Cordova()\n  getCurrentLocale(): Promise<string> {\n    return;\n  }\n\n  /**\n   * Resets the current locale.\n   *\n   * @param {function} [success] Success callback.\n   * @param {function(message)} [failure] Failure callback.\n   * @param {string} failure.message The error message.\n   * @since 14.3.0\n   */\n  @Cordova()\n  clearLocale(): Promise<any> {\n    return;\n  }\n}\n"]}

package/ngx/package.json

@@ -1 +1 @@
-{"description":"Awesome Cordova Plugins - Native plugins for ionic apps","main":"bundle.js","module":"index.js","typings":"index.d.ts","author":"ionic","license":"MIT","repository":{"type":"git","url":"https://github.com/danielsogl/awesome-cordova-plugins.git"},"name":"@awesome-cordova-plugins/urbanairship","dependencies":{"@types/cordova":"latest"},"peerDependencies":{"rxjs":"^5.5.0 || ^6.5.0 || ^7.3.0","@awesome-cordova-plugins/core":"^6.0.1"},"version":"6.2.0"}
+{"description":"Awesome Cordova Plugins - Native plugins for ionic apps","main":"bundle.js","module":"index.js","typings":"index.d.ts","author":"ionic","license":"MIT","repository":{"type":"git","url":"https://github.com/danielsogl/awesome-cordova-plugins.git"},"name":"@awesome-cordova-plugins/urbanairship","dependencies":{"@types/cordova":"latest"},"peerDependencies":{"rxjs":"^5.5.0 || ^6.5.0 || ^7.3.0","@awesome-cordova-plugins/core":"^6.0.1"},"version":"6.4.0"}

package/package.json

@@ -1 +1 @@
-{"description":"Awesome Cordova Plugins - Native plugins for ionic apps","main":"bundle.js","module":"index.js","typings":"index.d.ts","author":"ionic","license":"MIT","repository":{"type":"git","url":"https://github.com/danielsogl/awesome-cordova-plugins.git"},"name":"@awesome-cordova-plugins/urbanairship","dependencies":{"@types/cordova":"latest"},"peerDependencies":{"rxjs":"^5.5.0 || ^6.5.0 || ^7.3.0","@awesome-cordova-plugins/core":"^6.0.1"},"version":"6.2.0"}
+{"description":"Awesome Cordova Plugins - Native plugins for ionic apps","main":"bundle.js","module":"index.js","typings":"index.d.ts","author":"ionic","license":"MIT","repository":{"type":"git","url":"https://github.com/danielsogl/awesome-cordova-plugins.git"},"name":"@awesome-cordova-plugins/urbanairship","dependencies":{"@types/cordova":"latest"},"peerDependencies":{"rxjs":"^5.5.0 || ^6.5.0 || ^7.3.0","@awesome-cordova-plugins/core":"^6.0.1"},"version":"6.4.0"}