@ionic-native/http - npm Package Compare versions

Comparing version 5.30.0 to 5.31.1

index.d.ts

@@ -26,2 +26,5 @@ import { IonicNativePlugin } from '@ionic-native/core';
 }
+interface AbortedResponse {
+    aborted: boolean;
+}
 /**
@@ -78,2 +81,3 @@ * @name HTTP
         POST_PROCESSING_FAILED: number;
+        ABORTED: number;
     };
@@ -179,2 +183,12 @@ /**
     /**
+     * Make a sync POST request
+     * @param url {string} The url to send the request to
+     * @param body {Object} The body of the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    postSync(url: string, body: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      * Make a GET request
@@ -188,2 +202,12 @@ * @param url {string} The url to send the request to
     /**
+     * Make a sync GET request
+     * @param url {string} The url to send the request to
+     * @param parameters {Object} Parameters to send with the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    getSync(url: string, parameters: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      * Make a PUT request
@@ -197,2 +221,12 @@ * @param url {string} The url to send the request to
     /**
+     * Make a sync PUT request
+     * @param url {string} The url to send the request to
+     * @param body {Object} The body of the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    putSync(url: string, body: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      * Make a PATCH request
@@ -206,2 +240,12 @@ * @param url {string} The url to send the request to
     /**
+     * Make a sync PATCH request
+     * @param url {string} The url to send the request to
+     * @param body {Object} The body of the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    patchSync(url: string, body: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      * Make a DELETE request
@@ -215,2 +259,12 @@ * @param url {string} The url to send the request to
     /**
+     * Make a sync DELETE request
+     * @param url {string} The url to send the request to
+     * @param parameters {Object} Parameters to send with the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    deleteSync(url: string, parameters: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      * Make a HEAD request
@@ -224,2 +278,12 @@ * @param url {string} The url to send the request to
     /**
+     * Make a sync HEAD request
+     * @param url {string} The url to send the request to
+     * @param parameters {Object} Parameters to send with the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    headSync(url: string, parameters: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      * Make an OPTIONS request
@@ -233,2 +297,12 @@ * @param url {string} The url to send the request to
     /**
+     * Make an sync OPTIONS request
+     * @param url {string} The url to send the request to
+     * @param parameters {Object} Parameters to send with the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    optionsSync(url: string, parameters: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      *
@@ -248,2 +322,14 @@ * @param url {string} The url to send the request to
      * @param headers {Object} The headers to set for this request
+     * @param filePath {string} The local path(s) of the file(s) to upload
+     * @param name {string} The name(s) of the parameter to pass the file(s) along as
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    uploadFileSync(url: string, body: any, headers: any, filePath: string | string[], name: string | string[], success: (result: any) => void, failure: (error: any) => void): string;
+    /**
+     *
+     * @param url {string} The url to send the request to
+     * @param body {Object} The body of the request
+     * @param headers {Object} The headers to set for this request
      * @param filePath {string} The path to download the file to, including the file name.
@@ -256,2 +342,13 @@ * @returns {Promise<any>} returns a FileEntry promise that will resolve on success, and reject on failure
      * @param url {string} The url to send the request to
+     * @param body {Object} The body of the request
+     * @param headers {Object} The headers to set for this request
+     * @param filePath {string} The path to download the file to, including the file name.
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    downloadFileSync(url: string, body: any, headers: any, filePath: string, success: (result: any) => void, failure: (error: any) => void): string;
+    /**
+     *
+     * @param url {string} The url to send the request to
      * @param options {Object} options for individual request
@@ -287,4 +384,44 @@ * @param options.method {string} request method
     }): Promise<HTTPResponse>;
+    /**
+     *
+     * @param url {string} The url to send the request to
+     * @param options {Object} options for individual request
+     * @param options.method {string} request method
+     * @param options.data {Object} payload to be send to the server (only applicable on post, put or patch methods)
+     * @param options.params {Object} query params to be appended to the URL (only applicable on get, head, delete, upload or download methods)
+     * @param options.serializer {string} data serializer to be used (only applicable on post, put or patch methods), defaults to global serializer value, see setDataSerializer for supported values
+     * @param options.timeout {number} timeout value for the request in seconds, defaults to global timeout value
+     * @param options.headers {Object} headers object (key value pair), will be merged with global values
+     * @param options.filePath {string} file path(s) to be used during upload and download see uploadFile and downloadFile for detailed information
+     * @param options.name {string} name(s) to be used during upload see uploadFile for detailed information
+     * @param options.responseType {string} response type, defaults to text
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     *
+     * @returns {string} returns a string that represents the requestId
+     */
+    sendRequestSync(url: string, options: {
+        method: 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'upload' | 'download';
+        data?: {
+            [index: string]: any;
+        };
+        params?: {
+            [index: string]: string | number;
+        };
+        serializer?: 'json' | 'urlencoded' | 'utf8' | 'multipart';
+        timeout?: number;
+        headers?: {
+            [index: string]: string;
+        };
+        filePath?: string | string[];
+        name?: string | string[];
+        responseType?: 'text' | 'arraybuffer' | 'blob' | 'json';
+    }, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
+     * @param requestId {string} The RequestId of the request to abort
+     */
+    abort(requestId: string): Promise<AbortedResponse>;
 }
+export {};
 
 export declare const HTTP: HTTPOriginal;

index.js

@@ -5,3 +5,3 @@ var __extends = (this && this.__extends) || (function () {
             ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
         return extendStatics(d, b);
@@ -37,15 +37,26 @@ };
     HTTPOriginal.prototype.post = function (url, body, headers) { return cordova(this, "post", {}, arguments); };
+    HTTPOriginal.prototype.postSync = function (url, body, headers, success, failure) { return cordova(this, "post", { "methodName": "post", "sync": true }, arguments); };
     HTTPOriginal.prototype.get = function (url, parameters, headers) { return cordova(this, "get", {}, arguments); };
+    HTTPOriginal.prototype.getSync = function (url, parameters, headers, success, failure) { return cordova(this, "get", { "methodName": "get", "sync": true }, arguments); };
     HTTPOriginal.prototype.put = function (url, body, headers) { return cordova(this, "put", {}, arguments); };
+    HTTPOriginal.prototype.putSync = function (url, body, headers, success, failure) { return cordova(this, "put", { "methodName": "put", "sync": true }, arguments); };
     HTTPOriginal.prototype.patch = function (url, body, headers) { return cordova(this, "patch", {}, arguments); };
+    HTTPOriginal.prototype.patchSync = function (url, body, headers, success, failure) { return cordova(this, "patch", { "methodName": "patch", "sync": true }, arguments); };
     HTTPOriginal.prototype.delete = function (url, parameters, headers) { return cordova(this, "delete", {}, arguments); };
+    HTTPOriginal.prototype.deleteSync = function (url, parameters, headers, success, failure) { return cordova(this, "delete", { "methodName": "delete", "sync": true }, arguments); };
     HTTPOriginal.prototype.head = function (url, parameters, headers) { return cordova(this, "head", {}, arguments); };
+    HTTPOriginal.prototype.headSync = function (url, parameters, headers, success, failure) { return cordova(this, "head", { "methodName": "head", "sync": true }, arguments); };
     HTTPOriginal.prototype.options = function (url, parameters, headers) { return cordova(this, "options", {}, arguments); };
+    HTTPOriginal.prototype.optionsSync = function (url, parameters, headers, success, failure) { return cordova(this, "options", { "methodName": "options", "sync": true }, arguments); };
     HTTPOriginal.prototype.uploadFile = function (url, body, headers, filePath, name) { return cordova(this, "uploadFile", {}, arguments); };
+    HTTPOriginal.prototype.uploadFileSync = function (url, body, headers, filePath, name, success, failure) { return cordova(this, "uploadFile", { "methodName": "uploadFile", "sync": true }, arguments); };
     HTTPOriginal.prototype.downloadFile = function (url, body, headers, filePath) { return cordova(this, "downloadFile", {}, arguments); };
+    HTTPOriginal.prototype.downloadFileSync = function (url, body, headers, filePath, success, failure) { return cordova(this, "downloadFile", { "methodName": "downloadFile", "sync": true }, arguments); };
     HTTPOriginal.prototype.sendRequest = function (url, options) { return cordova(this, "sendRequest", {}, arguments); };
+    HTTPOriginal.prototype.sendRequestSync = function (url, options, success, failure) { return cordova(this, "sendRequest", { "methodName": "sendRequest", "sync": true }, arguments); };
+    HTTPOriginal.prototype.abort = function (requestId) { return cordova(this, "abort", {}, arguments); };
     Object.defineProperty(HTTPOriginal.prototype, "ErrorCode", {
         get: function () { return cordovaPropertyGet(this, "ErrorCode"); },
         set: function (value) { cordovaPropertySet(this, "ErrorCode", value); },
-        enumerable: true,
+        enumerable: false,
         configurable: true
@@ -62,2 +73,2 @@ });
 export { HTTP };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/@ionic-native/plugins/http/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AACA,OAAO,sEAAuD,MAAM,oBAAoB,CAAC;;IAuE/D,wBAAiB;;;;IAuBzC,iCAAkB,aAAC,QAAgB,EAAE,QAAgB;IAUrD,2BAAY,aAAC,QAAgB,EAAE,QAAgB;IAQ/C,yBAAU,aAAC,IAAY;IAWvB,wBAAS,aAAC,IAAY,EAAE,MAAc,EAAE,KAAa;IAOrD,gCAAiB;IAUjB,gCAAiB,aAAC,UAAgE;IAQlF,wBAAS,aAAC,GAAW,EAAE,MAAc;IAMrC,2BAAY;IAQZ,4BAAa,aAAC,GAAW,EAAE,EAAc;IAOzC,8BAAe,aAAC,GAAW;IAS3B,gCAAiB;IASjB,gCAAiB,aAAC,OAAe;IAOjC,gCAAiB;IASjB,gCAAiB,aAAC,MAAe;IAYjC,iCAAkB,aAAC,IAAiD;IAYpE,mBAAI,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY;IAYzC,kBAAG,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAY9C,kBAAG,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY;IAYxC,oBAAK,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY;IAY1C,qBAAM,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAYjD,mBAAI,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAY/C,sBAAO,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAclD,yBAAU,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY,EAAE,QAA2B,EAAE,IAAuB;IAarG,2BAAY,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY,EAAE,QAAgB;IAqBnE,0BAAW,aACT,GAAW,EACX,OAUC;0BA1RM,2BAAS;;;;;;;;;;;eA9EpB;EAwE0B,iBAAiB;SAA9B,IAAI","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Cordova, CordovaProperty, IonicNativePlugin, Plugin } from '@ionic-native/core';\n\nexport interface HTTPResponse {\n  /**\n   * The HTTP status number of the response or a negative internal error code.\n   */\n  status: number;\n  /**\n   * The headers of the response.\n   */\n  headers: { [key: string]: string };\n  /**\n   * The URL of the response. This property will be the final URL obtained after any redirects.\n   */\n  url: string;\n  /**\n   * The data that is in the response. This property usually exists when a promise returned by a request method resolves.\n   */\n  data?: any;\n  /**\n   * Error response from the server. This property usually exists when a promise returned by a request method rejects.\n   */\n  error?: string;\n}\n\n/**\n * @name HTTP\n * @description\n * Cordova / Phonegap plugin for communicating with HTTP servers. Supports iOS and Android.\n *\n * Advantages over Javascript requests:\n * - SSL / TLS Pinning\n * - CORS restrictions do not apply\n * - Handling of HTTP code 401 - read more at [Issue CB-2415](https://issues.apache.org/jira/browse/CB-2415)\n *\n * @usage\n * ```typescript\n * import { HTTP } from '@ionic-native/http/ngx';\n *\n * constructor(private http: HTTP) {}\n *\n * ...\n *\n * this.http.get('http://ionic.io', {}, {})\n *   .then(data => {\n *\n *     console.log(data.status);\n *     console.log(data.data); // data received by server\n *     console.log(data.headers);\n *\n *   })\n *   .catch(error => {\n *\n *     console.log(error.status);\n *     console.log(error.error); // error message as string\n *     console.log(error.headers);\n *\n *   });\n *\n * ```\n * @interfaces\n * HTTPResponse\n */\n@Plugin({\n  pluginName: 'HTTP',\n  plugin: 'cordova-plugin-advanced-http',\n  pluginRef: 'cordova.plugin.http',\n  repo: 'https://github.com/silkimen/cordova-plugin-advanced-http',\n  platforms: ['Android', 'iOS'],\n})\n@Injectable()\nexport class HTTP extends IonicNativePlugin {\n  /**\n   * This enum represents the internal error codes which can be returned in a HTTPResponse object.\n   * @readonly\n   */\n  @CordovaProperty()\n  readonly ErrorCode: {\n    GENERIC: number;\n    SSL_EXCEPTION: number;\n    SERVER_NOT_FOUND: number;\n    TIMEOUT: number;\n    UNSUPPORTED_URL: number;\n    NOT_CONNECTED: number;\n    POST_PROCESSING_FAILED: number;\n  };\n\n  /**\n   * This returns an object representing a basic HTTP Authorization header of the form.\n   * @param username {string} Username\n   * @param password {string} Password\n   * @returns {Object} an object representing a basic HTTP Authorization header of the form {'Authorization': 'Basic base64EncodedUsernameAndPassword'}\n   */\n  @Cordova({ sync: true })\n  getBasicAuthHeader(username: string, password: string): { Authorization: string } {\n    return;\n  }\n\n  /**\n   * This sets up all future requests to use Basic HTTP authentication with the given username and password.\n   * @param username {string} Username\n   * @param password {string} Password\n   */\n  @Cordova({ sync: true })\n  useBasicAuth(username: string, password: string): void {}\n\n  /**\n   * Get all headers defined for a given hostname.\n   * @param host {string} The hostname\n   * @returns {string} return all headers defined for the hostname\n   */\n  @Cordova({ sync: true })\n  getHeaders(host: string): string {\n    return;\n  }\n\n  /**\n   * Set a header for all future requests. Takes a hostname, a header and a value.\n   * @param host {string} The hostname to be used for scoping this header\n   * @param header {string} The name of the header\n   * @param value {string} The value of the header\n   */\n  @Cordova({ sync: true })\n  setHeader(host: string, header: string, value: string): void {}\n\n  /**\n   * Get the name of the data serializer which will be used for all future POST and PUT requests.\n   * @returns {string} returns the name of the configured data serializer\n   */\n  @Cordova({ sync: true })\n  getDataSerializer(): string {\n    return;\n  }\n\n  /**\n   * Set the data serializer which will be used for all future POST, PUT and PATCH requests. Takes a string representing the name of the serializer.\n   * @param serializer {string} The name of the serializer.\n   * @see https://github.com/silkimen/cordova-plugin-advanced-http#setdataserializer\n   */\n  @Cordova({ sync: true })\n  setDataSerializer(serializer: 'urlencoded' | 'json' | 'utf8' | 'multipart' | 'raw'): void {}\n\n  /**\n   * Add a custom cookie.\n   * @param url {string} Scope of the cookie\n   * @param cookie {string} RFC compliant cookie string\n   */\n  @Cordova({ sync: true })\n  setCookie(url: string, cookie: string): void {}\n\n  /**\n   * Clear all cookies.\n   */\n  @Cordova({ sync: true })\n  clearCookies(): void {}\n\n  /**\n   * Remove cookies for given URL.\n   * @param url {string}\n   * @param cb\n   */\n  @Cordova({ sync: true })\n  removeCookies(url: string, cb: () => void): void {}\n\n  /**\n   * Resolve cookie string for given URL.\n   * @param url {string}\n   */\n  @Cordova({ sync: true })\n  getCookieString(url: string): string {\n    return;\n  }\n\n  /**\n   * Get global request timeout value in seconds.\n   * @returns {number} returns the global request timeout value\n   */\n  @Cordova({ sync: true })\n  getRequestTimeout(): number {\n    return;\n  }\n\n  /**\n   * Set global request timeout value in seconds.\n   * @param timeout {number} The timeout in seconds. Default 60\n   */\n  @Cordova({ sync: true })\n  setRequestTimeout(timeout: number): void {}\n\n  /**\n   * Resolve if it should follow redirects automatically.\n   * @returns {boolean} returns true if it is configured to follow redirects automatically\n   */\n  @Cordova({ sync: true })\n  getFollowRedirect(): boolean {\n    return;\n  }\n\n  /**\n   * Configure if it should follow redirects automatically.\n   * @param follow {boolean} Set to false to disable following redirects automatically\n   */\n  @Cordova({ sync: true })\n  setFollowRedirect(follow: boolean): void {}\n\n  /**\n   * Set server trust mode, being one of the following values:\n   * default: default SSL trustship and hostname verification handling using system's CA certs;\n   * legacy: use legacy default behavior (< 2.0.3), excluding user installed CA certs (only for Android);\n   * nocheck: disable SSL certificate checking and hostname verification, trusting all certs (meant to be used only for testing purposes);\n   * pinned: trust only provided certificates;\n   * @see https://github.com/silkimen/cordova-plugin-advanced-http#setservertrustmode\n   * @param {string} mode server trust mode\n   */\n  @Cordova()\n  setServerTrustMode(mode: 'default' | 'legacy' | 'nocheck' | 'pinned'): Promise<void> {\n    return;\n  }\n\n  /**\n   * Make a POST request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  post(url: string, body: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a GET request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  get(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a PUT request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  put(url: string, body: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a PATCH request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  patch(url: string, body: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a DELETE request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  delete(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a HEAD request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  head(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make an OPTIONS request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  options(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param filePath {string} The local path(s) of the file(s) to upload\n   * @param name {string} The name(s) of the parameter to pass the file(s) along as\n   * @returns {Promise<any>} returns a FileEntry promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  uploadFile(url: string, body: any, headers: any, filePath: string | string[], name: string | string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param filePath {string} The path to download the file to, including the file name.\n   * @returns {Promise<any>} returns a FileEntry promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  downloadFile(url: string, body: any, headers: any, filePath: string): Promise<any> {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param options {Object} options for individual request\n   * @param options.method {string} request method\n   * @param options.data {Object} payload to be send to the server (only applicable on post, put or patch methods)\n   * @param options.params {Object} query params to be appended to the URL (only applicable on get, head, delete, upload or download methods)\n   * @param options.serializer {string} data serializer to be used (only applicable on post, put or patch methods), defaults to global serializer value, see setDataSerializer for supported values\n   * @param options.timeout {number} timeout value for the request in seconds, defaults to global timeout value\n   * @param options.headers {Object} headers object (key value pair), will be merged with global values\n   * @param options.filePath {string} file path(s) to be used during upload and download see uploadFile and downloadFile for detailed information\n   * @param options.name {string} name(s) to be used during upload see uploadFile for detailed information\n   * @param options.responseType {string} response type, defaults to text\n   *\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  sendRequest(\n    url: string,\n    options: {\n      method: 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'upload' | 'download';\n      data?: { [index: string]: any };\n      params?: { [index: string]: string | number };\n      serializer?: 'json' | 'urlencoded' | 'utf8' | 'multipart' | 'raw';\n      timeout?: number;\n      headers?: { [index: string]: string };\n      filePath?: string | string[];\n      name?: string | string[];\n      responseType?: 'text' | 'arraybuffer' | 'blob' | 'json';\n    }\n  ): Promise<HTTPResponse> {\n    return;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/@ionic-native/plugins/http/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AACA,OAAO,sEAAuD,MAAM,oBAAoB,CAAC;;IA2E/D,wBAAiB;;;;IAwBzC,iCAAkB,aAAC,QAAgB,EAAE,QAAgB;IAUrD,2BAAY,aAAC,QAAgB,EAAE,QAAgB;IAQ/C,yBAAU,aAAC,IAAY;IAWvB,wBAAS,aAAC,IAAY,EAAE,MAAc,EAAE,KAAa;IAOrD,gCAAiB;IAUjB,gCAAiB,aAAC,UAAgE;IAQlF,wBAAS,aAAC,GAAW,EAAE,MAAc;IAMrC,2BAAY;IAQZ,4BAAa,aAAC,GAAW,EAAE,EAAc;IAOzC,8BAAe,aAAC,GAAW;IAS3B,gCAAiB;IASjB,gCAAiB,aAAC,OAAe;IAOjC,gCAAiB;IASjB,gCAAiB,aAAC,MAAe;IAYjC,iCAAkB,aAAC,IAAiD;IAYpE,mBAAI,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY;IAiBzC,uBAAQ,aACN,GAAW,EACX,IAAS,EACT,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAa/B,kBAAG,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAiB9C,sBAAO,aACL,GAAW,EACX,UAAe,EACf,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAa/B,kBAAG,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY;IAiBxC,sBAAO,aACL,GAAW,EACX,IAAS,EACT,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAa/B,oBAAK,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY;IAiB1C,wBAAS,aACP,GAAW,EACX,IAAS,EACT,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAa/B,qBAAM,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAiBjD,yBAAU,aACR,GAAW,EACX,UAAe,EACf,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAa/B,mBAAI,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAiB/C,uBAAQ,aACN,GAAW,EACX,UAAe,EACf,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAa/B,sBAAO,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAiBlD,0BAAW,aACT,GAAW,EACX,UAAe,EACf,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAe/B,yBAAU,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY,EAAE,QAA2B,EAAE,IAAuB;IAmBrG,6BAAc,aACZ,GAAW,EACX,IAAS,EACT,OAAY,EACZ,QAA2B,EAC3B,IAAuB,EACvB,OAA8B,EAC9B,OAA6B;IAc/B,2BAAY,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY,EAAE,QAAgB;IAkBnE,+BAAgB,aACd,GAAW,EACX,IAAS,EACT,OAAY,EACZ,QAAgB,EAChB,OAA8B,EAC9B,OAA6B;IAsB/B,0BAAW,aACT,GAAW,EACX,OAUC;IA2BH,8BAAe,aACb,GAAW,EACX,OAUC,EACD,OAAuC,EACvC,OAA6B;IAS/B,oBAAK,aAAC,SAAiB;0BAliBd,2BAAS;;;;;;;;;;;eAlFpB;EA4E0B,iBAAiB;SAA9B,IAAI","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Cordova, CordovaProperty, IonicNativePlugin, Plugin } from '@ionic-native/core';\n\nexport interface HTTPResponse {\n  /**\n   * The HTTP status number of the response or a negative internal error code.\n   */\n  status: number;\n  /**\n   * The headers of the response.\n   */\n  headers: { [key: string]: string };\n  /**\n   * The URL of the response. This property will be the final URL obtained after any redirects.\n   */\n  url: string;\n  /**\n   * The data that is in the response. This property usually exists when a promise returned by a request method resolves.\n   */\n  data?: any;\n  /**\n   * Error response from the server. This property usually exists when a promise returned by a request method rejects.\n   */\n  error?: string;\n}\n\ninterface AbortedResponse {\n  aborted: boolean;\n}\n\n/**\n * @name HTTP\n * @description\n * Cordova / Phonegap plugin for communicating with HTTP servers. Supports iOS and Android.\n *\n * Advantages over Javascript requests:\n * - SSL / TLS Pinning\n * - CORS restrictions do not apply\n * - Handling of HTTP code 401 - read more at [Issue CB-2415](https://issues.apache.org/jira/browse/CB-2415)\n *\n * @usage\n * ```typescript\n * import { HTTP } from '@ionic-native/http/ngx';\n *\n * constructor(private http: HTTP) {}\n *\n * ...\n *\n * this.http.get('http://ionic.io', {}, {})\n *   .then(data => {\n *\n *     console.log(data.status);\n *     console.log(data.data); // data received by server\n *     console.log(data.headers);\n *\n *   })\n *   .catch(error => {\n *\n *     console.log(error.status);\n *     console.log(error.error); // error message as string\n *     console.log(error.headers);\n *\n *   });\n *\n * ```\n * @interfaces\n * HTTPResponse\n */\n@Plugin({\n  pluginName: 'HTTP',\n  plugin: 'cordova-plugin-advanced-http',\n  pluginRef: 'cordova.plugin.http',\n  repo: 'https://github.com/silkimen/cordova-plugin-advanced-http',\n  platforms: ['Android', 'iOS'],\n})\n@Injectable()\nexport class HTTP extends IonicNativePlugin {\n  /**\n   * This enum represents the internal error codes which can be returned in a HTTPResponse object.\n   * @readonly\n   */\n  @CordovaProperty()\n  readonly ErrorCode: {\n    GENERIC: number;\n    SSL_EXCEPTION: number;\n    SERVER_NOT_FOUND: number;\n    TIMEOUT: number;\n    UNSUPPORTED_URL: number;\n    NOT_CONNECTED: number;\n    POST_PROCESSING_FAILED: number;\n    ABORTED: number;\n  };\n\n  /**\n   * This returns an object representing a basic HTTP Authorization header of the form.\n   * @param username {string} Username\n   * @param password {string} Password\n   * @returns {Object} an object representing a basic HTTP Authorization header of the form {'Authorization': 'Basic base64EncodedUsernameAndPassword'}\n   */\n  @Cordova({ sync: true })\n  getBasicAuthHeader(username: string, password: string): { Authorization: string } {\n    return;\n  }\n\n  /**\n   * This sets up all future requests to use Basic HTTP authentication with the given username and password.\n   * @param username {string} Username\n   * @param password {string} Password\n   */\n  @Cordova({ sync: true })\n  useBasicAuth(username: string, password: string): void {}\n\n  /**\n   * Get all headers defined for a given hostname.\n   * @param host {string} The hostname\n   * @returns {string} return all headers defined for the hostname\n   */\n  @Cordova({ sync: true })\n  getHeaders(host: string): string {\n    return;\n  }\n\n  /**\n   * Set a header for all future requests. Takes a hostname, a header and a value.\n   * @param host {string} The hostname to be used for scoping this header\n   * @param header {string} The name of the header\n   * @param value {string} The value of the header\n   */\n  @Cordova({ sync: true })\n  setHeader(host: string, header: string, value: string): void {}\n\n  /**\n   * Get the name of the data serializer which will be used for all future POST and PUT requests.\n   * @returns {string} returns the name of the configured data serializer\n   */\n  @Cordova({ sync: true })\n  getDataSerializer(): string {\n    return;\n  }\n\n  /**\n   * Set the data serializer which will be used for all future POST, PUT and PATCH requests. Takes a string representing the name of the serializer.\n   * @param serializer {string} The name of the serializer.\n   * @see https://github.com/silkimen/cordova-plugin-advanced-http#setdataserializer\n   */\n  @Cordova({ sync: true })\n  setDataSerializer(serializer: 'urlencoded' | 'json' | 'utf8' | 'multipart' | 'raw'): void {}\n\n  /**\n   * Add a custom cookie.\n   * @param url {string} Scope of the cookie\n   * @param cookie {string} RFC compliant cookie string\n   */\n  @Cordova({ sync: true })\n  setCookie(url: string, cookie: string): void {}\n\n  /**\n   * Clear all cookies.\n   */\n  @Cordova({ sync: true })\n  clearCookies(): void {}\n\n  /**\n   * Remove cookies for given URL.\n   * @param url {string}\n   * @param cb\n   */\n  @Cordova({ sync: true })\n  removeCookies(url: string, cb: () => void): void {}\n\n  /**\n   * Resolve cookie string for given URL.\n   * @param url {string}\n   */\n  @Cordova({ sync: true })\n  getCookieString(url: string): string {\n    return;\n  }\n\n  /**\n   * Get global request timeout value in seconds.\n   * @returns {number} returns the global request timeout value\n   */\n  @Cordova({ sync: true })\n  getRequestTimeout(): number {\n    return;\n  }\n\n  /**\n   * Set global request timeout value in seconds.\n   * @param timeout {number} The timeout in seconds. Default 60\n   */\n  @Cordova({ sync: true })\n  setRequestTimeout(timeout: number): void {}\n\n  /**\n   * Resolve if it should follow redirects automatically.\n   * @returns {boolean} returns true if it is configured to follow redirects automatically\n   */\n  @Cordova({ sync: true })\n  getFollowRedirect(): boolean {\n    return;\n  }\n\n  /**\n   * Configure if it should follow redirects automatically.\n   * @param follow {boolean} Set to false to disable following redirects automatically\n   */\n  @Cordova({ sync: true })\n  setFollowRedirect(follow: boolean): void {}\n\n  /**\n   * Set server trust mode, being one of the following values:\n   * default: default SSL trustship and hostname verification handling using system's CA certs;\n   * legacy: use legacy default behavior (< 2.0.3), excluding user installed CA certs (only for Android);\n   * nocheck: disable SSL certificate checking and hostname verification, trusting all certs (meant to be used only for testing purposes);\n   * pinned: trust only provided certificates;\n   * @see https://github.com/silkimen/cordova-plugin-advanced-http#setservertrustmode\n   * @param {string} mode server trust mode\n   */\n  @Cordova()\n  setServerTrustMode(mode: 'default' | 'legacy' | 'nocheck' | 'pinned'): Promise<void> {\n    return;\n  }\n\n  /**\n   * Make a POST request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  post(url: string, body: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a sync POST request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'post',\n    sync: true,\n  })\n  postSync(\n    url: string,\n    body: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * Make a GET request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  get(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a sync GET request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'get',\n    sync: true,\n  })\n  getSync(\n    url: string,\n    parameters: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * Make a PUT request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  put(url: string, body: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a sync PUT request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'put',\n    sync: true,\n  })\n  putSync(\n    url: string,\n    body: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * Make a PATCH request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  patch(url: string, body: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a sync PATCH request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'patch',\n    sync: true,\n  })\n  patchSync(\n    url: string,\n    body: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * Make a DELETE request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  delete(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a sync DELETE request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'delete',\n    sync: true,\n  })\n  deleteSync(\n    url: string,\n    parameters: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * Make a HEAD request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  head(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a sync HEAD request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'head',\n    sync: true,\n  })\n  headSync(\n    url: string,\n    parameters: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * Make an OPTIONS request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  options(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make an sync OPTIONS request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'options',\n    sync: true,\n  })\n  optionsSync(\n    url: string,\n    parameters: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param filePath {string} The local path(s) of the file(s) to upload\n   * @param name {string} The name(s) of the parameter to pass the file(s) along as\n   * @returns {Promise<any>} returns a FileEntry promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  uploadFile(url: string, body: any, headers: any, filePath: string | string[], name: string | string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param filePath {string} The local path(s) of the file(s) to upload\n   * @param name {string} The name(s) of the parameter to pass the file(s) along as\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'uploadFile',\n    sync: true,\n  })\n  uploadFileSync(\n    url: string,\n    body: any,\n    headers: any,\n    filePath: string | string[],\n    name: string | string[],\n    success: (result: any) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param filePath {string} The path to download the file to, including the file name.\n   * @returns {Promise<any>} returns a FileEntry promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  downloadFile(url: string, body: any, headers: any, filePath: string): Promise<any> {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param filePath {string} The path to download the file to, including the file name.\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'downloadFile',\n    sync: true,\n  })\n  downloadFileSync(\n    url: string,\n    body: any,\n    headers: any,\n    filePath: string,\n    success: (result: any) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param options {Object} options for individual request\n   * @param options.method {string} request method\n   * @param options.data {Object} payload to be send to the server (only applicable on post, put or patch methods)\n   * @param options.params {Object} query params to be appended to the URL (only applicable on get, head, delete, upload or download methods)\n   * @param options.serializer {string} data serializer to be used (only applicable on post, put or patch methods), defaults to global serializer value, see setDataSerializer for supported values\n   * @param options.timeout {number} timeout value for the request in seconds, defaults to global timeout value\n   * @param options.headers {Object} headers object (key value pair), will be merged with global values\n   * @param options.filePath {string} file path(s) to be used during upload and download see uploadFile and downloadFile for detailed information\n   * @param options.name {string} name(s) to be used during upload see uploadFile for detailed information\n   * @param options.responseType {string} response type, defaults to text\n   *\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  sendRequest(\n    url: string,\n    options: {\n      method: 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'upload' | 'download';\n      data?: { [index: string]: any };\n      params?: { [index: string]: string | number };\n      serializer?: 'json' | 'urlencoded' | 'utf8' | 'multipart' | 'raw';\n      timeout?: number;\n      headers?: { [index: string]: string };\n      filePath?: string | string[];\n      name?: string | string[];\n      responseType?: 'text' | 'arraybuffer' | 'blob' | 'json';\n    }\n  ): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param options {Object} options for individual request\n   * @param options.method {string} request method\n   * @param options.data {Object} payload to be send to the server (only applicable on post, put or patch methods)\n   * @param options.params {Object} query params to be appended to the URL (only applicable on get, head, delete, upload or download methods)\n   * @param options.serializer {string} data serializer to be used (only applicable on post, put or patch methods), defaults to global serializer value, see setDataSerializer for supported values\n   * @param options.timeout {number} timeout value for the request in seconds, defaults to global timeout value\n   * @param options.headers {Object} headers object (key value pair), will be merged with global values\n   * @param options.filePath {string} file path(s) to be used during upload and download see uploadFile and downloadFile for detailed information\n   * @param options.name {string} name(s) to be used during upload see uploadFile for detailed information\n   * @param options.responseType {string} response type, defaults to text\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   *\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'sendRequest',\n    sync: true,\n  })\n  sendRequestSync(\n    url: string,\n    options: {\n      method: 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'upload' | 'download';\n      data?: { [index: string]: any };\n      params?: { [index: string]: string | number };\n      serializer?: 'json' | 'urlencoded' | 'utf8' | 'multipart';\n      timeout?: number;\n      headers?: { [index: string]: string };\n      filePath?: string | string[];\n      name?: string | string[];\n      responseType?: 'text' | 'arraybuffer' | 'blob' | 'json';\n    },\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * @param requestId {string} The RequestId of the request to abort\n   */\n  @Cordova()\n  abort(requestId: string): Promise<AbortedResponse> {\n    return;\n  }\n}\n"]}

ngx/index.d.ts

@@ -26,2 +26,5 @@ import { IonicNativePlugin } from '@ionic-native/core';
 }
+interface AbortedResponse {
+    aborted: boolean;
+}
 /**
@@ -78,2 +81,3 @@ * @name HTTP
         POST_PROCESSING_FAILED: number;
+        ABORTED: number;
     };
@@ -179,2 +183,12 @@ /**
     /**
+     * Make a sync POST request
+     * @param url {string} The url to send the request to
+     * @param body {Object} The body of the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    postSync(url: string, body: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      * Make a GET request
@@ -188,2 +202,12 @@ * @param url {string} The url to send the request to
     /**
+     * Make a sync GET request
+     * @param url {string} The url to send the request to
+     * @param parameters {Object} Parameters to send with the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    getSync(url: string, parameters: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      * Make a PUT request
@@ -197,2 +221,12 @@ * @param url {string} The url to send the request to
     /**
+     * Make a sync PUT request
+     * @param url {string} The url to send the request to
+     * @param body {Object} The body of the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    putSync(url: string, body: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      * Make a PATCH request
@@ -206,2 +240,12 @@ * @param url {string} The url to send the request to
     /**
+     * Make a sync PATCH request
+     * @param url {string} The url to send the request to
+     * @param body {Object} The body of the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    patchSync(url: string, body: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      * Make a DELETE request
@@ -215,2 +259,12 @@ * @param url {string} The url to send the request to
     /**
+     * Make a sync DELETE request
+     * @param url {string} The url to send the request to
+     * @param parameters {Object} Parameters to send with the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    deleteSync(url: string, parameters: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      * Make a HEAD request
@@ -224,2 +278,12 @@ * @param url {string} The url to send the request to
     /**
+     * Make a sync HEAD request
+     * @param url {string} The url to send the request to
+     * @param parameters {Object} Parameters to send with the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    headSync(url: string, parameters: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      * Make an OPTIONS request
@@ -233,2 +297,12 @@ * @param url {string} The url to send the request to
     /**
+     * Make an sync OPTIONS request
+     * @param url {string} The url to send the request to
+     * @param parameters {Object} Parameters to send with the request
+     * @param headers {Object} The headers to set for this request
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    optionsSync(url: string, parameters: any, headers: any, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
      *
@@ -248,2 +322,14 @@ * @param url {string} The url to send the request to
      * @param headers {Object} The headers to set for this request
+     * @param filePath {string} The local path(s) of the file(s) to upload
+     * @param name {string} The name(s) of the parameter to pass the file(s) along as
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    uploadFileSync(url: string, body: any, headers: any, filePath: string | string[], name: string | string[], success: (result: any) => void, failure: (error: any) => void): string;
+    /**
+     *
+     * @param url {string} The url to send the request to
+     * @param body {Object} The body of the request
+     * @param headers {Object} The headers to set for this request
      * @param filePath {string} The path to download the file to, including the file name.
@@ -256,2 +342,13 @@ * @returns {Promise<any>} returns a FileEntry promise that will resolve on success, and reject on failure
      * @param url {string} The url to send the request to
+     * @param body {Object} The body of the request
+     * @param headers {Object} The headers to set for this request
+     * @param filePath {string} The path to download the file to, including the file name.
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     * @returns {string} returns a string that represents the requestId
+     */
+    downloadFileSync(url: string, body: any, headers: any, filePath: string, success: (result: any) => void, failure: (error: any) => void): string;
+    /**
+     *
+     * @param url {string} The url to send the request to
      * @param options {Object} options for individual request
@@ -287,2 +384,42 @@ * @param options.method {string} request method
     }): Promise<HTTPResponse>;
+    /**
+     *
+     * @param url {string} The url to send the request to
+     * @param options {Object} options for individual request
+     * @param options.method {string} request method
+     * @param options.data {Object} payload to be send to the server (only applicable on post, put or patch methods)
+     * @param options.params {Object} query params to be appended to the URL (only applicable on get, head, delete, upload or download methods)
+     * @param options.serializer {string} data serializer to be used (only applicable on post, put or patch methods), defaults to global serializer value, see setDataSerializer for supported values
+     * @param options.timeout {number} timeout value for the request in seconds, defaults to global timeout value
+     * @param options.headers {Object} headers object (key value pair), will be merged with global values
+     * @param options.filePath {string} file path(s) to be used during upload and download see uploadFile and downloadFile for detailed information
+     * @param options.name {string} name(s) to be used during upload see uploadFile for detailed information
+     * @param options.responseType {string} response type, defaults to text
+     * @param success {function} A callback that is called when the request succeed
+     * @param failure {function} A callback that is called when the request failed
+     *
+     * @returns {string} returns a string that represents the requestId
+     */
+    sendRequestSync(url: string, options: {
+        method: 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'upload' | 'download';
+        data?: {
+            [index: string]: any;
+        };
+        params?: {
+            [index: string]: string | number;
+        };
+        serializer?: 'json' | 'urlencoded' | 'utf8' | 'multipart';
+        timeout?: number;
+        headers?: {
+            [index: string]: string;
+        };
+        filePath?: string | string[];
+        name?: string | string[];
+        responseType?: 'text' | 'arraybuffer' | 'blob' | 'json';
+    }, success: (result: HTTPResponse) => void, failure: (error: any) => void): string;
+    /**
+     * @param requestId {string} The RequestId of the request to abort
+     */
+    abort(requestId: string): Promise<AbortedResponse>;
 }
+export {};

ngx/index.js

@@ -1,2 +0,2 @@
-import { __decorate, __extends } from "tslib";
+import { __extends } from "tslib";
 import { Injectable } from '@angular/core';
@@ -25,15 +25,26 @@ import { IonicNativePlugin, cordova, cordovaPropertyGet, cordovaPropertySet } from '@ionic-native/core';
     HTTP.prototype.post = function (url, body, headers) { return cordova(this, "post", {}, arguments); };
+    HTTP.prototype.postSync = function (url, body, headers, success, failure) { return cordova(this, "post", { "methodName": "post", "sync": true }, arguments); };
     HTTP.prototype.get = function (url, parameters, headers) { return cordova(this, "get", {}, arguments); };
+    HTTP.prototype.getSync = function (url, parameters, headers, success, failure) { return cordova(this, "get", { "methodName": "get", "sync": true }, arguments); };
     HTTP.prototype.put = function (url, body, headers) { return cordova(this, "put", {}, arguments); };
+    HTTP.prototype.putSync = function (url, body, headers, success, failure) { return cordova(this, "put", { "methodName": "put", "sync": true }, arguments); };
     HTTP.prototype.patch = function (url, body, headers) { return cordova(this, "patch", {}, arguments); };
+    HTTP.prototype.patchSync = function (url, body, headers, success, failure) { return cordova(this, "patch", { "methodName": "patch", "sync": true }, arguments); };
     HTTP.prototype.delete = function (url, parameters, headers) { return cordova(this, "delete", {}, arguments); };
+    HTTP.prototype.deleteSync = function (url, parameters, headers, success, failure) { return cordova(this, "delete", { "methodName": "delete", "sync": true }, arguments); };
     HTTP.prototype.head = function (url, parameters, headers) { return cordova(this, "head", {}, arguments); };
+    HTTP.prototype.headSync = function (url, parameters, headers, success, failure) { return cordova(this, "head", { "methodName": "head", "sync": true }, arguments); };
     HTTP.prototype.options = function (url, parameters, headers) { return cordova(this, "options", {}, arguments); };
+    HTTP.prototype.optionsSync = function (url, parameters, headers, success, failure) { return cordova(this, "options", { "methodName": "options", "sync": true }, arguments); };
     HTTP.prototype.uploadFile = function (url, body, headers, filePath, name) { return cordova(this, "uploadFile", {}, arguments); };
+    HTTP.prototype.uploadFileSync = function (url, body, headers, filePath, name, success, failure) { return cordova(this, "uploadFile", { "methodName": "uploadFile", "sync": true }, arguments); };
     HTTP.prototype.downloadFile = function (url, body, headers, filePath) { return cordova(this, "downloadFile", {}, arguments); };
+    HTTP.prototype.downloadFileSync = function (url, body, headers, filePath, success, failure) { return cordova(this, "downloadFile", { "methodName": "downloadFile", "sync": true }, arguments); };
     HTTP.prototype.sendRequest = function (url, options) { return cordova(this, "sendRequest", {}, arguments); };
+    HTTP.prototype.sendRequestSync = function (url, options, success, failure) { return cordova(this, "sendRequest", { "methodName": "sendRequest", "sync": true }, arguments); };
+    HTTP.prototype.abort = function (requestId) { return cordova(this, "abort", {}, arguments); };
     Object.defineProperty(HTTP.prototype, "ErrorCode", {
         get: function () { return cordovaPropertyGet(this, "ErrorCode"); },
         set: function (value) { cordovaPropertySet(this, "ErrorCode", value); },
-        enumerable: true,
+        enumerable: false,
         configurable: true
@@ -46,8 +57,8 @@ });
     HTTP.platforms = ["Android", "iOS"];
-    HTTP = __decorate([
-        Injectable()
-    ], HTTP);
+    HTTP.decorators = [
+        { type: Injectable }
+    ];
     return HTTP;
 }(IonicNativePlugin));
 export { HTTP };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/@ionic-native/plugins/http/ngx/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,sEAAuD,MAAM,oBAAoB,CAAC;;IAuE/D,wBAAiB;;;;IAuBzC,iCAAkB,aAAC,QAAgB,EAAE,QAAgB;IAUrD,2BAAY,aAAC,QAAgB,EAAE,QAAgB;IAQ/C,yBAAU,aAAC,IAAY;IAWvB,wBAAS,aAAC,IAAY,EAAE,MAAc,EAAE,KAAa;IAOrD,gCAAiB;IAUjB,gCAAiB,aAAC,UAAgE;IAQlF,wBAAS,aAAC,GAAW,EAAE,MAAc;IAMrC,2BAAY;IAQZ,4BAAa,aAAC,GAAW,EAAE,EAAc;IAOzC,8BAAe,aAAC,GAAW;IAS3B,gCAAiB;IASjB,gCAAiB,aAAC,OAAe;IAOjC,gCAAiB;IASjB,gCAAiB,aAAC,MAAe;IAYjC,iCAAkB,aAAC,IAAiD;IAYpE,mBAAI,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY;IAYzC,kBAAG,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAY9C,kBAAG,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY;IAYxC,oBAAK,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY;IAY1C,qBAAM,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAYjD,mBAAI,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAY/C,sBAAO,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAclD,yBAAU,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY,EAAE,QAA2B,EAAE,IAAuB;IAarG,2BAAY,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY,EAAE,QAAgB;IAqBnE,0BAAW,aACT,GAAW,EACX,OAUC;0BA1RM,2BAAS;;;;;;;;;;;IANP,IAAI;QADhB,UAAU,EAAE;OACA,IAAI;eAxEjB;EAwE0B,iBAAiB;SAA9B,IAAI","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Cordova, CordovaProperty, IonicNativePlugin, Plugin } from '@ionic-native/core';\n\nexport interface HTTPResponse {\n  /**\n   * The HTTP status number of the response or a negative internal error code.\n   */\n  status: number;\n  /**\n   * The headers of the response.\n   */\n  headers: { [key: string]: string };\n  /**\n   * The URL of the response. This property will be the final URL obtained after any redirects.\n   */\n  url: string;\n  /**\n   * The data that is in the response. This property usually exists when a promise returned by a request method resolves.\n   */\n  data?: any;\n  /**\n   * Error response from the server. This property usually exists when a promise returned by a request method rejects.\n   */\n  error?: string;\n}\n\n/**\n * @name HTTP\n * @description\n * Cordova / Phonegap plugin for communicating with HTTP servers. Supports iOS and Android.\n *\n * Advantages over Javascript requests:\n * - SSL / TLS Pinning\n * - CORS restrictions do not apply\n * - Handling of HTTP code 401 - read more at [Issue CB-2415](https://issues.apache.org/jira/browse/CB-2415)\n *\n * @usage\n * ```typescript\n * import { HTTP } from '@ionic-native/http/ngx';\n *\n * constructor(private http: HTTP) {}\n *\n * ...\n *\n * this.http.get('http://ionic.io', {}, {})\n *   .then(data => {\n *\n *     console.log(data.status);\n *     console.log(data.data); // data received by server\n *     console.log(data.headers);\n *\n *   })\n *   .catch(error => {\n *\n *     console.log(error.status);\n *     console.log(error.error); // error message as string\n *     console.log(error.headers);\n *\n *   });\n *\n * ```\n * @interfaces\n * HTTPResponse\n */\n@Plugin({\n  pluginName: 'HTTP',\n  plugin: 'cordova-plugin-advanced-http',\n  pluginRef: 'cordova.plugin.http',\n  repo: 'https://github.com/silkimen/cordova-plugin-advanced-http',\n  platforms: ['Android', 'iOS'],\n})\n@Injectable()\nexport class HTTP extends IonicNativePlugin {\n  /**\n   * This enum represents the internal error codes which can be returned in a HTTPResponse object.\n   * @readonly\n   */\n  @CordovaProperty()\n  readonly ErrorCode: {\n    GENERIC: number;\n    SSL_EXCEPTION: number;\n    SERVER_NOT_FOUND: number;\n    TIMEOUT: number;\n    UNSUPPORTED_URL: number;\n    NOT_CONNECTED: number;\n    POST_PROCESSING_FAILED: number;\n  };\n\n  /**\n   * This returns an object representing a basic HTTP Authorization header of the form.\n   * @param username {string} Username\n   * @param password {string} Password\n   * @returns {Object} an object representing a basic HTTP Authorization header of the form {'Authorization': 'Basic base64EncodedUsernameAndPassword'}\n   */\n  @Cordova({ sync: true })\n  getBasicAuthHeader(username: string, password: string): { Authorization: string } {\n    return;\n  }\n\n  /**\n   * This sets up all future requests to use Basic HTTP authentication with the given username and password.\n   * @param username {string} Username\n   * @param password {string} Password\n   */\n  @Cordova({ sync: true })\n  useBasicAuth(username: string, password: string): void {}\n\n  /**\n   * Get all headers defined for a given hostname.\n   * @param host {string} The hostname\n   * @returns {string} return all headers defined for the hostname\n   */\n  @Cordova({ sync: true })\n  getHeaders(host: string): string {\n    return;\n  }\n\n  /**\n   * Set a header for all future requests. Takes a hostname, a header and a value.\n   * @param host {string} The hostname to be used for scoping this header\n   * @param header {string} The name of the header\n   * @param value {string} The value of the header\n   */\n  @Cordova({ sync: true })\n  setHeader(host: string, header: string, value: string): void {}\n\n  /**\n   * Get the name of the data serializer which will be used for all future POST and PUT requests.\n   * @returns {string} returns the name of the configured data serializer\n   */\n  @Cordova({ sync: true })\n  getDataSerializer(): string {\n    return;\n  }\n\n  /**\n   * Set the data serializer which will be used for all future POST, PUT and PATCH requests. Takes a string representing the name of the serializer.\n   * @param serializer {string} The name of the serializer.\n   * @see https://github.com/silkimen/cordova-plugin-advanced-http#setdataserializer\n   */\n  @Cordova({ sync: true })\n  setDataSerializer(serializer: 'urlencoded' | 'json' | 'utf8' | 'multipart' | 'raw'): void {}\n\n  /**\n   * Add a custom cookie.\n   * @param url {string} Scope of the cookie\n   * @param cookie {string} RFC compliant cookie string\n   */\n  @Cordova({ sync: true })\n  setCookie(url: string, cookie: string): void {}\n\n  /**\n   * Clear all cookies.\n   */\n  @Cordova({ sync: true })\n  clearCookies(): void {}\n\n  /**\n   * Remove cookies for given URL.\n   * @param url {string}\n   * @param cb\n   */\n  @Cordova({ sync: true })\n  removeCookies(url: string, cb: () => void): void {}\n\n  /**\n   * Resolve cookie string for given URL.\n   * @param url {string}\n   */\n  @Cordova({ sync: true })\n  getCookieString(url: string): string {\n    return;\n  }\n\n  /**\n   * Get global request timeout value in seconds.\n   * @returns {number} returns the global request timeout value\n   */\n  @Cordova({ sync: true })\n  getRequestTimeout(): number {\n    return;\n  }\n\n  /**\n   * Set global request timeout value in seconds.\n   * @param timeout {number} The timeout in seconds. Default 60\n   */\n  @Cordova({ sync: true })\n  setRequestTimeout(timeout: number): void {}\n\n  /**\n   * Resolve if it should follow redirects automatically.\n   * @returns {boolean} returns true if it is configured to follow redirects automatically\n   */\n  @Cordova({ sync: true })\n  getFollowRedirect(): boolean {\n    return;\n  }\n\n  /**\n   * Configure if it should follow redirects automatically.\n   * @param follow {boolean} Set to false to disable following redirects automatically\n   */\n  @Cordova({ sync: true })\n  setFollowRedirect(follow: boolean): void {}\n\n  /**\n   * Set server trust mode, being one of the following values:\n   * default: default SSL trustship and hostname verification handling using system's CA certs;\n   * legacy: use legacy default behavior (< 2.0.3), excluding user installed CA certs (only for Android);\n   * nocheck: disable SSL certificate checking and hostname verification, trusting all certs (meant to be used only for testing purposes);\n   * pinned: trust only provided certificates;\n   * @see https://github.com/silkimen/cordova-plugin-advanced-http#setservertrustmode\n   * @param {string} mode server trust mode\n   */\n  @Cordova()\n  setServerTrustMode(mode: 'default' | 'legacy' | 'nocheck' | 'pinned'): Promise<void> {\n    return;\n  }\n\n  /**\n   * Make a POST request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  post(url: string, body: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a GET request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  get(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a PUT request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  put(url: string, body: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a PATCH request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  patch(url: string, body: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a DELETE request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  delete(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a HEAD request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  head(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make an OPTIONS request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  options(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param filePath {string} The local path(s) of the file(s) to upload\n   * @param name {string} The name(s) of the parameter to pass the file(s) along as\n   * @returns {Promise<any>} returns a FileEntry promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  uploadFile(url: string, body: any, headers: any, filePath: string | string[], name: string | string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param filePath {string} The path to download the file to, including the file name.\n   * @returns {Promise<any>} returns a FileEntry promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  downloadFile(url: string, body: any, headers: any, filePath: string): Promise<any> {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param options {Object} options for individual request\n   * @param options.method {string} request method\n   * @param options.data {Object} payload to be send to the server (only applicable on post, put or patch methods)\n   * @param options.params {Object} query params to be appended to the URL (only applicable on get, head, delete, upload or download methods)\n   * @param options.serializer {string} data serializer to be used (only applicable on post, put or patch methods), defaults to global serializer value, see setDataSerializer for supported values\n   * @param options.timeout {number} timeout value for the request in seconds, defaults to global timeout value\n   * @param options.headers {Object} headers object (key value pair), will be merged with global values\n   * @param options.filePath {string} file path(s) to be used during upload and download see uploadFile and downloadFile for detailed information\n   * @param options.name {string} name(s) to be used during upload see uploadFile for detailed information\n   * @param options.responseType {string} response type, defaults to text\n   *\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  sendRequest(\n    url: string,\n    options: {\n      method: 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'upload' | 'download';\n      data?: { [index: string]: any };\n      params?: { [index: string]: string | number };\n      serializer?: 'json' | 'urlencoded' | 'utf8' | 'multipart' | 'raw';\n      timeout?: number;\n      headers?: { [index: string]: string };\n      filePath?: string | string[];\n      name?: string | string[];\n      responseType?: 'text' | 'arraybuffer' | 'blob' | 'json';\n    }\n  ): Promise<HTTPResponse> {\n    return;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/@ionic-native/plugins/http/ngx/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,sEAAuD,MAAM,oBAAoB,CAAC;;IA2E/D,wBAAiB;;;;IAwBzC,iCAAkB,aAAC,QAAgB,EAAE,QAAgB;IAUrD,2BAAY,aAAC,QAAgB,EAAE,QAAgB;IAQ/C,yBAAU,aAAC,IAAY;IAWvB,wBAAS,aAAC,IAAY,EAAE,MAAc,EAAE,KAAa;IAOrD,gCAAiB;IAUjB,gCAAiB,aAAC,UAAgE;IAQlF,wBAAS,aAAC,GAAW,EAAE,MAAc;IAMrC,2BAAY;IAQZ,4BAAa,aAAC,GAAW,EAAE,EAAc;IAOzC,8BAAe,aAAC,GAAW;IAS3B,gCAAiB;IASjB,gCAAiB,aAAC,OAAe;IAOjC,gCAAiB;IASjB,gCAAiB,aAAC,MAAe;IAYjC,iCAAkB,aAAC,IAAiD;IAYpE,mBAAI,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY;IAiBzC,uBAAQ,aACN,GAAW,EACX,IAAS,EACT,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAa/B,kBAAG,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAiB9C,sBAAO,aACL,GAAW,EACX,UAAe,EACf,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAa/B,kBAAG,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY;IAiBxC,sBAAO,aACL,GAAW,EACX,IAAS,EACT,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAa/B,oBAAK,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY;IAiB1C,wBAAS,aACP,GAAW,EACX,IAAS,EACT,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAa/B,qBAAM,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAiBjD,yBAAU,aACR,GAAW,EACX,UAAe,EACf,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAa/B,mBAAI,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAiB/C,uBAAQ,aACN,GAAW,EACX,UAAe,EACf,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAa/B,sBAAO,aAAC,GAAW,EAAE,UAAe,EAAE,OAAY;IAiBlD,0BAAW,aACT,GAAW,EACX,UAAe,EACf,OAAY,EACZ,OAAuC,EACvC,OAA6B;IAe/B,yBAAU,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY,EAAE,QAA2B,EAAE,IAAuB;IAmBrG,6BAAc,aACZ,GAAW,EACX,IAAS,EACT,OAAY,EACZ,QAA2B,EAC3B,IAAuB,EACvB,OAA8B,EAC9B,OAA6B;IAc/B,2BAAY,aAAC,GAAW,EAAE,IAAS,EAAE,OAAY,EAAE,QAAgB;IAkBnE,+BAAgB,aACd,GAAW,EACX,IAAS,EACT,OAAY,EACZ,QAAgB,EAChB,OAA8B,EAC9B,OAA6B;IAsB/B,0BAAW,aACT,GAAW,EACX,OAUC;IA2BH,8BAAe,aACb,GAAW,EACX,OAUC,EACD,OAAuC,EACvC,OAA6B;IAS/B,oBAAK,aAAC,SAAiB;0BAliBd,2BAAS;;;;;;;;;;;;gBAPnB,UAAU;;eA3EX;EA4E0B,iBAAiB;SAA9B,IAAI","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Cordova, CordovaProperty, IonicNativePlugin, Plugin } from '@ionic-native/core';\n\nexport interface HTTPResponse {\n  /**\n   * The HTTP status number of the response or a negative internal error code.\n   */\n  status: number;\n  /**\n   * The headers of the response.\n   */\n  headers: { [key: string]: string };\n  /**\n   * The URL of the response. This property will be the final URL obtained after any redirects.\n   */\n  url: string;\n  /**\n   * The data that is in the response. This property usually exists when a promise returned by a request method resolves.\n   */\n  data?: any;\n  /**\n   * Error response from the server. This property usually exists when a promise returned by a request method rejects.\n   */\n  error?: string;\n}\n\ninterface AbortedResponse {\n  aborted: boolean;\n}\n\n/**\n * @name HTTP\n * @description\n * Cordova / Phonegap plugin for communicating with HTTP servers. Supports iOS and Android.\n *\n * Advantages over Javascript requests:\n * - SSL / TLS Pinning\n * - CORS restrictions do not apply\n * - Handling of HTTP code 401 - read more at [Issue CB-2415](https://issues.apache.org/jira/browse/CB-2415)\n *\n * @usage\n * ```typescript\n * import { HTTP } from '@ionic-native/http/ngx';\n *\n * constructor(private http: HTTP) {}\n *\n * ...\n *\n * this.http.get('http://ionic.io', {}, {})\n *   .then(data => {\n *\n *     console.log(data.status);\n *     console.log(data.data); // data received by server\n *     console.log(data.headers);\n *\n *   })\n *   .catch(error => {\n *\n *     console.log(error.status);\n *     console.log(error.error); // error message as string\n *     console.log(error.headers);\n *\n *   });\n *\n * ```\n * @interfaces\n * HTTPResponse\n */\n@Plugin({\n  pluginName: 'HTTP',\n  plugin: 'cordova-plugin-advanced-http',\n  pluginRef: 'cordova.plugin.http',\n  repo: 'https://github.com/silkimen/cordova-plugin-advanced-http',\n  platforms: ['Android', 'iOS'],\n})\n@Injectable()\nexport class HTTP extends IonicNativePlugin {\n  /**\n   * This enum represents the internal error codes which can be returned in a HTTPResponse object.\n   * @readonly\n   */\n  @CordovaProperty()\n  readonly ErrorCode: {\n    GENERIC: number;\n    SSL_EXCEPTION: number;\n    SERVER_NOT_FOUND: number;\n    TIMEOUT: number;\n    UNSUPPORTED_URL: number;\n    NOT_CONNECTED: number;\n    POST_PROCESSING_FAILED: number;\n    ABORTED: number;\n  };\n\n  /**\n   * This returns an object representing a basic HTTP Authorization header of the form.\n   * @param username {string} Username\n   * @param password {string} Password\n   * @returns {Object} an object representing a basic HTTP Authorization header of the form {'Authorization': 'Basic base64EncodedUsernameAndPassword'}\n   */\n  @Cordova({ sync: true })\n  getBasicAuthHeader(username: string, password: string): { Authorization: string } {\n    return;\n  }\n\n  /**\n   * This sets up all future requests to use Basic HTTP authentication with the given username and password.\n   * @param username {string} Username\n   * @param password {string} Password\n   */\n  @Cordova({ sync: true })\n  useBasicAuth(username: string, password: string): void {}\n\n  /**\n   * Get all headers defined for a given hostname.\n   * @param host {string} The hostname\n   * @returns {string} return all headers defined for the hostname\n   */\n  @Cordova({ sync: true })\n  getHeaders(host: string): string {\n    return;\n  }\n\n  /**\n   * Set a header for all future requests. Takes a hostname, a header and a value.\n   * @param host {string} The hostname to be used for scoping this header\n   * @param header {string} The name of the header\n   * @param value {string} The value of the header\n   */\n  @Cordova({ sync: true })\n  setHeader(host: string, header: string, value: string): void {}\n\n  /**\n   * Get the name of the data serializer which will be used for all future POST and PUT requests.\n   * @returns {string} returns the name of the configured data serializer\n   */\n  @Cordova({ sync: true })\n  getDataSerializer(): string {\n    return;\n  }\n\n  /**\n   * Set the data serializer which will be used for all future POST, PUT and PATCH requests. Takes a string representing the name of the serializer.\n   * @param serializer {string} The name of the serializer.\n   * @see https://github.com/silkimen/cordova-plugin-advanced-http#setdataserializer\n   */\n  @Cordova({ sync: true })\n  setDataSerializer(serializer: 'urlencoded' | 'json' | 'utf8' | 'multipart' | 'raw'): void {}\n\n  /**\n   * Add a custom cookie.\n   * @param url {string} Scope of the cookie\n   * @param cookie {string} RFC compliant cookie string\n   */\n  @Cordova({ sync: true })\n  setCookie(url: string, cookie: string): void {}\n\n  /**\n   * Clear all cookies.\n   */\n  @Cordova({ sync: true })\n  clearCookies(): void {}\n\n  /**\n   * Remove cookies for given URL.\n   * @param url {string}\n   * @param cb\n   */\n  @Cordova({ sync: true })\n  removeCookies(url: string, cb: () => void): void {}\n\n  /**\n   * Resolve cookie string for given URL.\n   * @param url {string}\n   */\n  @Cordova({ sync: true })\n  getCookieString(url: string): string {\n    return;\n  }\n\n  /**\n   * Get global request timeout value in seconds.\n   * @returns {number} returns the global request timeout value\n   */\n  @Cordova({ sync: true })\n  getRequestTimeout(): number {\n    return;\n  }\n\n  /**\n   * Set global request timeout value in seconds.\n   * @param timeout {number} The timeout in seconds. Default 60\n   */\n  @Cordova({ sync: true })\n  setRequestTimeout(timeout: number): void {}\n\n  /**\n   * Resolve if it should follow redirects automatically.\n   * @returns {boolean} returns true if it is configured to follow redirects automatically\n   */\n  @Cordova({ sync: true })\n  getFollowRedirect(): boolean {\n    return;\n  }\n\n  /**\n   * Configure if it should follow redirects automatically.\n   * @param follow {boolean} Set to false to disable following redirects automatically\n   */\n  @Cordova({ sync: true })\n  setFollowRedirect(follow: boolean): void {}\n\n  /**\n   * Set server trust mode, being one of the following values:\n   * default: default SSL trustship and hostname verification handling using system's CA certs;\n   * legacy: use legacy default behavior (< 2.0.3), excluding user installed CA certs (only for Android);\n   * nocheck: disable SSL certificate checking and hostname verification, trusting all certs (meant to be used only for testing purposes);\n   * pinned: trust only provided certificates;\n   * @see https://github.com/silkimen/cordova-plugin-advanced-http#setservertrustmode\n   * @param {string} mode server trust mode\n   */\n  @Cordova()\n  setServerTrustMode(mode: 'default' | 'legacy' | 'nocheck' | 'pinned'): Promise<void> {\n    return;\n  }\n\n  /**\n   * Make a POST request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  post(url: string, body: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a sync POST request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'post',\n    sync: true,\n  })\n  postSync(\n    url: string,\n    body: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * Make a GET request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  get(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a sync GET request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'get',\n    sync: true,\n  })\n  getSync(\n    url: string,\n    parameters: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * Make a PUT request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  put(url: string, body: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a sync PUT request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'put',\n    sync: true,\n  })\n  putSync(\n    url: string,\n    body: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * Make a PATCH request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  patch(url: string, body: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a sync PATCH request\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'patch',\n    sync: true,\n  })\n  patchSync(\n    url: string,\n    body: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * Make a DELETE request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  delete(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a sync DELETE request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'delete',\n    sync: true,\n  })\n  deleteSync(\n    url: string,\n    parameters: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * Make a HEAD request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  head(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make a sync HEAD request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'head',\n    sync: true,\n  })\n  headSync(\n    url: string,\n    parameters: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * Make an OPTIONS request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  options(url: string, parameters: any, headers: any): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   * Make an sync OPTIONS request\n   * @param url {string} The url to send the request to\n   * @param parameters {Object} Parameters to send with the request\n   * @param headers {Object} The headers to set for this request\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'options',\n    sync: true,\n  })\n  optionsSync(\n    url: string,\n    parameters: any,\n    headers: any,\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param filePath {string} The local path(s) of the file(s) to upload\n   * @param name {string} The name(s) of the parameter to pass the file(s) along as\n   * @returns {Promise<any>} returns a FileEntry promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  uploadFile(url: string, body: any, headers: any, filePath: string | string[], name: string | string[]): Promise<any> {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param filePath {string} The local path(s) of the file(s) to upload\n   * @param name {string} The name(s) of the parameter to pass the file(s) along as\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'uploadFile',\n    sync: true,\n  })\n  uploadFileSync(\n    url: string,\n    body: any,\n    headers: any,\n    filePath: string | string[],\n    name: string | string[],\n    success: (result: any) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param filePath {string} The path to download the file to, including the file name.\n   * @returns {Promise<any>} returns a FileEntry promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  downloadFile(url: string, body: any, headers: any, filePath: string): Promise<any> {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param body {Object} The body of the request\n   * @param headers {Object} The headers to set for this request\n   * @param filePath {string} The path to download the file to, including the file name.\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'downloadFile',\n    sync: true,\n  })\n  downloadFileSync(\n    url: string,\n    body: any,\n    headers: any,\n    filePath: string,\n    success: (result: any) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param options {Object} options for individual request\n   * @param options.method {string} request method\n   * @param options.data {Object} payload to be send to the server (only applicable on post, put or patch methods)\n   * @param options.params {Object} query params to be appended to the URL (only applicable on get, head, delete, upload or download methods)\n   * @param options.serializer {string} data serializer to be used (only applicable on post, put or patch methods), defaults to global serializer value, see setDataSerializer for supported values\n   * @param options.timeout {number} timeout value for the request in seconds, defaults to global timeout value\n   * @param options.headers {Object} headers object (key value pair), will be merged with global values\n   * @param options.filePath {string} file path(s) to be used during upload and download see uploadFile and downloadFile for detailed information\n   * @param options.name {string} name(s) to be used during upload see uploadFile for detailed information\n   * @param options.responseType {string} response type, defaults to text\n   *\n   * @returns {Promise<HTTPResponse>} returns a promise that will resolve on success, and reject on failure\n   */\n  @Cordova()\n  sendRequest(\n    url: string,\n    options: {\n      method: 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'upload' | 'download';\n      data?: { [index: string]: any };\n      params?: { [index: string]: string | number };\n      serializer?: 'json' | 'urlencoded' | 'utf8' | 'multipart' | 'raw';\n      timeout?: number;\n      headers?: { [index: string]: string };\n      filePath?: string | string[];\n      name?: string | string[];\n      responseType?: 'text' | 'arraybuffer' | 'blob' | 'json';\n    }\n  ): Promise<HTTPResponse> {\n    return;\n  }\n\n  /**\n   *\n   * @param url {string} The url to send the request to\n   * @param options {Object} options for individual request\n   * @param options.method {string} request method\n   * @param options.data {Object} payload to be send to the server (only applicable on post, put or patch methods)\n   * @param options.params {Object} query params to be appended to the URL (only applicable on get, head, delete, upload or download methods)\n   * @param options.serializer {string} data serializer to be used (only applicable on post, put or patch methods), defaults to global serializer value, see setDataSerializer for supported values\n   * @param options.timeout {number} timeout value for the request in seconds, defaults to global timeout value\n   * @param options.headers {Object} headers object (key value pair), will be merged with global values\n   * @param options.filePath {string} file path(s) to be used during upload and download see uploadFile and downloadFile for detailed information\n   * @param options.name {string} name(s) to be used during upload see uploadFile for detailed information\n   * @param options.responseType {string} response type, defaults to text\n   * @param success {function} A callback that is called when the request succeed\n   * @param failure {function} A callback that is called when the request failed\n   *\n   * @returns {string} returns a string that represents the requestId\n   */\n  @Cordova({\n    methodName: 'sendRequest',\n    sync: true,\n  })\n  sendRequestSync(\n    url: string,\n    options: {\n      method: 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'upload' | 'download';\n      data?: { [index: string]: any };\n      params?: { [index: string]: string | number };\n      serializer?: 'json' | 'urlencoded' | 'utf8' | 'multipart';\n      timeout?: number;\n      headers?: { [index: string]: string };\n      filePath?: string | string[];\n      name?: string | string[];\n      responseType?: 'text' | 'arraybuffer' | 'blob' | 'json';\n    },\n    success: (result: HTTPResponse) => void,\n    failure: (error: any) => void\n  ): string {\n    return;\n  }\n\n  /**\n   * @param requestId {string} The RequestId of the request to abort\n   */\n  @Cordova()\n  abort(requestId: string): Promise<AbortedResponse> {\n    return;\n  }\n}\n"]}

ngx/index.metadata.json

@@ -1,1 +0,1 @@
-[{"__symbolic":"module","version":4,"metadata":{"HTTPResponse":{"__symbolic":"interface"},"HTTP":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"@ionic-native/core","name":"IonicNativePlugin","line":72,"character":26},"decorators":[{"__symbolic":"call","expression":{"__symbolic":"reference","module":"@angular/core","name":"Injectable","line":71,"character":1}}],"members":{"ErrorCode":[{"__symbolic":"property"}],"getBasicAuthHeader":[{"__symbolic":"method"}],"useBasicAuth":[{"__symbolic":"method"}],"getHeaders":[{"__symbolic":"method"}],"setHeader":[{"__symbolic":"method"}],"getDataSerializer":[{"__symbolic":"method"}],"setDataSerializer":[{"__symbolic":"method"}],"setCookie":[{"__symbolic":"method"}],"clearCookies":[{"__symbolic":"method"}],"removeCookies":[{"__symbolic":"method"}],"getCookieString":[{"__symbolic":"method"}],"getRequestTimeout":[{"__symbolic":"method"}],"setRequestTimeout":[{"__symbolic":"method"}],"getFollowRedirect":[{"__symbolic":"method"}],"setFollowRedirect":[{"__symbolic":"method"}],"setServerTrustMode":[{"__symbolic":"method"}],"post":[{"__symbolic":"method"}],"get":[{"__symbolic":"method"}],"put":[{"__symbolic":"method"}],"patch":[{"__symbolic":"method"}],"delete":[{"__symbolic":"method"}],"head":[{"__symbolic":"method"}],"options":[{"__symbolic":"method"}],"uploadFile":[{"__symbolic":"method"}],"downloadFile":[{"__symbolic":"method"}],"sendRequest":[{"__symbolic":"method"}]}}}}]
+[{"__symbolic":"module","version":4,"metadata":{"HTTPResponse":{"__symbolic":"interface"},"HTTP":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"@ionic-native/core","name":"IonicNativePlugin","line":76,"character":26},"decorators":[{"__symbolic":"call","expression":{"__symbolic":"reference","module":"@angular/core","name":"Injectable","line":75,"character":1}}],"members":{"ErrorCode":[{"__symbolic":"property"}],"getBasicAuthHeader":[{"__symbolic":"method"}],"useBasicAuth":[{"__symbolic":"method"}],"getHeaders":[{"__symbolic":"method"}],"setHeader":[{"__symbolic":"method"}],"getDataSerializer":[{"__symbolic":"method"}],"setDataSerializer":[{"__symbolic":"method"}],"setCookie":[{"__symbolic":"method"}],"clearCookies":[{"__symbolic":"method"}],"removeCookies":[{"__symbolic":"method"}],"getCookieString":[{"__symbolic":"method"}],"getRequestTimeout":[{"__symbolic":"method"}],"setRequestTimeout":[{"__symbolic":"method"}],"getFollowRedirect":[{"__symbolic":"method"}],"setFollowRedirect":[{"__symbolic":"method"}],"setServerTrustMode":[{"__symbolic":"method"}],"post":[{"__symbolic":"method"}],"postSync":[{"__symbolic":"method"}],"get":[{"__symbolic":"method"}],"getSync":[{"__symbolic":"method"}],"put":[{"__symbolic":"method"}],"putSync":[{"__symbolic":"method"}],"patch":[{"__symbolic":"method"}],"patchSync":[{"__symbolic":"method"}],"delete":[{"__symbolic":"method"}],"deleteSync":[{"__symbolic":"method"}],"head":[{"__symbolic":"method"}],"headSync":[{"__symbolic":"method"}],"options":[{"__symbolic":"method"}],"optionsSync":[{"__symbolic":"method"}],"uploadFile":[{"__symbolic":"method"}],"uploadFileSync":[{"__symbolic":"method"}],"downloadFile":[{"__symbolic":"method"}],"downloadFileSync":[{"__symbolic":"method"}],"sendRequest":[{"__symbolic":"method"}],"sendRequestSync":[{"__symbolic":"method"}],"abort":[{"__symbolic":"method"}]}}}}]

ngx/package.json

@@ -1,1 +0,1 @@
-{"description":"Ionic Native - Native plugins for ionic apps","module":"index.js","typings":"index.d.ts","author":"ionic","license":"MIT","repository":{"type":"git","url":"https://github.com/ionic-team/ionic-native.git"},"name":"@ionic-native/http","dependencies":{"@types/cordova":"latest"},"peerDependencies":{"rxjs":"^5.5.0 || ^6.5.0","@ionic-native/core":"^5.1.0"},"version":"5.30.0"}
+{"description":"Ionic Native - Native plugins for ionic apps","module":"index.js","typings":"index.d.ts","author":"ionic","license":"MIT","repository":{"type":"git","url":"https://github.com/ionic-team/ionic-native.git"},"name":"@ionic-native/http","dependencies":{"@types/cordova":"latest"},"peerDependencies":{"rxjs":"^5.5.0 || ^6.5.0","@ionic-native/core":"^5.1.0"},"version":"5.31.1"}

package.json

@@ -1,1 +0,1 @@
-{"description":"Ionic Native - Native plugins for ionic apps","module":"index.js","typings":"index.d.ts","author":"ionic","license":"MIT","repository":{"type":"git","url":"https://github.com/ionic-team/ionic-native.git"},"name":"@ionic-native/http","dependencies":{"@types/cordova":"latest"},"peerDependencies":{"rxjs":"^5.5.0 || ^6.5.0","@ionic-native/core":"^5.1.0"},"version":"5.30.0"}
+{"description":"Ionic Native - Native plugins for ionic apps","module":"index.js","typings":"index.d.ts","author":"ionic","license":"MIT","repository":{"type":"git","url":"https://github.com/ionic-team/ionic-native.git"},"name":"@ionic-native/http","dependencies":{"@types/cordova":"latest"},"peerDependencies":{"rxjs":"^5.5.0 || ^6.5.0","@ionic-native/core":"^5.1.0"},"version":"5.31.1"}

README.md

@@ -1,2 +0,2 @@
-<a style="float:right;font-size:12px;" href="http://github.com/ionic-team/ionic-native/edit/master/src/@ionic-native/plugins/http/index.ts#L24">
+<a style="float:right;font-size:12px;" href="http://github.com/ionic-team/ionic-native/edit/master/src/@ionic-native/plugins/http/index.ts#L28">
   Improve this doc
@@ -3,0 +3,0 @@ </a>

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

120142

increased by63.31%

Lines of code

965

increased by44.68%

No dependency changes