@signalwire/compatibility-api/dist/index.node.mjs

SignalWire Compatibility API

      import { fileURLToPath } from 'url';
      import path from 'path';
      import { createRequire as topLevelCreateRequire } from 'module';
      const require = topLevelCreateRequire(import.meta.url);
      const __filename = fileURLToPath(import.meta.url);
      const __dirname = path.dirname(__filename);
      
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
  if (typeof require !== "undefined")
    return require.apply(this, arguments);
  throw new Error('Dynamic require of "' + x + '" is not supported');
});
var __commonJS = (cb, mod) => function __require2() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));

// package.json
var require_package = __commonJS({
  "package.json"(exports, module) {
    module.exports = {
      name: "@signalwire/compatibility-api",
      description: "SignalWire Compatibility API",
      author: "SignalWire Team <open.source@signalwire.com>",
      license: "MIT",
      version: "3.1.4",
      keywords: [
        "signalwire",
        "voice",
        "laml",
        "sms",
        "rest",
        "api"
      ],
      repository: {
        type: "git",
        url: "https://github.com/signalwire/compatibility-api-js"
      },
      bugs: {
        url: "https://github.com/signalwire/compatibility-api-js/issues"
      },
      homepage: "https://developer.signalwire.com/compatibility-api",
      dependencies: {
        axios: "^0.26.1",
        dayjs: "^1.8.29",
        "https-proxy-agent": "^5.0.0",
        jsonwebtoken: "9.0.0",
        lodash: "^4.17.21",
        q: "2.0.x",
        qs: "^6.9.4",
        rootpath: "^0.1.2",
        scmp: "^2.1.0",
        "url-parse": "^1.5.9",
        xmlbuilder: "^13.0.2"
      },
      devDependencies: {
        "@types/node": "9.6.57",
        esbuild: "^0.17.19",
        "esbuild-node-externals": "^1.7.0",
        eslint: "^7.28.0",
        express: "^4.17.1",
        jasmine: "~3.5.0",
        jsdoc: "^4.0.2",
        jshint: "^2.11.0",
        "mock-fs": "^4.12.0",
        nock: "^10.0.6",
        "node-mocks-http": "^1.8.1",
        nyc: "^15.1.0",
        proxyquire: "^2.1.3",
        typescript: "^2.9.2"
      },
      scripts: {
        test: "npm run test:javascript && npm run test:typescript",
        "test:javascript": "jasmine spec/**/**.spec.js",
        "test:typescript": "tsc examples/typescript/example.ts --noEmit --strict",
        jshint: "jshint lib/rest/** lib/base/** lib/http/**",
        jscs: "eslint lib/base/**/**.js lib/http/**/**.js --fix",
        check: "npm run jshint && npm run jscs",
        ci: "npm run nyc && npm run nsp",
        coverage: "nyc npm test",
        jsdoc: "jsdoc -r lib -d docs",
        nsp: 'if [ `npm --version | cut -d\'.\' -f1` -ge "6" ]; then npm audit --production; else echo "npm audit is not available for npm < 6.0"; fi',
        nyc: "if [ `node --version | cut -d'.' -f1 | cut -c2-` -ge \"8\" ]; then npm run coverage; else npm test; fi",
        tsc: "tsc -p tsconfig.cjs.json",
        "tsc:esm": "tsc -p tsconfig.esm.json",
        build: "node build.js"
      },
      files: [
        "dist",
        "lib",
        "src",
        "index.js",
        "index.d.ts",
        "compatibility-api.d.ts"
      ],
      main: "dist/index.node.js",
      exports: {
        require: "./dist/index.node.js",
        default: "./dist/index.node.mjs"
      },
      types: "./compatibility-api.d.ts",
      engines: {
        node: ">=12"
      }
    };
  }
});

// lib/base/RestException.js
var require_RestException = __commonJS({
  "lib/base/RestException.js"(exports, module) {
    "use strict";
    var RestException = class extends Error {
      constructor(response) {
        super("[HTTP " + response.statusCode + "] Failed to execute request");
        const body = typeof response.body === "string" ? JSON.parse(response.body) : response.body;
        this.status = response.statusCode;
        this.message = body.message;
        this.code = body.code;
        this.moreInfo = body.more_info;
        this.details = body.details;
      }
    };
    module.exports = RestException;
  }
});

// lib/http/response.js
var require_response = __commonJS({
  "lib/http/response.js"(exports, module) {
    "use strict";
    var Response = function(statusCode, body, headers) {
      this.statusCode = statusCode;
      this.body = body;
      this.headers = headers;
    };
    Response.prototype.toString = function() {
      return "HTTP " + this.statusCode + " " + this.body;
    };
    module.exports = Response;
  }
});

// lib/http/request.js
var require_request = __commonJS({
  "lib/http/request.js"(exports, module) {
    "use strict";
    var _ = __require("lodash");
    var Request = function(opts) {
      opts = opts || {};
      this.method = opts.method || this.ANY;
      this.url = opts.url || this.ANY;
      this.auth = opts.auth || this.ANY;
      this.params = opts.params || this.ANY;
      this.data = opts.data || this.ANY;
      this.headers = opts.headers || this.ANY;
      this.ca = opts.ca;
    };
    Request.prototype.ANY = "*";
    Request.prototype.attributeEqual = function(lhs, rhs) {
      if (lhs === this.ANY || rhs === this.ANY) {
        return true;
      }
      lhs = lhs || void 0;
      rhs = rhs || void 0;
      return _.isEqual(lhs, rhs);
    };
    Request.prototype.isEqual = function(other) {
      return this.attributeEqual(this.method, other.method) && this.attributeEqual(this.url, other.url) && this.attributeEqual(this.auth, other.auth) && this.attributeEqual(this.params, other.params) && this.attributeEqual(this.data, other.data) && this.attributeEqual(this.headers, other.headers);
    };
    Request.prototype.toString = function() {
      var auth = "";
      if (this.auth && this.auth !== this.ANY) {
        auth = this.auth + " ";
      }
      var params = "";
      if (this.params && this.params !== this.ANY) {
        params = "?" + _.join(_.chain(_.keys(this.params)).map(function(key) {
          return key + "=" + this.params[key];
        }.bind(this)).value(), "&");
      }
      var data = "";
      if (this.data && this.data !== this.ANY) {
        if (this.method === "GET") {
          data = "\n -G";
        }
        data = data + "\n" + _.join(
          _.map(this.data, function(value, key) {
            return " -d " + key + "=" + value;
          }),
          "\n"
        );
      }
      var headers = "";
      if (this.headers && this.headers !== this.ANY) {
        headers = "\n" + _.join(
          _.map(this.headers, function(value, key) {
            return " -H " + key + "=" + value;
          }),
          "\n"
        );
      }
      return auth + this.method + " " + this.url + params + data + headers;
    };
    module.exports = Request;
  }
});

// lib/base/RequestClient.js
var require_RequestClient = __commonJS({
  "lib/base/RequestClient.js"(exports, module) {
    "use strict";
    var _ = __require("lodash");
    var axios = __require("axios");
    var fs = __require("fs");
    var HttpsProxyAgent = __require("https-proxy-agent");
    var Q = __require("q");
    var qs = __require("qs");
    var Response = require_response();
    var Request = require_request();
    axios.defaults.headers.post["Content-Type"] = "application/x-www-form-urlencoded";
    var RequestClient = function() {
    };
    RequestClient.prototype.request = function(opts) {
      opts = opts || {};
      if (!opts.method) {
        throw new Error("http method is required");
      }
      if (!opts.uri) {
        throw new Error("uri is required");
      }
      var deferred = Q.defer();
      var headers = opts.headers || {};
      if (!headers.Connection && !headers.connection && opts.forever) {
        headers.Connection = "keep-alive";
      } else if (!headers.Connection && !headers.connection) {
        headers.Connection = "close";
      }
      if (opts.username && opts.password) {
        var b64Auth = Buffer.from(opts.username + ":" + opts.password).toString("base64");
        headers.Authorization = "Basic " + b64Auth;
      }
      var options = {
        timeout: opts.timeout || 3e4,
        maxRedirects: opts.allowRedirects ? 10 : 0,
        // Same number of allowed redirects as request module default
        url: opts.uri,
        method: opts.method,
        headers: opts.headers,
        httpsAgent: process.env.HTTP_PROXY ? new HttpsProxyAgent(process.env.HTTP_PROXY) : void 0,
        proxy: false,
        validateStatus: (status) => status >= 100 && status < 600
      };
      if (process.env.TWILIO_CA_BUNDLE !== void 0) {
        if (this.ca === void 0) {
          this.ca = fs.readFileSync(process.env.TWILIO_CA_BUNDLE);
        }
        options.ca = this.ca;
      }
      if (!_.isNull(opts.data)) {
        options.data = qs.stringify(opts.data, { arrayFormat: "repeat" });
      }
      if (!_.isNull(opts.params)) {
        options.params = opts.params;
        options.paramsSerializer = (params) => {
          return qs.stringify(params, { arrayFormat: "repeat" });
        };
      }
      var optionsRequest = {
        method: options.method,
        url: options.url,
        auth: b64Auth || null,
        params: options.params,
        data: opts.data,
        headers: options.headers,
        ca: options.ca
      };
      if (opts.logLevel === "debug") {
        this.logRequest(options);
      }
      var _this = this;
      this.lastResponse = void 0;
      this.lastRequest = new Request(optionsRequest);
      axios(options).then((response) => {
        if (opts.logLevel === "debug") {
          console.log(`response.statusCode: ${response.status}`);
          console.log(`response.headers: ${JSON.stringify(response.headers)}`);
        }
        _this.lastResponse = new Response(response.status, response.data, response.headers);
        deferred.resolve({
          statusCode: response.status,
          body: response.data,
          headers: response.headers
        });
      }).catch((error) => {
        _this.lastResponse = void 0;
        deferred.reject(error);
      });
      return deferred.promise;
    };
    RequestClient.prototype.filterLoggingHeaders = function(headers) {
      return Object.keys(headers).filter((header) => {
        return !"authorization".includes(header.toLowerCase());
      });
    };
    RequestClient.prototype.logRequest = function(options) {
      console.log("-- BEGIN Twilio API Request --");
      console.log(`${options.method} ${options.url}`);
      if (options.params) {
        console.log("Querystring:");
        console.log(options.params);
      }
      if (options.headers) {
        console.log("Headers:");
        const filteredHeaderKeys = this.filterLoggingHeaders(options.headers);
        filteredHeaderKeys.forEach((header) => console.log(`${header}: ${options.headers[header]}`));
      }
      console.log("-- END Twilio API Request --");
    };
    module.exports = RequestClient;
  }
});

// lib/base/Domain.js
var require_Domain = __commonJS({
  "lib/base/Domain.js"(exports, module) {
    "use strict";
    var _ = __require("lodash");
    function Domain(twilio3, baseUrl) {
      this.twilio = twilio3;
      this.baseUrl = baseUrl;
    }
    Domain.prototype.absoluteUrl = function(uri) {
      return _.trim(this.baseUrl, "/") + "/" + _.trim(uri, "/");
    };
    Domain.prototype.request = function(opts) {
      return this.twilio.request(_.assign({}, opts, {
        uri: this.absoluteUrl(opts.uri)
      }));
    };
    module.exports = Domain;
  }
});

// lib/base/Page.js
var require_Page = __commonJS({
  "lib/base/Page.js"(exports, module) {
    "use strict";
    var _ = __require("lodash");
    var RestException = require_RestException();
    function Page(version, response, solution) {
      var payload = this.processResponse(response);
      this._version = version;
      this._payload = payload;
      this._solution = solution;
      this.nextPageUrl = this.getNextPageUrl();
      this.previousPageUrl = this.getPreviousPageUrl();
      this.instances = this.loadInstances(this.loadPage(payload));
    }
    Page.prototype.META_KEYS = [
      "end",
      "first_page_uri",
      "last_page_uri",
      "next_page_uri",
      "num_pages",
      "page",
      "page_size",
      "previous_page_uri",
      "start",
      "total",
      "uri"
    ];
    Page.prototype.getPreviousPageUrl = function() {
      if ("meta" in this._payload && "previous_page_url" in this._payload.meta && this._payload.meta.previous_page_url) {
        return this._payload.meta.previous_page_url;
      }
      if ("previous_page_uri" in this._payload && this._payload.previous_page_uri) {
        return this._version._domain.absoluteUrl(this._payload.previous_page_uri);
      }
      return void 0;
    };
    Page.prototype.getNextPageUrl = function() {
      if ("meta" in this._payload && "next_page_url" in this._payload.meta && this._payload.meta.next_page_url) {
        return this._payload.meta.next_page_url;
      }
      if ("next_page_uri" in this._payload && this._payload.next_page_uri) {
        return this._version._domain.absoluteUrl(this._payload.next_page_uri);
      }
      return void 0;
    };
    Page.prototype.getInstance = function(payload) {
      throw new Error("Page.get_instance() must be implemented in the derived class");
    };
    Page.prototype.loadInstances = function(resources) {
      return _.map(resources, function(resource) {
        return this.getInstance(resource);
      }.bind(this));
    };
    Page.prototype.nextPage = function() {
      if (!this.nextPageUrl) {
        return void 0;
      }
      var promise = this._version._domain.twilio.request({
        method: "GET",
        uri: this.nextPageUrl
      });
      promise = promise.then(function(response) {
        return new this.constructor(this._version, response, this._solution);
      }.bind(this));
      return promise;
    };
    Page.prototype.previousPage = function() {
      if (!this.previousPageUrl) {
        return void 0;
      }
      var promise = this._version._domain.twilio.request({
        method: "GET",
        uri: this.previousPageUrl
      });
      promise = promise.then(function(response) {
        return new this.constructor(this._version, response, this._solution);
      }.bind(this));
      return promise;
    };
    Page.prototype.processResponse = function(response) {
      if (response.statusCode !== 200) {
        throw new RestException(response);
      }
      if (typeof response.body === "string") {
        return JSON.parse(response.body);
      }
      return response.body;
    };
    Page.prototype.loadPage = function(payload) {
      if ("meta" in payload && "key" in payload.meta) {
        return payload[payload.meta.key];
      }
      var keys = _.chain(payload).keys().difference(this.META_KEYS).value();
      if (keys.length === 1) {
        return payload[keys[0]];
      }
      throw new Error("Page Records cannot be deserialized");
    };
    module.exports = Page;
  }
});

// lib/base/deserialize.js
var require_deserialize = __commonJS({
  "lib/base/deserialize.js"(exports, module) {
    "use strict";
    var _ = __require("lodash");
    var dayjs = __require("dayjs");
    var utc = __require("dayjs/plugin/utc");
    dayjs.extend(utc);
    function parseDate(s, format) {
      var m = dayjs.utc(s, format);
      if (m.isValid()) {
        return m.toDate();
      }
      return s;
    }
    function parseNumber(n, parser) {
      var parsed = parser(n);
      if (isNaN(parsed)) {
        return n;
      }
      return parsed;
    }
    function iso8601Date(s) {
      return parseDate(s, "YYYY-MM-DD");
    }
    function iso8601DateTime(s) {
      return parseDate(s, "YYYY-MM-DD[T]HH:mm:ss[Z]");
    }
    function rfc2822DateTime(s) {
      return parseDate(s, "ddd, DD MMM YYYY HH:mm:ss [+0000]");
    }
    function decimal(d) {
      return parseNumber(d, parseFloat);
    }
    function integer(i) {
      return parseNumber(i, _.parseInt);
    }
    module.exports = {
      iso8601Date,
      iso8601DateTime,
      rfc2822DateTime,
      decimal,
      integer
    };
  }
});

// lib/base/values.js
var require_values = __commonJS({
  "lib/base/values.js"(exports, module) {
    "use strict";
    var _ = __require("lodash");
    function of(obj) {
      return _.omitBy(obj, _.isUndefined);
    }
    module.exports = {
      of
    };
  }
});

// lib/rest/accounts/v1/authTokenPromotion.js
var require_authTokenPromotion = __commonJS({
  "lib/rest/accounts/v1/authTokenPromotion.js"(exports, module) {
    "use strict";
    var Q = __require("q");
    var _ = __require("lodash");
    var util = __require("util");
    var Page = require_Page();
    var deserialize = require_deserialize();
    var values = require_values();
    var AuthTokenPromotionList;
    var AuthTokenPromotionPage;
    var AuthTokenPromotionInstance;
    var AuthTokenPromotionContext;
    AuthTokenPromotionList = function AuthTokenPromotionList2(version) {
      function AuthTokenPromotionListInstance(sid) {
        return AuthTokenPromotionListInstance.get(sid);
      }
      AuthTokenPromotionListInstance._version = version;
      AuthTokenPromotionListInstance._solution = {};
      AuthTokenPromotionListInstance.get = function get() {
        return new AuthTokenPromotionContext(this._version);
      };
      AuthTokenPromotionListInstance.toJSON = function toJSON() {
        return this._solution;
      };
      AuthTokenPromotionListInstance[util.inspect.custom] = function inspect(depth, options) {
        return util.inspect(this.toJSON(), options);
      };
      return AuthTokenPromotionListInstance;
    };
    AuthTokenPromotionPage = function AuthTokenPromotionPage2(version, response, solution) {
      this._solution = solution;
      Page.prototype.constructor.call(this, version, response, this._solution);
    };
    _.extend(AuthTokenPromotionPage.prototype, Page.prototype);
    AuthTokenPromotionPage.prototype.constructor = AuthTokenPromotionPage;
    AuthTokenPromotionPage.prototype.getInstance = function getInstance(payload) {
      return new AuthTokenPromotionInstance(this._version, payload);
    };
    AuthTokenPromotionPage.prototype.toJSON = function toJSON() {
      let clone = {};
      _.forOwn(this, function(value, key) {
        if (!_.startsWith(key, "_") && !_.isFunction(value)) {
          clone[key] = value;
        }
      });
      return clone;
    };
    AuthTokenPromotionPage.prototype[util.inspect.custom] = function inspect(depth, options) {
      return util.inspect(this.toJSON(), options);
    };
    AuthTokenPromotionInstance = function AuthTokenPromotionInstance2(version, payload) {
      this._version = version;
      this.accountSid = payload.account_sid;
      this.authToken = payload.auth_token;
      this.dateCreated = deserialize.iso8601DateTime(payload.date_created);
      this.dateUpdated = deserialize.iso8601DateTime(payload.date_updated);
      this.url = payload.url;
      this._context = void 0;
      this._solution = {};
    };
    Object.defineProperty(
      AuthTokenPromotionInstance.prototype,
      "_proxy",
      {
        get: function() {
          if (!this._context) {
            this._context = new AuthTokenPromotionContext(this._version);
          }
          return this._context;
        }
      }
    );
    AuthTokenPromotionInstance.prototype.update = function update(callback) {
      return this._proxy.update(callback);
    };
    AuthTokenPromotionInstance.prototype.toJSON = function toJSON() {
      let clone = {};
      _.forOwn(this, function(value, key) {
        if (!_.startsWith(key, "_") && !_.isFunction(value)) {
          clone[key] = value;
        }
      });
      return clone;
    };
    AuthTokenPromotionInstance.prototype[util.inspect.custom] = function inspect(depth, options) {
      return util.inspect(this.toJSON(), options);
    };
    AuthTokenPromotionContext = function AuthTokenPromotionContext2(version) {
      this._version = version;
      this._solution = {};
      this._uri = `/AuthTokens/Promote`;
    };
    AuthTokenPromotionContext.prototype.update = function update(callback) {
      var deferred = Q.defer();
      var promise = this._version.update({ uri: this._uri, method: "POST" });
      promise = promise.then(function(payload) {
        deferred.resolve(new AuthTokenPromotionInstance(this._version, payload));
      }.bind(this));
      promise.catch(function(error) {
        deferred.reject(error);
      });
      if (_.isFunction(callback)) {
        deferred.promise.nodeify(callback);
      }
      return deferred.promise;
    };
    AuthTokenPromotionContext.prototype.toJSON = function toJSON() {
      return this._solution;
    };
    AuthTokenPromotionContext.prototype[util.inspect.custom] = function inspect(depth, options) {
      return util.inspect(this.toJSON(), options);
    };
    module.exports = {
      AuthTokenPromotionList,
      AuthTokenPromotionPage,
      AuthTokenPromotionInstance,
      AuthTokenPromotionContext
    };
  }
});

// lib/rest/accounts/v1/credential/aws.js
var require_aws = __commonJS({
  "lib/rest/accounts/v1/credential/aws.js"(exports, module) {
    "use strict";
    var Q = __require("q");
    var _ = __require("lodash");
    var util = __require("util");
    var Page = require_Page();
    var deserialize = require_deserialize();
    var values = require_values();
    var AwsList;
    var AwsPage;
    var AwsInstance;
    var AwsContext;
    AwsList = function AwsList2(version) {
      function AwsListInstance(sid) {
        return AwsListInstance.get(sid);
      }
      AwsListInstance._version = version;
      AwsListInstance._solution = {};
      AwsListInstance._uri = `/Credentials/AWS`;
      AwsListInstance.each = function each(opts, callback) {
        if (_.isFunction(opts)) {
          callback = opts;
          opts = {};
        }
        opts = opts || {};
        if (opts.callback) {
          callback = opts.callback;
        }
        if (_.isUndefined(callback)) {
          throw new Error("Callback function must be provided");
        }
        var done = false;
        var currentPage = 1;
        var currentResource = 0;
        var limits = this._version.readLimits({
          limit: opts.limit,
          pageSize: opts.pageSize
        });
        function onComplete(error) {
          done = true;
          if (_.isFunction(opts.done)) {
            opts.done(error);
          }
        }
        function fetchNextPage(fn) {
          var promise = fn();
          if (_.isUndefined(promise)) {
            onComplete();
            return;
          }
          promise.then(function(page) {
            _.each(page.instances, function(instance) {
              if (done || !_.isUndefined(opts.limit) && currentResource >= opts.limit) {
                done = true;
                return false;
              }
              currentResource++;
              callback(instance, onComplete);
            });
            if (!done) {
              currentPage++;
              fetchNextPage(_.bind(page.nextPage, page));
            } else {
              onComplete();
            }
          });
          promise.catch(onComplete);
        }
        fetchNextPage(_.bind(this.page, this, _.merge(opts, limits)));
      };
      AwsListInstance.list = function list(opts, callback) {
        if (_.isFunction(opts)) {
          callback = opts;
          opts = {};
        }
        opts = opts || {};
        var deferred = Q.defer();
        var allResources = [];
        opts.callback = function(resource, done) {
          allResources.push(resource);
          if (!_.isUndefined(opts.limit) && allResources.length === opts.limit) {
            done();
          }
        };
        opts.done = function(error) {
          if (_.isUndefined(error)) {
            deferred.resolve(allResources);
          } else {
            deferred.reject(error);
          }
        };
        if (_.isFunction(callback)) {
          deferred.promise.nodeify(callback);
        }
        this.each(opts);
        return deferred.promise;
      };
      AwsListInstance.page = function page(opts, callback) {
        if (_.isFunction(opts)) {
          callback = opts;
          opts = {};
        }
        opts = opts || {};
        var deferred = Q.defer();
        var data = values.of({
          "PageToken": opts.pageToken,
          "Page": opts.pageNumber,
          "PageSize": opts.pageSize
        });
        var promise = this._version.page({ uri: this._uri, method: "GET", params: data });
        promise = promise.then(function(payload) {
          deferred.resolve(new AwsPage(this._version, payload, this._solution));
        }.bind(this));
        promise.catch(function(error) {
          deferred.reject(error);
        });
        if (_.isFunction(callback)) {
          deferred.promise.nodeify(callback);
        }
        return deferred.promise;
      };
      AwsListInstance.getPage = function getPage(targetUrl, callback) {
        var deferred = Q.defer();
        var promise = this._version._domain.twilio.request({ method: "GET", uri: targetUrl });
        promise = promise.then(function(payload) {
          deferred.resolve(new AwsPage(this._version, payload, this._solution));
        }.bind(this));
        promise.catch(function(error) {
          deferred.reject(error);
        });
        if (_.isFunction(callback)) {
          deferred.promise.nodeify(callback);
        }
        return deferred.promise;
      };
      AwsListInstance.create = function create(opts, callback) {
        if (_.isUndefined(opts)) {
          throw new Error('Required parameter "opts" missing.');
        }
        if (_.isUndefined(opts["credentials"])) {
          throw new Error(`Required parameter "opts['credentials']" missing.`);
        }
        var deferred = Q.defer();
        var data = values.of({
          "Credentials": _.get(opts, "credentials"),
          "FriendlyName": _.get(opts, "friendlyName"),
          "AccountSid": _.get(opts, "accountSid")
        });
        var promise = this._version.create({ uri: this._uri, method: "POST", data });
        promise = promise.then(function(payload) {
          deferred.resolve(new AwsInstance(this._version, payload, this._solution.sid));
        }.bind(this));
        promise.catch(function(error) {
          deferred.reject(error);
        });
        if (_.isFunction(callback)) {
          deferred.promise.nodeify(callback);
        }
        return deferred.promise;
      };
      AwsListInstance.get = function get(sid) {
        return new AwsContext(this._version, sid);
      };
      AwsListInstance.toJSON = function toJSON() {
        return this._solution;
      };
      AwsListInstance[util.inspect.custom] = function inspect(depth, options) {
        return util.inspect(this.toJSON(), options);
      };
      return AwsListInstance;
    };
    AwsPage = function AwsPage2(version, response, solution) {
      this._solution = solution;
      Page.prototype.constructor.call(this, version, response, this._solution);
    };
    _.extend(AwsPage.prototype, Page.prototype);
    AwsPage.prototype.constructor = AwsPage;
    AwsPage.prototype.getInstance = function getInstance(payload) {
      return new AwsInstance(this._version, payload);
    };
    AwsPage.prototype.toJSON = function toJSON() {
      let clone = {};
      _.forOwn(this, function(value, key) {
        if (!_.startsWith(key, "_") && !_.isFunction(value)) {
          clone[key] = value;
        }
      });
      return clone;
    };
    AwsPage.prototype[util.inspect.custom] = function inspect(depth, options) {
      return util.inspect(this.toJSON(), options);
    };
    AwsInstance = function AwsInstance2(version, payload, sid) {
      this._version = version;
      this.sid = payload.sid;
      this.accountSid = payload.account_sid;
      this.friendlyName = payload.friendly_name;
      this.dateCreated = deserialize.iso8601DateTime(payload.date_created);
      this.dateUpdated = deserialize.iso8601DateTime(payload.date_updated);
      this.url = payload.url;
      this._context = void 0;
      this._solution = { sid: sid || this.sid };
    };
    Object.defineProperty(
      AwsInstance.prototype,
      "_proxy",
      {
        get: function() {
          if (!this._context) {
            this._context = new AwsContext(this._version, this._solution.sid);
          }
          return this._context;
        }
      }
    );
    AwsInstance.prototype.fetch = function fetch(callback) {
      return this._proxy.fetch(callback);
    };
    AwsInstance.prototype.update = function update(opts, callback) {
      return this._proxy.update(opts, callback);
    };
    AwsInstance.prototype.remove = function remove(callback) {
      return this._proxy.remove(callback);
    };
    AwsInstance.prototype.toJSON = function toJSON() {
      let clone = {};
      _.forOwn(this, function(value, key) {
        if (!_.startsWith(key, "_") && !_.isFunction(value)) {
          clone[key] = value;
        }
      });
      return clone;
    };
    AwsInstance.prototype[util.inspect.custom] = function inspect(depth, options) {
      return util.inspect(this.toJSON(), options);
    };
    AwsContext = function AwsContext2(version, sid) {
      this._version = version;
      this._solution = { sid };
      this._uri = `/Credentials/AWS/${sid}`;
    };
    AwsContext.prototype.fetch = function fetch(callback) {
      var deferred = Q.defer();
      var promise = this._version.fetch({ uri: this._uri, method: "GET" });
      promise = promise.then(function(payload) {
        deferred.resolve(new AwsInstance(this._version, payload, this._solution.sid));
      }.bind(this));
      promise.catch(function(error) {
        deferred.reject(error);
      });
      if (_.isFunction(callback)) {
        deferred.promise.nodeify(callback);
      }
      return deferred.promise;
    };
    AwsContext.prototype.update = function update(opts, callback) {
      if (_.isFunction(opts)) {
        callback = opts;
        opts = {};
      }
      opts = opts || {};
      var deferred = Q.defer();
      var data = values.of({ "FriendlyName": _.get(opts, "friendlyName") });
      var promise = this._version.update({ uri: this._uri, method: "POST", data });
      promise = promise.then(function(payload) {
        deferred.resolve(new AwsInstance(this._version, payload, this._solution.sid));
      }.bind(this));
      promise.catch(function(error) {
        deferred.reject(error);
      });
      if (_.isFunction(callback)) {
        deferred.promise.nodeify(callback);
      }
      return deferred.promise;
    };
    AwsContext.prototype.remove = function remove(callback) {
      var deferred = Q.defer();
      var promise = this._version.remove({ uri: this._uri, method: "DELETE" });
      promise = promise.then(function(payload) {
        deferred.resolve(payload);
      }.bind(this));
      promise.catch(function(error) {
        deferred.reject(error);
      });
      if (_.isFunction(callback)) {
        deferred.promise.nodeify(callback);
      }
      return deferred.promise;
    };
    AwsContext.prototype.toJSON = function toJSON() {
      return this._solution;
    };
    AwsContext.prototype[util.inspect.custom] = function inspect(depth, options) {
      return util.inspect(this.toJSON(), options);
    };
    module.exports = {
      AwsList,
      AwsPage,
      AwsInstance,
      AwsContext
    };
  }
});

// lib/rest/accounts/v1/credential/publicKey.js
var require_publicKey = __commonJS({
  "lib/rest/accounts/v1/credential/publicKey.js"(exports, module) {
    "use strict";
    var Q = __require("q");
    var _ = __require("lodash");
    var util = __require("util");
    var Page = require_Page();
    var deserialize = require_deserialize();
    var values = require_values();
    var PublicKeyList;
    var PublicKeyPage;
    var PublicKeyInstance;
    var PublicKeyContext;
    PublicKeyList = function PublicKeyList2(version) {
      function PublicKeyListInstance(sid) {
        return PublicKeyListInstance.get(sid);
      }
      PublicKeyListInstance._version = version;
      PublicKeyListInstance._solution = {};
      PublicKeyListInstance._uri = `/Credentials/PublicKeys`;
      PublicKeyListInstance.each = function each(opts, callback) {
        if (_.isFunction(opts)) {
          callback = opts;
          opts = {};
        }
        opts = opts || {};
        if (opts.callback) {
          callback = opts.callback;
        }
        if (_.isUndefined(callback)) {
          throw new Error("Callback function must be provided");
        }
        var done = false;
        var currentPage = 1;
        var currentResource = 0;
        var limits = this._version.readLimits({
          limit: opts.limit,
          pageSize: opts.pageSize
        });
        function onComplete(error) {
          done = true;
          if (_.isFunction(opts.done)) {
            opts.done(error);
          }
        }
        function fetchNextPage(fn) {
          var promise = fn();
          if (_.isUndefined(promise)) {
            onComplete();
            return;
          }
          promise.then(function(page) {
            _.each(page.instances, function(instance) {
              if (done || !_.isUndefined(opts.limit) && currentResource >= opts.limit) {
                done = true;
                return false;
              }
              currentResource++;
              callback(instance, onComplete);
            });
            if (!done) {
              currentPage++;
              fetchNextPage(_.bind(page.nextPage, page));
            } else {
              onComplete();
            }
          });
          promise.catch(onComplete);
        }
        fetchNextPage(_.bind(this.page, this, _.merge(opts, limits)));
      };
      PublicKeyListInstance.list = function list(opts, callback) {
        if (_.isFunction(opts)) {
          callback = opts;
          opts = {};
        }
        opts = opts || {};
        var deferred = Q.defer();
        var allResources = [];
        opts.callback = function(resource, done) {
          allResources.push(resource);
          if (!_.isUndefined(opts.limit) && allResources.length === opts.limit) {
            done();
          }
        };
        opts.done = function(error) {
          if (_.isUndefined(error)) {
            deferred.resolve(allResources);
          } else {
            deferred.reject(error);
          }
        };
        if (_.isFunction(callback)) {
          deferred.promise.nodeify(callback);
        }
        this.each(opts);
        return deferred.promise;
      };
      PublicKeyListInstance.page = function page(opts, callback) {
        if (_.isFunction(opts)) {
          callback = opts;
          opts = {};
        }
        opts = opts || {};
        var deferred = Q.defer();
        var data = values.of({
          "PageToken": opts.pageToken,
          "Page": opts.pageNumber,
          "PageSize": opts.pageSize
        });
        var promise = this._version.page({ uri: this._uri, method: "GET", params: data });
        promise = promise.then(function(payload) {
          deferred.resolve(new PublicKeyPage(this._version, payload, this._solution));
        }.bind(this));
        promise.catch(function(error) {
          deferred.reject(error);
        });
        if (_.isFunction(callback)) {
          deferred.promise.nodeify(callback);
        }
        return deferred.promise;
      };
      PublicKeyListInstance.getPage = function getPage(targetUrl, callback) {
        var deferred = Q.defer();
        var promise = this._version._domain.twilio.request({ method: "GET", uri: targetUrl });
        promise = promise.then(function(payload) {
          deferred.resolve(new PublicKeyPage(this._version, payload, this._solution));
        }.bind(this));
        promise.catch(function(error) {
          deferred.reject(error);
        });
        if (_.isFunction(callback)) {
          deferred.promise.nodeify(callback);
        }
        return deferred.promise;
      };
      PublicKeyListInstance.create = function create(opts, callback) {
        if (_.isUndefined(opts)) {
          throw new Error('Required parameter "opts" missing.');
        }
        if (_.isUndefined(opts["publicKey"])) {
          throw new Error(`Required parameter "opts['publicKey']" missing.`);
        }
        var deferred = Q.defer();
        var data = values.of({
          "PublicKey": _.get(opts, "publicKey"),
          "FriendlyName": _.get(opts, "friendlyName"),
          "AccountSid": _.get(opts, "accountSid")
        });
        var promise = this._version.create({ uri: this._uri, method: "POST", data });
        promise = promise.then(function(payload) {
          deferred.resolve(new PublicKeyInstance(this._version, payload, this._solution.sid));
        }.bind(this));
        promise.catch(function(error) {
          deferred.reject(error);
        });
        if (_.isFunction(callback)) {
          deferred.promise.nodeify(callback);
        }
        return deferred.promise;
      };
      PublicKeyListInstance.get = function get(sid) {
        return new PublicKeyContext(this._version, sid);
      };
      PublicKeyListInstance.toJSON = function toJSON() {
        return this._solution;
      };
      PublicKeyListInstance[util.inspect.custom] = function inspect(depth, options) {
        return util.inspect(this.toJSON(), options);
      };
      return PublicKeyListInstance;
    };
    PublicKeyPage = function PublicKeyPage2(version, response, solution) {
      this._solution = solution;
      Page.prototype.constructor.call(this, version, response, this._solution);
    };
    _.extend(PublicKeyPage.prototype, Page.prototype);
    PublicKeyPage.prototype.constructor = PublicKeyPage;
    PublicKeyPage.prototype.getInstance = function getInstance(payload) {
      return new PublicKeyInstance(this._version, payload);
    };
    PublicKeyPage.prototype.toJSON = function toJSON() {
      let clone = {};
      _.forOwn(this, function(value, key) {
        if (!_.startsWith(key, "_") && !_.isFunction(value)) {
          clone[key] = value;
        }
      });
      return clone;
    };
    PublicKeyPage.prototype[util.inspect.custom] = function inspect(depth, options) {
      return util.inspect(this.toJSON(), options);
    };
    PublicKeyInstance = function PublicKeyInstance2(version, payload, sid) {
      this._version = version;
      this.sid = payload.sid;
      this.accountSid = payload.account_sid;
      this.friendlyName = payload.friendly_name;
      this.dateCreated = deserialize.iso8601DateTime(payload.date_created);
      this.dateUpdated = deserialize.iso8601DateTime(payload.date_updated);
      this.url = payload.url;
      this._context = void 0;
      this._solution = { sid: sid || this.sid };
    };
    Object.defineProperty(
      PublicKeyInstance.prototype,
      "_proxy",
      {
        get: function() {
          if (!this._context) {
            this._context = new PublicKeyContext(this._version, this._solution.sid);
          }
          return this._context;
        }
      }
    );
    PublicKeyInstance.prototype.fetch = function fetch(callback) {
      return this._proxy.fetch(callback);
    };
    PublicKeyInstance.prototype.update = function update(opts, callback) {
      return this._proxy.update(opts, callback);
    };
    PublicKeyInstance.prototype.remove = function remove(callback) {
      return this._proxy.remove(callback);
    };
    PublicKeyInstance.prototype.toJSON = function toJSON() {
      let clone = {};
      _.forOwn(this, function(value, key) {
        if (!_.startsWith(key, "_") && !_.isFunction(value)) {
          clone[key] = value;
        }
      });
      return clone;
    };
    PublicKeyInstance.prototype[util.inspect.custom] = function inspect(depth, options) {
      return util.inspect(this.toJSON(), options);
    };
    PublicKeyContext = function PublicKeyContext2(version, sid) {
      this._version = version;
      this._solution = { sid };
      this._uri = `/Credentials/PublicKeys/${sid}`;
    };
    PublicKeyContext.prototype.fetch = function fetch(callback) {
      var deferred = Q.defer();
      var promise = this._version.fetch({ uri: this._uri, method: "GET" });
      promise = promise.then(function(payload) {
        deferred.resolve(new PublicKeyInstance(this._version, payload, this._solution.sid));
      }.bind(this));
      promise.catch(function(error) {
        deferred.reject(error);
      });
      if (_.isFunction(callback)) {
        deferred.promise.nodeify(callback);
      }
      return deferred.promise;
    };
    PublicKeyContext.prototype.update = function update(opts, callback) {
      if (_.isFunction(opts)) {
        callback = opts;
        opts = {};
      }
      opts = opts || {};
      var deferred = Q.defer();
      var data = values.of({ "FriendlyName": _.get(opts, "friendlyName") });
      var promise = this._version.update({ uri: this._uri, method: "POST", data });
      promise = promise.then(function(payload) {
        deferred.resolve(new PublicKeyInstance(this._version, payload, this._solution.sid));
      }.bind(this));
      promise.catch(function(error) {
        deferred.reject(error);
      });
      if (_.isFunction(callback)) {
        deferred.promise.nodeify(callback);
      }
      return deferred.promise;
    };
    PublicKeyContext.prototype.remove = function remove(callback) {
      var deferred = Q.defer();
      var promise = this._version.remove({ uri: this._uri, method: "DELETE" });
      promise = promise.then(function(payload) {
        deferred.resolve(payload);
      }.bind(this));
      promise.catch(function(error) {
        deferred.reject(error);
      });
      if (_.isFunction(callback)) {
        deferred.promise.nodeify(callback);
      }
      return deferred.promise;
    };
    PublicKeyContext.prototype.toJSON = function toJSON() {
      return this._solution;
    };
    PublicKeyContext.prototype[util.inspect.custom] = function inspect(depth, options) {
      return util.inspect(this.toJSON(), options);
    };
    module.exports = {
      PublicKeyList,
      PublicKeyPage,
      PublicKeyInstance,
      PublicKeyContext
    };
  }
});

// lib/rest/accounts/v1/credential.js
var require_credential = __commonJS({
  "lib/rest/accounts/v1/credential.js"(exports, module) {
    "use strict";
    var _ = __require("lodash");
    var util = __require("util");
    var AwsList = require_aws().AwsList;
    var PublicKeyList = require_publicKey().PublicKeyList;
    var CredentialList;
    CredentialList = function CredentialList2(version) {
      function CredentialListInstance(sid) {
        return CredentialListInstance.get(sid);
      }
      CredentialListInstance._version = version;
      CredentialListInstance._solution = {};
      CredentialListInstance._publicKey = void 0;
      CredentialListInstance._aws = void 0;
      Object.defineProperty(
        CredentialListInstance,
        "publicKey",
        {
          get: function publicKey() {
            if (!this._publicKey) {
              this._publicKey = new PublicKeyList(this._version);
            }
            return this._publicKey;
          }
        }
      );
      Object.defineProperty(
        CredentialListInstance,
        "aws",
        {
          get: function aws() {
            if (!this._aws) {
              this._aws = new AwsList(this._version);
            }
            return this._aws;
          }
        }
      );
      CredentialListInstance.toJSON = function toJSON() {
        return this._solution;
      };
      CredentialListInstance[util.inspect.custom] = function inspect(depth, options) {
        return util.inspect(this.toJSON(), options);
      };
      return CredentialListInstance;
    };
    module.exports = {
      CredentialList
    };
  }
});

// lib/rest/accounts/v1/secondaryAuthToken.js
var require_secondaryAuthToken = __commonJS({
  "lib/rest/accounts/v1/secondaryAuthToken.js"(exports, module) {
    "use strict";
    var Q = __require("q");
    var _ = __require("lodash");
    var util = __require("util");
    var Page = require_Page();
    var deserialize = require_deserialize();
    var values = require_values();
    var SecondaryAuthTokenList;
    var SecondaryAuthTokenPage;
    var SecondaryAuthTokenInstance;
    var SecondaryAuthTokenContext;
    SecondaryAuthTokenList = function SecondaryAuthTokenList2(version) {
      function SecondaryAuthTokenListInstance(sid) {
        return SecondaryAuthTokenListInstance.get(sid);
      }
      SecondaryAuthTokenListInstance._version = version;
      SecondaryAuthTokenListInstance._solution = {};
      SecondaryAuthTokenListInstance.get = function get() {
        return new SecondaryAuthTokenContext(this._version);
      };
      SecondaryAuthTokenListInstance.toJSON = function toJSON() {
        return this._solution;
      };
      SecondaryAuthTokenListInstance[util.inspect.custom] = function inspect(depth, options) {
        return util.inspect(this.toJSON(), options);
      };
      return SecondaryAuthTokenListInstance;
    };
    SecondaryAuthTokenPage = function SecondaryAuthTokenPage2(version, response, solution) {
      this._solution = solution;
      Page.prototype.constructor.call(this, version, response, this._solution);
    };
    _.extend(SecondaryAuthTokenPage.prototype, Page.prototype);
    SecondaryAuthTokenPage.prototype.constructor = SecondaryAuthTokenPage;
    SecondaryAuthTokenPage.prototype.getInstance = function getInstance(payload) {
      return new SecondaryAuthTokenInstance(this._version, payload);
    };
    SecondaryAuthTokenPage.prototype.toJSON = function toJSON() {
      let clone = {};
      _.forOwn(this, function(value, key) {
        if (!_.startsWith(key, "_") && !_.isFunction(value)) {
          clone[key] = value;
        }
      });
      return clone;
    };
    SecondaryAuthTokenPage.prototype[util.inspect.custom] = function inspect(depth, options) {
      return util.inspect(this.toJSON(), options);
    };
    SecondaryAuthTokenInstance = function SecondaryAuthTokenInstance2(version, payload) {
      this._version = version;
      this.accountSid = payload.account_sid;
      this.dateCreated = deserialize.iso8601DateTime(payload.date_created);
      this.dateUpdated = deserialize.iso8601DateTime(payload.date_updated);
      this.secondaryAuthToken = payload.secondary_auth_token;
      this.url = payload.url;
      this._context = void 0;
      this._solution = {};
    };
    Object.defineProperty(
      SecondaryAuthTokenInstance.prototype,
      "_proxy",
      {
        get: function() {
          if (!this._context) {
            this._context = new SecondaryAuthTokenContext(this._version);
          }
          return this._context;
        }
      }
    );
    SecondaryAuthTokenInstance.prototype.create = function create(callback) {
      return this._proxy.create(callback);
    };
    SecondaryAuthTokenInstance.prototype.remove = function remove(callback) {
      return this._proxy.remove(callback);
    };
    SecondaryAuthTokenInstance.prototype.toJSON = function toJSON() {
      let clone = {};
      _.forOwn(this, function(value, key) {
        if (!_.startsWith(key, "_") && !_.isFunction(value)) {
          clone[key] = value;
        }
      });
      return clone;
    };
    SecondaryAuthTokenInstance.prototype[util.inspect.custom] = function inspect(depth, options) {
      return util.inspect(this.toJSON(), options);
    };
    SecondaryAuthTokenContext = function SecondaryAuthTokenContext2(version) {
      this._version = version;
      this._solution = {};
      this._uri = `/AuthTokens/Secondary`;
    };
    SecondaryAuthTokenContext.prototype.create = function create(callback) {
      var deferred = Q.defer();
      var promise = this._version.create({ uri: this._uri, method: "POST" });
      promise = promise.then(function(payload) {
        deferred.resolve(new SecondaryAuthTokenInstance(this._version, payload));
      }.bind(this));
      promise.catch(function(error) {
        deferred.reject(error);
      });
      if (_.isFunction(callback)) {
        deferred.promise.nodeify(callback);
      }
      return deferred.promise;
    };
    SecondaryAuthTokenContext.prototype.remove = function remove(callback) {
      var deferred = Q.defer();
      var promise = this._version.remove({ uri: this._uri, method: "DELETE" });
      promise = promise.then(function(payload)