twilio 5.0.0-rc16 → 5.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2023, Twilio, Inc. <https://www.twilio.com/help/contact>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,51 +1,305 @@
 # twilio-node
 
-A node.js Twilio helper library.
+[![][test-workflow-image]][test-workflow-url]
+[![][npm-version-image]][npm-url]
+[![][npm-install-size-image]][npm-install-size-url]
+[![][npm-downloads-image]][npm-downloads-url]
 
-[![NPM](https://nodei.co/npm/twilio.png?downloads=true&stars=true)](https://nodei.co/npm/twilio/)
+## Documentation
 
-[![Build Status](https://travis-ci.org/twilio/twilio-node.svg?branch=master)](https://travis-ci.org/twilio/twilio-node)
+The documentation for the Twilio API can be found [here][apidocs].
 
-## End User Docs
+The Node library documentation can be found [here][libdocs].
 
-For detailed usage information and API docs, head out here:
+## Versions
 
-[http://twilio.github.io/twilio-node/](http://twilio.github.io/twilio-node/)
+`twilio-node` uses a modified version of [Semantic Versioning](https://semver.org) for all changes. [See this document](VERSIONS.md) for details.
+
+### Supported Node.js Versions
+
+This library supports the following Node.js implementations:
+
+- Node.js 14
+- Node.js 16
+- Node.js 18
+
+TypeScript is supported for TypeScript version 2.9 and above.
+
+> **Warning**
+> Do not use this Node.js library in a front-end application. Doing so can expose your Twilio credentials to end-users as part of the bundled HTML/JavaScript sent to their browser.
+
+## Installation
+
+`npm install twilio` or `yarn add twilio`
+
+### Test your installation
+
+To make sure the installation was successful, try sending yourself an SMS message, like this:
+
+```js
+// Your AccountSID and Auth Token from console.twilio.com
+const accountSid = 'ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
+const authToken = 'your_auth_token';
+
+const client = require('twilio')(accountSid, authToken);
+
+client.messages
+  .create({
+    body: 'Hello from twilio-node',
+    to: '+12345678901', // Text your number
+    from: '+12345678901', // From a valid Twilio number
+  })
+  .then((message) => console.log(message.sid));
+```
+
+After a brief delay, you will receive the text message on your phone.
+
+> **Warning**
+> It's okay to hardcode your credentials when testing locally, but you should use environment variables to keep them secret before committing any code or deploying to production. Check out [How to Set Environment Variables](https://www.twilio.com/blog/2017/01/how-to-set-environment-variables.html) for more information.
+
+## Usage
+
+Check out these [code examples](examples) in JavaScript and TypeScript to get up and running quickly.
+
+### Environment Variables
+
+`twilio-node` supports credential storage in environment variables. If no credentials are provided when instantiating the Twilio client (e.g., `const client = require('twilio')();`), the values in following env vars will be used: `TWILIO_ACCOUNT_SID` and `TWILIO_AUTH_TOKEN`.
+
+If your environment requires SSL decryption, you can set the path to CA bundle in the env var `TWILIO_CA_BUNDLE`.
+
+### Client Initialization
+
+If you invoke any V2010 operations without specifying an account SID, `twilio-node` will automatically use the `TWILIO_ACCOUNT_SID` value that the client was initialized with. This is useful for when you'd like to, for example, fetch resources for your main account but also your subaccount. See below:
+
+```javascript
+// Your Account SID, Subaccount SID Auth Token from console.twilio.com
+const accountSid = process.env.TWILIO_ACCOUNT_SID;
+const authToken = process.env.TWILIO_AUTH_TOKEN;
+const subaccountSid = process.env.TWILIO_ACCOUNT_SUBACCOUNT_SID;
+
+const client = require('twilio')(accountSid, authToken);
+const mainAccountCalls = client.api.v2010.account.calls.list; // SID not specified, so defaults to accountSid
+const subaccountCalls = client.api.v2010.account(subaccountSid).calls.list; // SID specified as subaccountSid
+```
+
+### Lazy Loading
+
+`twilio-node` supports lazy loading required modules for faster loading time. Lazy loading is enabled by default. To disable lazy loading, simply instantiate the Twilio client with the `lazyLoading` flag set to `false`:
+
+```javascript
+// Your Account SID and Auth Token from console.twilio.com
+const accountSid = process.env.TWILIO_ACCOUNT_SID;
+const authToken = process.env.TWILIO_AUTH_TOKEN;
+
+const client = require('twilio')(accountSid, authToken, {
+  lazyLoading: false,
+});
+```
+
+### Enable Auto-Retry with Exponential Backoff
+
+`twilio-node` supports automatic retry with exponential backoff when API requests receive an [Error 429 response](https://support.twilio.com/hc/en-us/articles/360044308153-Twilio-API-response-Error-429-Too-Many-Requests-). This retry with exponential backoff feature is disabled by default. To enable this feature, instantiate the Twilio client with the `autoRetry` flag set to `true`.
+
+Optionally, the maximum number of retries performed by this feature can be set with the `maxRetries` flag. The default maximum number of retries is `3`.
+
+```javascript
+const accountSid = process.env.TWILIO_ACCOUNT_SID;
+const authToken = process.env.TWILIO_AUTH_TOKEN;
+
+const client = require('twilio')(accountSid, authToken, {
+  autoRetry: true,
+  maxRetries: 3,
+});
+```
+
+### Specify Region and/or Edge
+
+To take advantage of Twilio's [Global Infrastructure](https://www.twilio.com/docs/global-infrastructure), specify the target Region and/or Edge for the client:
+
+```javascript
+const accountSid = process.env.TWILIO_ACCOUNT_SID;
+const authToken = process.env.TWILIO_AUTH_TOKEN;
+
+const client = require('twilio')(accountSid, authToken, {
+  region: 'au1',
+  edge: 'sydney',
+});
+```
+
+Alternatively, specify the edge and/or region after constructing the Twilio client:
+
+```javascript
+const client = require('twilio')(accountSid, authToken);
+client.region = 'au1';
+client.edge = 'sydney';
+```
+
+This will result in the `hostname` transforming from `api.twilio.com` to `api.sydney.au1.twilio.com`.
+
+### Iterate through records
+
+The library automatically handles paging for you. Collections, such as `calls` and `messages`, have `list` and `each` methods that page under the hood. With both `list` and `each`, you can specify the number of records you want to receive (`limit`) and the maximum size you want each page fetch to be (`pageSize`). The library will then handle the task for you.
+
+`list` eagerly fetches all records and returns them as a list, whereas `each` streams records and lazily retrieves pages of records as you iterate over the collection. You can also page manually using the `page` method.
+
+For more information about these methods, view the [auto-generated library docs](https://www.twilio.com/docs/libraries/reference/twilio-node/).
+
+```js
+// Your Account SID and Auth Token from console.twilio.com
+const accountSid = 'ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
+const authToken = 'your_auth_token';
+const client = require('twilio')(accountSid, authToken);
+
+client.calls.each((call) => console.log(call.direction));
+```
+
+### Enable Debug Logging
+
+There are two ways to enable debug logging in the default HTTP client. You can create an environment variable called `TWILIO_LOG_LEVEL` and set it to `debug` or you can set the logLevel variable on the client as debug:
+
+```javascript
+const accountSid = process.env.TWILIO_ACCOUNT_SID;
+const authToken = process.env.TWILIO_AUTH_TOKEN;
+
+const client = require('twilio')(accountSid, authToken, {
+  logLevel: 'debug',
+});
+```
+
+You can also set the logLevel variable on the client after constructing the Twilio client:
+
+```javascript
+const client = require('twilio')(accountSid, authToken);
+client.logLevel = 'debug';
+```
+
+### Debug API requests
+
+To assist with debugging, the library allows you to access the underlying request and response objects. This capability is built into the default HTTP client that ships with the library.
+
+For example, you can retrieve the status code of the last response like so:
+
+```js
+const accountSid = 'ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
+const authToken = 'your_auth_token';
+
+const client = require('twilio')(accountSid, authToken);
+
+client.messages
+  .create({
+    to: '+14158675309',
+    from: '+14258675310',
+    body: 'Ahoy!',
+  })
+  .then(() => {
+    // Access details about the last request
+    console.log(client.lastRequest.method);
+    console.log(client.lastRequest.url);
+    console.log(client.lastRequest.auth);
+    console.log(client.lastRequest.params);
+    console.log(client.lastRequest.headers);
+    console.log(client.lastRequest.data);
+
+    // Access details about the last response
+    console.log(client.httpClient.lastResponse.statusCode);
+    console.log(client.httpClient.lastResponse.body);
+  });
+```
+
+### Handle exceptions
+
+If the Twilio API returns a 400 or a 500 level HTTP response, `twilio-node` will throw an error including relevant information, which you can then `catch`:
+
+```js
+client.messages
+  .create({
+    body: 'Hello from Node',
+    to: '+12345678901',
+    from: '+12345678901',
+  })
+  .then((message) => console.log(message))
+  .catch((error) => {
+    // You can implement your fallback code here
+    console.log(error);
+  });
+```
+
+or with `async/await`:
+
+```js
+try {
+  const message = await client.messages.create({
+    body: 'Hello from Node',
+    to: '+12345678901',
+    from: '+12345678901',
+  });
+  console.log(message);
+} catch (error) {
+  // You can implement your fallback code here
+  console.error(error);
+}
+```
+
+If you are using callbacks, error information will be included in the `error` parameter of the callback.
+
+400-level errors are [normal during API operation](https://www.twilio.com/docs/api/rest/request#get-responses) ("Invalid number", "Cannot deliver SMS to that number", for example) and should be handled appropriately.
+
+### Use a custom HTTP Client
+
+To use a custom HTTP client with this helper library, please see the [advanced example of how to do so](./advanced-examples/custom-http-client.md).
+
+### Use webhook validation
+
+See [example](examples/express.js) for a code sample for incoming Twilio request validation.
+
+## Docker image
+
+The `Dockerfile` present in this repository and its respective `twilio/twilio-node` Docker image are currently used by Twilio for testing purposes only.
 
 ## Getting help
 
-If you need help installing or using the library, please contact Twilio Support at help@twilio.com first. Twilio's Support staff are well-versed in all of the Twilio Helper Libraries, and usually reply within 24 hours.
+If you need help installing or using the library, please check the [Twilio Support Help Center](https://support.twilio.com) first, and [file a support ticket](https://twilio.com/help/contact) if you don't find an answer to your question.
 
 If you've instead found a bug in the library or would like new features added, go ahead and open issues or pull requests against this repo!
 
 ## Contributing
 
-Bug fixes, docs, and enhancements welcome! If you're not familiar with the GitHub pull request/contribution process, [this is a nice tutorial](http://gun.io/blog/how-to-github-fork-branch-and-pull-request/).
+Bug fixes, docs, and library improvements are always welcome. Please refer to our [Contributing Guide](CONTRIBUTING.md) for detailed information on how you can contribute.
 
-#### Getting Started
-Fork and clone the repository. Install dependencies with:
-    
-    npm install
+> ⚠️ Please be aware that a large share of the files are auto-generated by our backend tool. You are welcome to suggest changes and submit PRs illustrating the changes. However, we'll have to make the changes in the underlying tool. You can find more info about this in the [Contributing Guide](CONTRIBUTING.md).
 
-Run the existing test spec with `npm test`.
-    
-To run just one specific test file instead of the whole suite, provide a JavaScript regular expression that will match your spec file's name, like: 
+If you're not familiar with the GitHub pull request/contribution process, [this is a nice tutorial](https://gun.io/blog/how-to-github-fork-branch-and-pull-request/).
 
-    ./node_modules/.bin/jasmine-node spec -m .\*accounts.\*
+### Get started
 
-To run live tests (such as `client.live.spec.js`) against your [Twilio account](https://www.twilio.com/user/account), you will need to create a local configuration file.  In the project root directory, do the following:
+If you want to familiarize yourself with the project, you can start by [forking the repository](https://help.github.com/articles/fork-a-repo/) and [cloning it in your local development environment](https://help.github.com/articles/cloning-a-repository/). The project requires [Node.js](https://nodejs.org) to be installed on your machine.
 
-* `cp config.sample.js config.js`
-* Edit `config.js` with your account information, a Twilio number, and your own mobile number
-* Run the live tests
+After cloning the repository, install the dependencies by running the following command in the directory of your cloned repository:
 
-#### Contributing Code
+```bash
+npm install
+```
 
-In your fork, create a new feature/bug fix branch, [per the guide listed above](http://gun.io/blog/how-to-github-fork-branch-and-pull-request/). Write a Jasmine test spec for your new feature or bug fix, and hack until it passes!  Submit a pull request, and it will be reviewed as soon as possible.
+You can run the existing tests to see if everything is okay by executing:
 
-#### Contributing Docs
+```bash
+npm test
+```
 
-Right now, the docs are maintained in static HTML in the `gh-pages` branch of this repository.  We hope to switch to a more robust documentation system soon, but for the time being, you can make documentation changes by editing [index.html](https://github.com/twilio/twilio-node/blob/gh-pages/index.html) directly.
+To run just one specific test file instead of the whole suite, provide a JavaScript regular expression that will match your spec file's name, like:
 
+```bash
+npm run test:javascript -- -m .\*client.\*
+```
 
+[apidocs]: https://www.twilio.com/docs/api
+[libdocs]: https://twilio.github.io/twilio-node
 
+[test-workflow-image]: https://github.com/twilio/twilio-node/actions/workflows/test-and-deploy.yml/badge.svg
+[test-workflow-url]: https://github.com/twilio/twilio-node/actions/workflows/test-and-deploy.yml
+[npm-downloads-image]: https://img.shields.io/npm/dm/twilio.svg
+[npm-downloads-url]: https://npmcharts.com/compare/twilio?minimal=true
+[npm-install-size-image]: https://badgen.net/packagephobia/install/twilio
+[npm-install-size-url]: https://packagephobia.com/result?p=twilio
+[npm-url]: https://npmjs.org/package/twilio
+[npm-version-image]: https://img.shields.io/npm/v/twilio.svg

package/index.d.ts

@@ -0,0 +1,2 @@
+import lib from "./lib";
+export = lib;

package/index.js

@@ -1 +1,9 @@
-module.exports = require('./lib');
+"use strict";
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, "__esModule", { value: true });
+const lib_1 = __importDefault(require("./lib"));
+module.exports = lib_1.default;

package/lib/base/BaseTwilio.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+import RequestClient from "./RequestClient";
+import { HttpMethod } from "../interfaces";
+import { Headers } from "../http/request";
+declare namespace Twilio {
+    interface ClientOpts {
+        httpClient?: RequestClient;
+        accountSid?: string;
+        env?: NodeJS.ProcessEnv;
+        edge?: string;
+        region?: string;
+        lazyLoading?: boolean;
+        logLevel?: string;
+        userAgentExtensions?: string[];
+        autoRetry?: boolean;
+        maxRetries?: number;
+    }
+    interface RequestOpts {
+        method?: HttpMethod;
+        uri?: string;
+        username?: string;
+        password?: string;
+        headers?: Headers;
+        params?: object;
+        data?: object;
+        timeout?: number;
+        allowRedirects?: boolean;
+        logLevel?: string;
+    }
+    /**
+     * Parent class for Twilio Client that implements request & validation logic
+     */
+    class Client {
+        username: string;
+        password: string;
+        accountSid: string;
+        opts?: ClientOpts;
+        env?: NodeJS.ProcessEnv;
+        edge?: string;
+        region?: string;
+        logLevel?: string;
+        autoRetry: boolean;
+        maxRetries?: number;
+        userAgentExtensions?: string[];
+        _httpClient?: RequestClient;
+        /**
+         * Create a BaseTwilio instance
+         *
+         * @param username -
+         *          The username used for authentication. This is normally account sid, but if using key/secret auth will be
+         *          the api key sid.
+         * @param password -
+         *          The password used for authentication. This is normally auth token, but if using key/secret auth will be
+         *          the secret.
+         * @param opts - The options argument
+         *
+         * @returns A new instance of BaseTwilio
+         */
+        constructor(username?: string, password?: string, opts?: ClientOpts);
+        get httpClient(): RequestClient;
+        /**
+         * Makes a request to the Twilio API using the configured http client.
+         * Authentication information is automatically added if none is provided.
+         *
+         * @param opts - The options argument
+         */
+        request(opts: RequestOpts): Promise<any>;
+        /**
+         * Adds a region and/or edge to a given hostname
+         *
+         * @param hostname - A URI hostname (e.g. api.twilio.com)
+         * @param targetEdge - The targeted edge location (e.g. sydney)
+         * @param targetRegion - The targeted region location (e.g. au1)
+         */
+        getHostname(hostname: string, targetEdge: string | undefined, targetRegion: string | undefined): string;
+        /**
+         * Test if your environment is impacted by a TLS or certificate
+         * change is by sending an HTTP request to the test endpoint
+         *
+         * @throws RestException if the request fails
+         *
+         */
+        validateSslCert(): Promise<any>;
+    }
+}
+export = Twilio;

package/lib/base/BaseTwilio.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const RequestClient_1 = __importDefault(require("./RequestClient")); /* jshint ignore:line */
+const os = require("os"); /* jshint ignore:line */
+const url = require("url"); /* jshint ignore:line */
+const moduleInfo = require("../../package.json"); /* jshint ignore:line */
+const util = require("util"); /* jshint ignore:line */
+const RestException = require("../base/RestException"); /* jshint ignore:line */
+var Twilio;
+(function (Twilio) {
+    /* jshint ignore:start */
+    /**
+     * Parent class for Twilio Client that implements request & validation logic
+     */
+    /* jshint ignore:end */
+    class Client {
+        /* jshint ignore:start */
+        /**
+         * Create a BaseTwilio instance
+         *
+         * @param username -
+         *          The username used for authentication. This is normally account sid, but if using key/secret auth will be
+         *          the api key sid.
+         * @param password -
+         *          The password used for authentication. This is normally auth token, but if using key/secret auth will be
+         *          the secret.
+         * @param opts - The options argument
+         *
+         * @returns A new instance of BaseTwilio
+         */
+        /* jshint ignore:end */
+        constructor(username, password, opts) {
+            this.opts = opts || {};
+            this.env = this.opts.env || {};
+            this.username =
+                username ??
+                    this.env.TWILIO_ACCOUNT_SID ??
+                    process.env.TWILIO_ACCOUNT_SID ??
+                    (() => {
+                        throw new Error("username is required");
+                    })();
+            this.password =
+                password ??
+                    this.env.TWILIO_AUTH_TOKEN ??
+                    process.env.TWILIO_AUTH_TOKEN ??
+                    (() => {
+                        throw new Error("password is required");
+                    })();
+            this.accountSid = this.opts.accountSid || this.username;
+            this.edge =
+                this.opts.edge ?? this.env.TWILIO_EDGE ?? process.env.TWILIO_EDGE;
+            this.region =
+                this.opts.region ?? this.env.TWILIO_REGION ?? process.env.TWILIO_REGION;
+            this.logLevel =
+                this.opts.logLevel ??
+                    this.env.TWILIO_LOG_LEVEL ??
+                    process.env.TWILIO_LOG_LEVEL;
+            this.autoRetry = this.opts.autoRetry || false;
+            this.maxRetries = this.opts.maxRetries;
+            this.userAgentExtensions = this.opts.userAgentExtensions || [];
+            this._httpClient = this.opts.httpClient;
+            if (this.opts.lazyLoading === false) {
+                this._httpClient = this.httpClient;
+            }
+            if (!this.accountSid.startsWith("AC")) {
+                const apiKeyMsg = this.accountSid.startsWith("SK")
+                    ? ". The given SID indicates an API Key which requires the accountSid to be passed as an additional option"
+                    : "";
+                throw new Error("accountSid must start with AC" + apiKeyMsg);
+            }
+        }
+        get httpClient() {
+            if (!this._httpClient) {
+                this._httpClient = new RequestClient_1.default({
+                    autoRetry: this.autoRetry,
+                    maxRetries: this.maxRetries,
+                });
+            }
+            return this._httpClient;
+        }
+        /* jshint ignore:start */
+        /**
+         * Makes a request to the Twilio API using the configured http client.
+         * Authentication information is automatically added if none is provided.
+         *
+         * @param opts - The options argument
+         */
+        /* jshint ignore:end */
+        request(opts) {
+            opts = opts || {};
+            if (!opts.method) {
+                throw new Error("method is required");
+            }
+            if (!opts.uri) {
+                throw new Error("uri is required");
+            }
+            const username = opts.username || this.username;
+            const password = opts.password || this.password;
+            const headers = opts.headers || {};
+            const pkgVersion = moduleInfo.version;
+            const osName = os.platform();
+            const osArch = os.arch();
+            const nodeVersion = process.version;
+            headers["User-Agent"] = util.format("twilio-node/%s (%s %s) node/%s", pkgVersion, osName, osArch, nodeVersion);
+            this.userAgentExtensions?.forEach((extension) => {
+                headers["User-Agent"] += ` ${extension}`;
+            });
+            headers["Accept-Charset"] = "utf-8";
+            if (opts.method === "post" && !headers["Content-Type"]) {
+                headers["Content-Type"] = "application/x-www-form-urlencoded";
+            }
+            if (!headers["Accept"]) {
+                headers["Accept"] = "application/json";
+            }
+            var uri = new url.URL(opts.uri);
+            uri.hostname = this.getHostname(uri.hostname, this.edge, this.region);
+            return this.httpClient?.request({
+                method: opts.method,
+                uri: uri.href,
+                username: username,
+                password: password,
+                headers: headers,
+                params: opts.params,
+                data: opts.data,
+                timeout: opts.timeout,
+                allowRedirects: opts.allowRedirects,
+                logLevel: opts.logLevel,
+            });
+        }
+        /* jshint ignore:start */
+        /**
+         * Adds a region and/or edge to a given hostname
+         *
+         * @param hostname - A URI hostname (e.g. api.twilio.com)
+         * @param targetEdge - The targeted edge location (e.g. sydney)
+         * @param targetRegion - The targeted region location (e.g. au1)
+         */
+        /* jshint ignore:end */
+        getHostname(hostname, targetEdge, targetRegion) {
+            const defaultRegion = "us1";
+            const domain = hostname.split(".").slice(-2).join(".");
+            const prefix = hostname.split("." + domain)[0];
+            let [product, edge, region] = prefix.split(".");
+            if (edge && !region) {
+                region = edge;
+                edge = undefined;
+            }
+            region = targetRegion || region || (targetEdge && defaultRegion);
+            if (!region) {
+                return hostname;
+            }
+            edge = targetEdge || edge;
+            return [product, edge, region, domain].filter((part) => part).join(".");
+        }
+        /* jshint ignore:start */
+        /**
+         * Test if your environment is impacted by a TLS or certificate
+         * change is by sending an HTTP request to the test endpoint
+         *
+         * @throws RestException if the request fails
+         *
+         */
+        /* jshint ignore:end */
+        validateSslCert() {
+            return this.httpClient
+                ?.request({
+                method: "get",
+                uri: "https://tls-test.twilio.com:443",
+            })
+                .then((response) => {
+                if (response["statusCode"] < 200 || response["statusCode"] >= 300) {
+                    throw new RestException(response);
+                }
+                return response;
+            });
+        }
+    }
+    Twilio.Client = Client;
+})(Twilio || (Twilio = {}));
+module.exports = Twilio;

package/lib/base/Domain.d.ts

@@ -0,0 +1,29 @@
+import { Client as BaseTwilio, RequestOpts } from "./BaseTwilio";
+/**
+ * Base domain object
+ */
+export default class Domain {
+    twilio: BaseTwilio;
+    baseUrl: string;
+    /**
+     * Creates a Domain instance
+     *
+     * @param twilio - A Twilio Client
+     * @param baseUrl - Base url for this domain
+     */
+    constructor(twilio: BaseTwilio, baseUrl: string);
+    /**
+     * Turn a uri into an absolute url
+     *
+     * @param uri - uri to transform
+     * @returns absolute url
+     */
+    absoluteUrl(uri?: string): string;
+    /**
+     * Make request to this domain
+     *
+     * @param opts - request options
+     * @returns request promise
+     */
+    request(opts: RequestOpts): Promise<any>;
+}