@awesome-cordova-plugins/urbanairship 5.39.0 → 5.41.0

package/index.d.ts

@@ -1,9 +1,36 @@
 import { AwesomeCordovaNativePlugin } from '@awesome-cordova-plugins/core';
 import { Observable } from 'rxjs';
+/**
+ * Interface for UAirship Tag Editor
+ */
 export interface TagGroupEditor {
-    addTags(): void;
-    removeTags(): void;
-    apply(): void;
+    addTags(tagGroup: string, tags: string[]): TagGroupEditor;
+    removeTags(tagGroup: string, tags: string[]): TagGroupEditor;
+    apply(success: () => void, failure: (message: string) => void): TagGroupEditor;
+}
+/**
+ * Interface for UAirship Attributes Editor
+ */
+export interface AttributesEditor {
+    setAttribute(name: string, value: string | number | boolean | Date): AttributesEditor;
+    removeAttribute(name: string): AttributesEditor;
+    apply(success: () => void, failure: (message: string) => void): AttributesEditor;
+}
+/**
+ * Interface for UAirship ChannelSubscriptionList Editor
+ */
+export interface ChannelSubscriptionListEditor {
+    subscribe(subscriptionListID: string): ChannelSubscriptionListEditor;
+    unsubscribe(subscriptionListID: string): ChannelSubscriptionListEditor;
+    apply(success: () => void, failure: (message: string) => void): ChannelSubscriptionListEditor;
+}
+/**
+ * Interface for UAirship ContactSubscriptionList Editor
+ */
+export interface ContactSubscriptionListEditor {
+    subscribe(subscriptionListID: string, contactScope: 'APP' | 'EMAIL'): ContactSubscriptionListEditor;
+    unsubscribe(subscriptionListID: string, contactScope: 'APP' | 'EMAIL'): ContactSubscriptionListEditor;
+    apply(success: () => void, failure: (message: string) => void): ContactSubscriptionListEditor;
 }
 /**
  * Enum for notification types.
@@ -138,6 +165,7 @@ export declare class UrbanAirShipOriginal extends AwesomeCordovaNativePlugin {
      * new config will not be used until the next app start.
      *
      * @param {object}  config The Urban Airship config.
+     * @param {string}  config.site Sets the cloud site, must be either EU or US.
      * @param {object}  config.development The Urban Airship development config.
      * @param {string}  config.development.appKey The development appKey.
      * @param {string}  config.development.appSecret The development appSecret.
@@ -347,7 +375,7 @@ export declare class UrbanAirShipOriginal extends AwesomeCordovaNativePlugin {
      * @param {function(message)} [failure] Failure callback.
      * @param {string} failure.message The error message.
      */
-    getNamedUser(): Promise<any>;
+    getNamedUser(): Promise<string>;
     /**
      * Sets the named user ID.
      *
@@ -370,16 +398,52 @@ export declare class UrbanAirShipOriginal extends AwesomeCordovaNativePlugin {
     runAction(actionName: string, actionValue: any): Promise<any>;
     /**
      * Creates an editor to modify the named user tag groups.
-     *
-     * @returns {TagGroupEditor} A tag group editor instance.
      */
     editNamedUserTagGroups(): TagGroupEditor;
     /**
      * Creates an editor to modify the channel tag groups.
-     *
-     * @returns {TagGroupEditor} A tag group editor instance.
      */
     editChannelTagGroups(): TagGroupEditor;
+    /**
+     * Creates an editor to modify the channel attributes.
+     */
+    editChannelAttributes(): AttributesEditor;
+    /**
+     * Creates an editor to modify the named user attributes.
+     */
+    editNamedUserAttributes(): AttributesEditor;
+    /**
+     * Creates an editor to modify the channel subscription lists.
+     *
+     * @returns {ChannelSubscriptionListEditor} A subscription list editor instance.
+     * @since 13.3.0
+     */
+    editChannelSubscriptionLists(): ChannelSubscriptionListEditor;
+    /**
+     * Creates an editor to modify the contact subscription lists.
+     *
+     * @returns {ContactSubscriptionListEditor} A subscription list editor instance.
+     * @since 13.3.0
+     */
+    editContactSubscriptionLists(): ContactSubscriptionListEditor;
+    /**
+     * Returns the current set of subscription lists for the current channel,
+     * optionally applying pending subscription list changes that will be applied during the next channel update.
+     * An empty set indicates that this contact is not subscribed to any lists.
+     *
+     * @param {Function} [success] Success callback.
+     * @param {string} failure.message The error message.
+     */
+    getChannelSubscriptionLists(): Promise<any>;
+    /**
+     * Returns the current set of subscription lists for the current contact,
+     * optionally applying pending subscription list changes that will be applied during the next contact update.
+     * An empty set indicates that this contact is not subscribed to any lists.
+     *
+     * @param {Function} [success] Success callback.
+     * @param {string} failure.message The error message.
+     */
+    getContactSubscriptionLists(): Promise<any>;
     /**
      * Sets an associated identifier for the Connect data stream.
      *
@@ -406,6 +470,7 @@ export declare class UrbanAirShipOriginal extends AwesomeCordovaNativePlugin {
      * @param {boolean} success.enabled Flag indicating if location is enabled or not.
      * @param {function(message)} [failure] Failure callback.
      * @param {string} failure.message The error message.
+     * @deprecated removed in version 8.0
      */
     isLocationEnabled(): Promise<any>;
     /**
@@ -415,6 +480,7 @@ export declare class UrbanAirShipOriginal extends AwesomeCordovaNativePlugin {
      * @param {Function} [success] Success callback.
      * @param {function(message)} [failure] Failure callback.
      * @param {string} failure.message The error message.
+     * @deprecated removed in version 8.0
      */
     setBackgroundLocationEnabled(enabled: boolean): Promise<any>;
     /**
@@ -424,6 +490,7 @@ export declare class UrbanAirShipOriginal extends AwesomeCordovaNativePlugin {
      * @param {boolean} success.enabled Flag indicating if background location updates are enabled or not.
      * @param {function(message)} [failure] Failure callback.
      * @param {string} failure.message The error message.
+     * @deprecated removed in version 8.0
      */
     isBackgroundLocationEnabled(): Promise<any>;
     /**
@@ -456,6 +523,7 @@ export declare class UrbanAirShipOriginal extends AwesomeCordovaNativePlugin {
      * @param {Function} [success] Success callback.
      * @param {function(message)} [failure] Failure callback.
      * @param {string} failure.message The error message.
+     * @deprecated removed in version 10.0
      */
     dismissOverlayInboxMessage(): Promise<any>;
     /**
@@ -518,6 +586,7 @@ export declare class UrbanAirShipOriginal extends AwesomeCordovaNativePlugin {
      * @param {Function} [success] Success callback.
      * @param {function(message)} [failure] Failure callback.
      * @param {string} failure.message The error message.
+     * @deprecated removed in version 10.0
      */
     overlayInboxMessage(messageId: string): Promise<any>;
     /**
@@ -649,6 +718,85 @@ export declare class UrbanAirShipOriginal extends AwesomeCordovaNativePlugin {
      * @param {string} failure.message The error message.
      */
     addCustomEvent(event: object): Promise<any>;
+    /**
+     * Initiates screen tracking for a specific app screen, must be called once per tracked screen.
+     *
+     * @param {string} screen The screen's string identifier.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 11.0.0
+     */
+    trackScreen(screen: string): Promise<any>;
+    /**
+     * Enables features, adding them to the set of currently enabled features.
+     *
+     * @param {Array<string>} features The features to enable.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    enableFeature(features: string[]): Promise<any>;
+    /**
+     * Disables features, removing them from the set of currently enabled features.
+     *
+     * @param {Array<string>} features The features to disable.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    disableFeature(features: string[]): Promise<any>;
+    /**
+     * Sets the current enabled features, replacing any currently enabled features with the given set.
+     *
+     * @param {Array<string>} features The features to set as enabled.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    setEnabledFeatures(features: string[]): Promise<any>;
+    /**
+     * Gets the current enabled features.
+     *
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    getEnabledFeatures(): Promise<any>;
+    /**
+     * Checks if all of the given features are enabled.
+     *
+     * @param {Array<string>} features The features to check.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    isFeatureEnabled(features: string[]): Promise<any>;
+    /**
+     * Returns the configuration of the Preference Center with the given ID trough a callback method.
+     *
+     * @param {string} preferenceCenterId The preference center ID.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.3.0
+     */
+    getPreferenceCenterConfig(preferenceCenterId: string): Promise<any>;
+    /**
+     * Opens the Preference Center with the given preferenceCenterId.
+     *
+     * @param {string} prenferenceCenterId The preference center ID.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    openPreferenceCenter(prenferenceCenterId: string): Promise<any>;
 }
 
 export declare const UrbanAirShip: UrbanAirShipOriginal;

package/index.js

@@ -75,8 +75,14 @@ var UrbanAirShipOriginal = /** @class */ (function (_super) {
     UrbanAirShipOriginal.prototype.getNamedUser = function () { return cordova(this, "getNamedUser", {}, arguments); };
     UrbanAirShipOriginal.prototype.setNamedUser = function (namedUser) { return cordova(this, "setNamedUser", {}, arguments); };
     UrbanAirShipOriginal.prototype.runAction = function (actionName, actionValue) { return cordova(this, "runAction", {}, arguments); };
-    UrbanAirShipOriginal.prototype.editNamedUserTagGroups = function () { return cordova(this, "editNamedUserTagGroups", {}, arguments); };
-    UrbanAirShipOriginal.prototype.editChannelTagGroups = function () { return cordova(this, "editChannelTagGroups", {}, arguments); };
+    UrbanAirShipOriginal.prototype.editNamedUserTagGroups = function () { return cordova(this, "editNamedUserTagGroups", { "sync": true }, arguments); };
+    UrbanAirShipOriginal.prototype.editChannelTagGroups = function () { return cordova(this, "editChannelTagGroups", { "sync": true }, arguments); };
+    UrbanAirShipOriginal.prototype.editChannelAttributes = function () { return cordova(this, "editChannelAttributes", { "sync": true }, arguments); };
+    UrbanAirShipOriginal.prototype.editNamedUserAttributes = function () { return cordova(this, "editNamedUserAttributes", { "sync": true }, arguments); };
+    UrbanAirShipOriginal.prototype.editChannelSubscriptionLists = function () { return cordova(this, "editChannelSubscriptionLists", { "sync": true }, arguments); };
+    UrbanAirShipOriginal.prototype.editContactSubscriptionLists = function () { return cordova(this, "editContactSubscriptionLists", { "sync": true }, arguments); };
+    UrbanAirShipOriginal.prototype.getChannelSubscriptionLists = function () { return cordova(this, "getChannelSubscriptionLists", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    UrbanAirShipOriginal.prototype.getContactSubscriptionLists = function () { return cordova(this, "getContactSubscriptionLists", { "successIndex": 1, "errorIndex": 2 }, arguments); };
     UrbanAirShipOriginal.prototype.setAssociatedIdentifier = function (key, identifier) { return cordova(this, "setAssociatedIdentifier", {}, arguments); };
     UrbanAirShipOriginal.prototype.setLocationEnabled = function (enabled) { return cordova(this, "setLocationEnabled", {}, arguments); };
     UrbanAirShipOriginal.prototype.isLocationEnabled = function () { return cordova(this, "isLocationEnabled", {}, arguments); };
@@ -106,6 +112,25 @@ var UrbanAirShipOriginal = /** @class */ (function (_super) {
     UrbanAirShipOriginal.prototype.isVibrateEnabled = function () { return cordova(this, "isVibrateEnabled", {}, arguments); };
     UrbanAirShipOriginal.prototype.setVibrateEnabled = function (enabled) { return cordova(this, "setVibrateEnabled", {}, arguments); };
     UrbanAirShipOriginal.prototype.addCustomEvent = function (event) { return cordova(this, "addCustomEvent", {}, arguments); };
+    UrbanAirShipOriginal.prototype.trackScreen = function (screen) { return cordova(this, "trackScreen", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    UrbanAirShipOriginal.prototype.enableFeature = function (features) { return cordova(this, "enableFeature", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    UrbanAirShipOriginal.prototype.disableFeature = function (features) { return cordova(this, "disableFeature", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    /**
+     * Sets the current enabled features, replacing any currently enabled features with the given set.
+     *
+     * @param {Array<string>} features The features to set as enabled.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    UrbanAirShipOriginal.prototype.setEnabledFeatures = function (features) {
+        return;
+    };
+    UrbanAirShipOriginal.prototype.getEnabledFeatures = function () { return cordova(this, "getEnabledFeatures", { "successIndex": 0, "errorIndex": 1 }, arguments); };
+    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.pluginName = "UrbanAirShip";
     UrbanAirShipOriginal.plugin = "urbanairship-cordova";
     UrbanAirShipOriginal.pluginRef = "window.UAirship";
@@ -116,4 +141,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;AAQlC;;;;;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;IAqBR,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;IAU9C,6CAAsB;IAUtB,2CAAoB;IAcpB,8CAAuB,aAAC,GAAW,EAAE,UAAkB;IAevD,yCAAkB,aAAC,OAAgB;IAanC,wCAAiB;IAajB,mDAA4B,aAAC,OAAgB;IAa7C,kDAA2B;IAY3B,2CAAoB;IAYpB,2CAAoB;IAYpB,0CAAmB;IAYnB,iDAA0B;IAmB1B,uCAAgB;IAahB,2CAAoB,aAAC,SAAiB;IAatC,yCAAkB,aAAC,SAAiB;IAapC,0CAAmB,aAAC,SAAiB;IAerC,mCAAY;IAaZ,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;;;;;;;uBAj7B9B;EAiEkC,0BAA0B;SAA/C,YAAY","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Plugin, Cordova, AwesomeCordovaNativePlugin } from '@awesome-cordova-plugins/core';\nimport { Observable } from 'rxjs';\n\nexport interface TagGroupEditor {\n  addTags(): void;\n  removeTags(): void;\n  apply(): void;\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 {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<any> {\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   * @returns {TagGroupEditor} A tag group editor instance.\n   */\n  @Cordova()\n  editNamedUserTagGroups(): TagGroupEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel tag groups.\n   *\n   * @returns {TagGroupEditor} A tag group editor instance.\n   */\n  @Cordova()\n  editChannelTagGroups(): TagGroupEditor {\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<any> {\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   */\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   */\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   */\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   */\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   */\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"]}
+//# 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;AAsClC;;;;;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;;;;;;;uBA1pClD;EA+FkC,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\n/**\n * Interface for UAirship ContactSubscriptionList Editor\n */\nexport interface ContactSubscriptionListEditor {\n  subscribe(subscriptionListID: string, contactScope: 'APP' | 'EMAIL'): ContactSubscriptionListEditor;\n  unsubscribe(subscriptionListID: string, contactScope: 'APP' | 'EMAIL'): 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: 1,\n    errorIndex: 2,\n  })\n  getChannelSubscriptionLists(): Promise<any> {\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: 1,\n    errorIndex: 2,\n  })\n  getContactSubscriptionLists(): Promise<any> {\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<any> {\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"]}

package/ngx/bundle.js

@@ -69,8 +69,14 @@ var UrbanAirShip = /** @class */ (function (_super) {
     UrbanAirShip.prototype.getNamedUser = function () { return core.cordova(this, "getNamedUser", {}, arguments); };
     UrbanAirShip.prototype.setNamedUser = function (namedUser) { return core.cordova(this, "setNamedUser", {}, arguments); };
     UrbanAirShip.prototype.runAction = function (actionName, actionValue) { return core.cordova(this, "runAction", {}, arguments); };
-    UrbanAirShip.prototype.editNamedUserTagGroups = function () { return core.cordova(this, "editNamedUserTagGroups", {}, arguments); };
-    UrbanAirShip.prototype.editChannelTagGroups = function () { return core.cordova(this, "editChannelTagGroups", {}, arguments); };
+    UrbanAirShip.prototype.editNamedUserTagGroups = function () { return core.cordova(this, "editNamedUserTagGroups", { "sync": true }, arguments); };
+    UrbanAirShip.prototype.editChannelTagGroups = function () { return core.cordova(this, "editChannelTagGroups", { "sync": true }, arguments); };
+    UrbanAirShip.prototype.editChannelAttributes = function () { return core.cordova(this, "editChannelAttributes", { "sync": true }, arguments); };
+    UrbanAirShip.prototype.editNamedUserAttributes = function () { return core.cordova(this, "editNamedUserAttributes", { "sync": true }, arguments); };
+    UrbanAirShip.prototype.editChannelSubscriptionLists = function () { return core.cordova(this, "editChannelSubscriptionLists", { "sync": true }, arguments); };
+    UrbanAirShip.prototype.editContactSubscriptionLists = function () { return core.cordova(this, "editContactSubscriptionLists", { "sync": true }, arguments); };
+    UrbanAirShip.prototype.getChannelSubscriptionLists = function () { return core.cordova(this, "getChannelSubscriptionLists", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    UrbanAirShip.prototype.getContactSubscriptionLists = function () { return core.cordova(this, "getContactSubscriptionLists", { "successIndex": 1, "errorIndex": 2 }, arguments); };
     UrbanAirShip.prototype.setAssociatedIdentifier = function (key, identifier) { return core.cordova(this, "setAssociatedIdentifier", {}, arguments); };
     UrbanAirShip.prototype.setLocationEnabled = function (enabled) { return core.cordova(this, "setLocationEnabled", {}, arguments); };
     UrbanAirShip.prototype.isLocationEnabled = function () { return core.cordova(this, "isLocationEnabled", {}, arguments); };
@@ -100,6 +106,25 @@ var UrbanAirShip = /** @class */ (function (_super) {
     UrbanAirShip.prototype.isVibrateEnabled = function () { return core.cordova(this, "isVibrateEnabled", {}, arguments); };
     UrbanAirShip.prototype.setVibrateEnabled = function (enabled) { return core.cordova(this, "setVibrateEnabled", {}, arguments); };
     UrbanAirShip.prototype.addCustomEvent = function (event) { return core.cordova(this, "addCustomEvent", {}, arguments); };
+    UrbanAirShip.prototype.trackScreen = function (screen) { return core.cordova(this, "trackScreen", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    UrbanAirShip.prototype.enableFeature = function (features) { return core.cordova(this, "enableFeature", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    UrbanAirShip.prototype.disableFeature = function (features) { return core.cordova(this, "disableFeature", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    /**
+     * Sets the current enabled features, replacing any currently enabled features with the given set.
+     *
+     * @param {Array<string>} features The features to set as enabled.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    UrbanAirShip.prototype.setEnabledFeatures = function (features) {
+        return;
+    };
+    UrbanAirShip.prototype.getEnabledFeatures = function () { return core.cordova(this, "getEnabledFeatures", { "successIndex": 0, "errorIndex": 1 }, arguments); };
+    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.pluginName = "UrbanAirShip";
     UrbanAirShip.plugin = "urbanairship-cordova";
     UrbanAirShip.pluginRef = "window.UAirship";

package/ngx/index.d.ts

@@ -1,9 +1,36 @@
 import { AwesomeCordovaNativePlugin } from '@awesome-cordova-plugins/core';
 import { Observable } from 'rxjs';
+/**
+ * Interface for UAirship Tag Editor
+ */
 export interface TagGroupEditor {
-    addTags(): void;
-    removeTags(): void;
-    apply(): void;
+    addTags(tagGroup: string, tags: string[]): TagGroupEditor;
+    removeTags(tagGroup: string, tags: string[]): TagGroupEditor;
+    apply(success: () => void, failure: (message: string) => void): TagGroupEditor;
+}
+/**
+ * Interface for UAirship Attributes Editor
+ */
+export interface AttributesEditor {
+    setAttribute(name: string, value: string | number | boolean | Date): AttributesEditor;
+    removeAttribute(name: string): AttributesEditor;
+    apply(success: () => void, failure: (message: string) => void): AttributesEditor;
+}
+/**
+ * Interface for UAirship ChannelSubscriptionList Editor
+ */
+export interface ChannelSubscriptionListEditor {
+    subscribe(subscriptionListID: string): ChannelSubscriptionListEditor;
+    unsubscribe(subscriptionListID: string): ChannelSubscriptionListEditor;
+    apply(success: () => void, failure: (message: string) => void): ChannelSubscriptionListEditor;
+}
+/**
+ * Interface for UAirship ContactSubscriptionList Editor
+ */
+export interface ContactSubscriptionListEditor {
+    subscribe(subscriptionListID: string, contactScope: 'APP' | 'EMAIL'): ContactSubscriptionListEditor;
+    unsubscribe(subscriptionListID: string, contactScope: 'APP' | 'EMAIL'): ContactSubscriptionListEditor;
+    apply(success: () => void, failure: (message: string) => void): ContactSubscriptionListEditor;
 }
 /**
  * Enum for notification types.
@@ -138,6 +165,7 @@ export declare class UrbanAirShip extends AwesomeCordovaNativePlugin {
      * new config will not be used until the next app start.
      *
      * @param {object}  config The Urban Airship config.
+     * @param {string}  config.site Sets the cloud site, must be either EU or US.
      * @param {object}  config.development The Urban Airship development config.
      * @param {string}  config.development.appKey The development appKey.
      * @param {string}  config.development.appSecret The development appSecret.
@@ -347,7 +375,7 @@ export declare class UrbanAirShip extends AwesomeCordovaNativePlugin {
      * @param {function(message)} [failure] Failure callback.
      * @param {string} failure.message The error message.
      */
-    getNamedUser(): Promise<any>;
+    getNamedUser(): Promise<string>;
     /**
      * Sets the named user ID.
      *
@@ -370,16 +398,52 @@ export declare class UrbanAirShip extends AwesomeCordovaNativePlugin {
     runAction(actionName: string, actionValue: any): Promise<any>;
     /**
      * Creates an editor to modify the named user tag groups.
-     *
-     * @returns {TagGroupEditor} A tag group editor instance.
      */
     editNamedUserTagGroups(): TagGroupEditor;
     /**
      * Creates an editor to modify the channel tag groups.
-     *
-     * @returns {TagGroupEditor} A tag group editor instance.
      */
     editChannelTagGroups(): TagGroupEditor;
+    /**
+     * Creates an editor to modify the channel attributes.
+     */
+    editChannelAttributes(): AttributesEditor;
+    /**
+     * Creates an editor to modify the named user attributes.
+     */
+    editNamedUserAttributes(): AttributesEditor;
+    /**
+     * Creates an editor to modify the channel subscription lists.
+     *
+     * @returns {ChannelSubscriptionListEditor} A subscription list editor instance.
+     * @since 13.3.0
+     */
+    editChannelSubscriptionLists(): ChannelSubscriptionListEditor;
+    /**
+     * Creates an editor to modify the contact subscription lists.
+     *
+     * @returns {ContactSubscriptionListEditor} A subscription list editor instance.
+     * @since 13.3.0
+     */
+    editContactSubscriptionLists(): ContactSubscriptionListEditor;
+    /**
+     * Returns the current set of subscription lists for the current channel,
+     * optionally applying pending subscription list changes that will be applied during the next channel update.
+     * An empty set indicates that this contact is not subscribed to any lists.
+     *
+     * @param {Function} [success] Success callback.
+     * @param {string} failure.message The error message.
+     */
+    getChannelSubscriptionLists(): Promise<any>;
+    /**
+     * Returns the current set of subscription lists for the current contact,
+     * optionally applying pending subscription list changes that will be applied during the next contact update.
+     * An empty set indicates that this contact is not subscribed to any lists.
+     *
+     * @param {Function} [success] Success callback.
+     * @param {string} failure.message The error message.
+     */
+    getContactSubscriptionLists(): Promise<any>;
     /**
      * Sets an associated identifier for the Connect data stream.
      *
@@ -406,6 +470,7 @@ export declare class UrbanAirShip extends AwesomeCordovaNativePlugin {
      * @param {boolean} success.enabled Flag indicating if location is enabled or not.
      * @param {function(message)} [failure] Failure callback.
      * @param {string} failure.message The error message.
+     * @deprecated removed in version 8.0
      */
     isLocationEnabled(): Promise<any>;
     /**
@@ -415,6 +480,7 @@ export declare class UrbanAirShip extends AwesomeCordovaNativePlugin {
      * @param {Function} [success] Success callback.
      * @param {function(message)} [failure] Failure callback.
      * @param {string} failure.message The error message.
+     * @deprecated removed in version 8.0
      */
     setBackgroundLocationEnabled(enabled: boolean): Promise<any>;
     /**
@@ -424,6 +490,7 @@ export declare class UrbanAirShip extends AwesomeCordovaNativePlugin {
      * @param {boolean} success.enabled Flag indicating if background location updates are enabled or not.
      * @param {function(message)} [failure] Failure callback.
      * @param {string} failure.message The error message.
+     * @deprecated removed in version 8.0
      */
     isBackgroundLocationEnabled(): Promise<any>;
     /**
@@ -456,6 +523,7 @@ export declare class UrbanAirShip extends AwesomeCordovaNativePlugin {
      * @param {Function} [success] Success callback.
      * @param {function(message)} [failure] Failure callback.
      * @param {string} failure.message The error message.
+     * @deprecated removed in version 10.0
      */
     dismissOverlayInboxMessage(): Promise<any>;
     /**
@@ -518,6 +586,7 @@ export declare class UrbanAirShip extends AwesomeCordovaNativePlugin {
      * @param {Function} [success] Success callback.
      * @param {function(message)} [failure] Failure callback.
      * @param {string} failure.message The error message.
+     * @deprecated removed in version 10.0
      */
     overlayInboxMessage(messageId: string): Promise<any>;
     /**
@@ -649,4 +718,83 @@ export declare class UrbanAirShip extends AwesomeCordovaNativePlugin {
      * @param {string} failure.message The error message.
      */
     addCustomEvent(event: object): Promise<any>;
+    /**
+     * Initiates screen tracking for a specific app screen, must be called once per tracked screen.
+     *
+     * @param {string} screen The screen's string identifier.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 11.0.0
+     */
+    trackScreen(screen: string): Promise<any>;
+    /**
+     * Enables features, adding them to the set of currently enabled features.
+     *
+     * @param {Array<string>} features The features to enable.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    enableFeature(features: string[]): Promise<any>;
+    /**
+     * Disables features, removing them from the set of currently enabled features.
+     *
+     * @param {Array<string>} features The features to disable.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    disableFeature(features: string[]): Promise<any>;
+    /**
+     * Sets the current enabled features, replacing any currently enabled features with the given set.
+     *
+     * @param {Array<string>} features The features to set as enabled.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    setEnabledFeatures(features: string[]): Promise<any>;
+    /**
+     * Gets the current enabled features.
+     *
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    getEnabledFeatures(): Promise<any>;
+    /**
+     * Checks if all of the given features are enabled.
+     *
+     * @param {Array<string>} features The features to check.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    isFeatureEnabled(features: string[]): Promise<any>;
+    /**
+     * Returns the configuration of the Preference Center with the given ID trough a callback method.
+     *
+     * @param {string} preferenceCenterId The preference center ID.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.3.0
+     */
+    getPreferenceCenterConfig(preferenceCenterId: string): Promise<any>;
+    /**
+     * Opens the Preference Center with the given preferenceCenterId.
+     *
+     * @param {string} prenferenceCenterId The preference center ID.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    openPreferenceCenter(prenferenceCenterId: string): Promise<any>;
 }

package/ngx/index.js

@@ -64,8 +64,14 @@ var UrbanAirShip = /** @class */ (function (_super) {
     UrbanAirShip.prototype.getNamedUser = function () { return cordova(this, "getNamedUser", {}, arguments); };
     UrbanAirShip.prototype.setNamedUser = function (namedUser) { return cordova(this, "setNamedUser", {}, arguments); };
     UrbanAirShip.prototype.runAction = function (actionName, actionValue) { return cordova(this, "runAction", {}, arguments); };
-    UrbanAirShip.prototype.editNamedUserTagGroups = function () { return cordova(this, "editNamedUserTagGroups", {}, arguments); };
-    UrbanAirShip.prototype.editChannelTagGroups = function () { return cordova(this, "editChannelTagGroups", {}, arguments); };
+    UrbanAirShip.prototype.editNamedUserTagGroups = function () { return cordova(this, "editNamedUserTagGroups", { "sync": true }, arguments); };
+    UrbanAirShip.prototype.editChannelTagGroups = function () { return cordova(this, "editChannelTagGroups", { "sync": true }, arguments); };
+    UrbanAirShip.prototype.editChannelAttributes = function () { return cordova(this, "editChannelAttributes", { "sync": true }, arguments); };
+    UrbanAirShip.prototype.editNamedUserAttributes = function () { return cordova(this, "editNamedUserAttributes", { "sync": true }, arguments); };
+    UrbanAirShip.prototype.editChannelSubscriptionLists = function () { return cordova(this, "editChannelSubscriptionLists", { "sync": true }, arguments); };
+    UrbanAirShip.prototype.editContactSubscriptionLists = function () { return cordova(this, "editContactSubscriptionLists", { "sync": true }, arguments); };
+    UrbanAirShip.prototype.getChannelSubscriptionLists = function () { return cordova(this, "getChannelSubscriptionLists", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    UrbanAirShip.prototype.getContactSubscriptionLists = function () { return cordova(this, "getContactSubscriptionLists", { "successIndex": 1, "errorIndex": 2 }, arguments); };
     UrbanAirShip.prototype.setAssociatedIdentifier = function (key, identifier) { return cordova(this, "setAssociatedIdentifier", {}, arguments); };
     UrbanAirShip.prototype.setLocationEnabled = function (enabled) { return cordova(this, "setLocationEnabled", {}, arguments); };
     UrbanAirShip.prototype.isLocationEnabled = function () { return cordova(this, "isLocationEnabled", {}, arguments); };
@@ -95,6 +101,25 @@ var UrbanAirShip = /** @class */ (function (_super) {
     UrbanAirShip.prototype.isVibrateEnabled = function () { return cordova(this, "isVibrateEnabled", {}, arguments); };
     UrbanAirShip.prototype.setVibrateEnabled = function (enabled) { return cordova(this, "setVibrateEnabled", {}, arguments); };
     UrbanAirShip.prototype.addCustomEvent = function (event) { return cordova(this, "addCustomEvent", {}, arguments); };
+    UrbanAirShip.prototype.trackScreen = function (screen) { return cordova(this, "trackScreen", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    UrbanAirShip.prototype.enableFeature = function (features) { return cordova(this, "enableFeature", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    UrbanAirShip.prototype.disableFeature = function (features) { return cordova(this, "disableFeature", { "successIndex": 1, "errorIndex": 2 }, arguments); };
+    /**
+     * Sets the current enabled features, replacing any currently enabled features with the given set.
+     *
+     * @param {Array<string>} features The features to set as enabled.
+     * @param {Function} [success] Success callback.
+     * @param {function(message)} [failure] Failure callback.
+     * @param {string} failure.message The error message.
+     * @since 13.0.0
+     */
+    UrbanAirShip.prototype.setEnabledFeatures = function (features) {
+        return;
+    };
+    UrbanAirShip.prototype.getEnabledFeatures = function () { return cordova(this, "getEnabledFeatures", { "successIndex": 0, "errorIndex": 1 }, arguments); };
+    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.pluginName = "UrbanAirShip";
     UrbanAirShip.plugin = "urbanairship-cordova";
     UrbanAirShip.pluginRef = "window.UAirship";
@@ -107,4 +132,4 @@ var UrbanAirShip = /** @class */ (function (_super) {
     return UrbanAirShip;
 }(AwesomeCordovaNativePlugin));
 export { UrbanAirShip };
-//# 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;AAQlC;;;;;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;IAqBR,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;IAU9C,6CAAsB;IAUtB,2CAAoB;IAcpB,8CAAuB,aAAC,GAAW,EAAE,UAAkB;IAevD,yCAAkB,aAAC,OAAgB;IAanC,wCAAiB;IAajB,mDAA4B,aAAC,OAAgB;IAa7C,kDAA2B;IAY3B,2CAAoB;IAYpB,2CAAoB;IAYpB,0CAAmB;IAYnB,iDAA0B;IAmB1B,uCAAgB;IAahB,2CAAoB,aAAC,SAAiB;IAatC,yCAAkB,aAAC,SAAiB;IAapC,0CAAmB,aAAC,SAAiB;IAerC,mCAAY;IAaZ,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;;;;;;;;gBAj3B7B,UAAU;;uBAhEX;EAiEkC,0BAA0B;SAA/C,YAAY","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Plugin, Cordova, AwesomeCordovaNativePlugin } from '@awesome-cordova-plugins/core';\nimport { Observable } from 'rxjs';\n\nexport interface TagGroupEditor {\n  addTags(): void;\n  removeTags(): void;\n  apply(): void;\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 {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<any> {\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   * @returns {TagGroupEditor} A tag group editor instance.\n   */\n  @Cordova()\n  editNamedUserTagGroups(): TagGroupEditor {\n    return;\n  }\n\n  /**\n   * Creates an editor to modify the channel tag groups.\n   *\n   * @returns {TagGroupEditor} A tag group editor instance.\n   */\n  @Cordova()\n  editChannelTagGroups(): TagGroupEditor {\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<any> {\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   */\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   */\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   */\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   */\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   */\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"]}
+//# 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;AAsClC;;;;;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;;;;;;;;gBA5jCjD,UAAU;;uBA9FX;EA+FkC,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\n/**\n * Interface for UAirship ContactSubscriptionList Editor\n */\nexport interface ContactSubscriptionListEditor {\n  subscribe(subscriptionListID: string, contactScope: 'APP' | 'EMAIL'): ContactSubscriptionListEditor;\n  unsubscribe(subscriptionListID: string, contactScope: 'APP' | 'EMAIL'): 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: 1,\n    errorIndex: 2,\n  })\n  getChannelSubscriptionLists(): Promise<any> {\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: 1,\n    errorIndex: 2,\n  })\n  getContactSubscriptionLists(): Promise<any> {\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<any> {\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"]}

package/ngx/index.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"TagGroupEditor":{"__symbolic":"interface"},"NotificationType":{"none":0,"badge":1,"sound":2,"alert":4},"PresentationOptions":{"none":0,"badge":1,"sound":2,"alert":4},"UrbanAirShip":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"@awesome-cordova-plugins/core","name":"AwesomeCordovaNativePlugin","line":65,"character":34},"decorators":[{"__symbolic":"call","expression":{"__symbolic":"reference","module":"@angular/core","name":"Injectable","line":64,"character":1}}],"members":{"onDeepLink":[{"__symbolic":"method"}],"onRegistration":[{"__symbolic":"method"}],"onInboxUpdated":[{"__symbolic":"method"}],"onShowInbox":[{"__symbolic":"method"}],"onPushReceived":[{"__symbolic":"method"}],"onNotificationOpened":[{"__symbolic":"method"}],"onNotificationOptInStatus":[{"__symbolic":"method"}],"reattach":[{"__symbolic":"method"}],"takeOff":[{"__symbolic":"method"}],"setAndroidNotificationConfig":[{"__symbolic":"method"}],"setAutoLaunchDefaultMessageCenter":[{"__symbolic":"method"}],"setUserNotificationsEnabled":[{"__symbolic":"method"}],"isUserNotificationsEnabled":[{"__symbolic":"method"}],"isAppNotificationsEnabled":[{"__symbolic":"method"}],"getChannelID":[{"__symbolic":"method"}],"getLaunchNotification":[{"__symbolic":"method"}],"getDeepLink":[{"__symbolic":"method"}],"getTags":[{"__symbolic":"method"}],"setTags":[{"__symbolic":"method"}],"getAlias":[{"__symbolic":"method"}],"setAlias":[{"__symbolic":"method"}],"isQuietTimeEnabled":[{"__symbolic":"method"}],"setQuietTimeEnabled":[{"__symbolic":"method"}],"isInQuietTime":[{"__symbolic":"method"}],"getQuietTime":[{"__symbolic":"method"}],"setQuietTime":[{"__symbolic":"method"}],"setAnalyticsEnabled":[{"__symbolic":"method"}],"isAnalyticsEnabled":[{"__symbolic":"method"}],"getNamedUser":[{"__symbolic":"method"}],"setNamedUser":[{"__symbolic":"method"}],"runAction":[{"__symbolic":"method"}],"editNamedUserTagGroups":[{"__symbolic":"method"}],"editChannelTagGroups":[{"__symbolic":"method"}],"setAssociatedIdentifier":[{"__symbolic":"method"}],"setLocationEnabled":[{"__symbolic":"method"}],"isLocationEnabled":[{"__symbolic":"method"}],"setBackgroundLocationEnabled":[{"__symbolic":"method"}],"isBackgroundLocationEnabled":[{"__symbolic":"method"}],"displayMessageCenter":[{"__symbolic":"method"}],"dismissMessageCenter":[{"__symbolic":"method"}],"dismissInboxMessage":[{"__symbolic":"method"}],"dismissOverlayInboxMessage":[{"__symbolic":"method"}],"getInboxMessages":[{"__symbolic":"method"}],"markInboxMessageRead":[{"__symbolic":"method"}],"deleteInboxMessage":[{"__symbolic":"method"}],"displayInboxMessage":[{"__symbolic":"method"}],"refreshInbox":[{"__symbolic":"method"}],"overlayInboxMessage":[{"__symbolic":"method"}],"clearNotification":[{"__symbolic":"method"}],"clearNotifications":[{"__symbolic":"method"}],"getActiveNotifications":[{"__symbolic":"method"}],"setAutobadgeEnabled":[{"__symbolic":"method"}],"setBadgeNumber":[{"__symbolic":"method"}],"getBadgeNumber":[{"__symbolic":"method"}],"resetBadge":[{"__symbolic":"method"}],"setNotificationTypes":[{"__symbolic":"method"}],"setPresentationOptions":[{"__symbolic":"method"}],"isSoundEnabled":[{"__symbolic":"method"}],"setSoundEnabled":[{"__symbolic":"method"}],"isVibrateEnabled":[{"__symbolic":"method"}],"setVibrateEnabled":[{"__symbolic":"method"}],"addCustomEvent":[{"__symbolic":"method"}]}}}}]
+[{"__symbolic":"module","version":4,"metadata":{"TagGroupEditor":{"__symbolic":"interface"},"AttributesEditor":{"__symbolic":"interface"},"ChannelSubscriptionListEditor":{"__symbolic":"interface"},"ContactSubscriptionListEditor":{"__symbolic":"interface"},"NotificationType":{"none":0,"badge":1,"sound":2,"alert":4},"PresentationOptions":{"none":0,"badge":1,"sound":2,"alert":4},"UrbanAirShip":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"@awesome-cordova-plugins/core","name":"AwesomeCordovaNativePlugin","line":95,"character":34},"decorators":[{"__symbolic":"call","expression":{"__symbolic":"reference","module":"@angular/core","name":"Injectable","line":94,"character":1}}],"members":{"onDeepLink":[{"__symbolic":"method"}],"onRegistration":[{"__symbolic":"method"}],"onInboxUpdated":[{"__symbolic":"method"}],"onShowInbox":[{"__symbolic":"method"}],"onPushReceived":[{"__symbolic":"method"}],"onNotificationOpened":[{"__symbolic":"method"}],"onNotificationOptInStatus":[{"__symbolic":"method"}],"reattach":[{"__symbolic":"method"}],"takeOff":[{"__symbolic":"method"}],"setAndroidNotificationConfig":[{"__symbolic":"method"}],"setAutoLaunchDefaultMessageCenter":[{"__symbolic":"method"}],"setUserNotificationsEnabled":[{"__symbolic":"method"}],"isUserNotificationsEnabled":[{"__symbolic":"method"}],"isAppNotificationsEnabled":[{"__symbolic":"method"}],"getChannelID":[{"__symbolic":"method"}],"getLaunchNotification":[{"__symbolic":"method"}],"getDeepLink":[{"__symbolic":"method"}],"getTags":[{"__symbolic":"method"}],"setTags":[{"__symbolic":"method"}],"getAlias":[{"__symbolic":"method"}],"setAlias":[{"__symbolic":"method"}],"isQuietTimeEnabled":[{"__symbolic":"method"}],"setQuietTimeEnabled":[{"__symbolic":"method"}],"isInQuietTime":[{"__symbolic":"method"}],"getQuietTime":[{"__symbolic":"method"}],"setQuietTime":[{"__symbolic":"method"}],"setAnalyticsEnabled":[{"__symbolic":"method"}],"isAnalyticsEnabled":[{"__symbolic":"method"}],"getNamedUser":[{"__symbolic":"method"}],"setNamedUser":[{"__symbolic":"method"}],"runAction":[{"__symbolic":"method"}],"editNamedUserTagGroups":[{"__symbolic":"method"}],"editChannelTagGroups":[{"__symbolic":"method"}],"editChannelAttributes":[{"__symbolic":"method"}],"editNamedUserAttributes":[{"__symbolic":"method"}],"editChannelSubscriptionLists":[{"__symbolic":"method"}],"editContactSubscriptionLists":[{"__symbolic":"method"}],"getChannelSubscriptionLists":[{"__symbolic":"method"}],"getContactSubscriptionLists":[{"__symbolic":"method"}],"setAssociatedIdentifier":[{"__symbolic":"method"}],"setLocationEnabled":[{"__symbolic":"method"}],"isLocationEnabled":[{"__symbolic":"method"}],"setBackgroundLocationEnabled":[{"__symbolic":"method"}],"isBackgroundLocationEnabled":[{"__symbolic":"method"}],"displayMessageCenter":[{"__symbolic":"method"}],"dismissMessageCenter":[{"__symbolic":"method"}],"dismissInboxMessage":[{"__symbolic":"method"}],"dismissOverlayInboxMessage":[{"__symbolic":"method"}],"getInboxMessages":[{"__symbolic":"method"}],"markInboxMessageRead":[{"__symbolic":"method"}],"deleteInboxMessage":[{"__symbolic":"method"}],"displayInboxMessage":[{"__symbolic":"method"}],"refreshInbox":[{"__symbolic":"method"}],"overlayInboxMessage":[{"__symbolic":"method"}],"clearNotification":[{"__symbolic":"method"}],"clearNotifications":[{"__symbolic":"method"}],"getActiveNotifications":[{"__symbolic":"method"}],"setAutobadgeEnabled":[{"__symbolic":"method"}],"setBadgeNumber":[{"__symbolic":"method"}],"getBadgeNumber":[{"__symbolic":"method"}],"resetBadge":[{"__symbolic":"method"}],"setNotificationTypes":[{"__symbolic":"method"}],"setPresentationOptions":[{"__symbolic":"method"}],"isSoundEnabled":[{"__symbolic":"method"}],"setSoundEnabled":[{"__symbolic":"method"}],"isVibrateEnabled":[{"__symbolic":"method"}],"setVibrateEnabled":[{"__symbolic":"method"}],"addCustomEvent":[{"__symbolic":"method"}],"trackScreen":[{"__symbolic":"method"}],"enableFeature":[{"__symbolic":"method"}],"disableFeature":[{"__symbolic":"method"}],"setEnabledFeatures":[{"__symbolic":"method"}],"getEnabledFeatures":[{"__symbolic":"method"}],"isFeatureEnabled":[{"__symbolic":"method"}],"getPreferenceCenterConfig":[{"__symbolic":"method"}],"openPreferenceCenter":[{"__symbolic":"method"}]}}}}]

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":"^5.1.0"},"version":"5.39.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":"^5.1.0"},"version":"5.41.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":"^5.1.0"},"version":"5.39.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":"^5.1.0"},"version":"5.41.0"}