@dereekb/nestjs 14.14.0 → 14.15.0

package/twilio/index.esm.js

@@ -1,13 +1,13 @@
 import { Injectable, Inject, Logger, Module, Post, Req, Controller, ForbiddenException } from '@nestjs/common';
 import * as twilioModule from 'twilio';
-import { performAsyncTasks, handlerFactory, handlerConfigurerFactory, handlerMappedSetFunctionFactory } from '@dereekb/util';
+import { performAsyncTasks, websiteUrlFromPaths, handlerFactory, handlerConfigurerFactory, handlerMappedSetFunctionFactory } from '@dereekb/util';
 import { ConfigService, ConfigModule } from '@nestjs/config';
-import { RawBody } from '@dereekb/nestjs';
+import { RawBody, DEFAULT_BASE_WEBHOOK_PATH } from '@dereekb/nestjs';
 
-function _class_call_check$e(instance, Constructor) {
+function _class_call_check$f(instance, Constructor) {
     if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
 }
-function _defineProperties$8(target, props) {
+function _defineProperties$9(target, props) {
     for(var i = 0; i < props.length; i++){
         var descriptor = props[i];
         descriptor.enumerable = descriptor.enumerable || false;
@@ -16,11 +16,11 @@ function _defineProperties$8(target, props) {
         Object.defineProperty(target, descriptor.key, descriptor);
     }
 }
-function _create_class$8(Constructor, protoProps, staticProps) {
-    if (staticProps) _defineProperties$8(Constructor, staticProps);
+function _create_class$9(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties$9(Constructor, staticProps);
     return Constructor;
 }
-function _define_property$b(obj, key, value) {
+function _define_property$e(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -37,21 +37,20 @@ var TWILIO_API_KEY_SID_ENV_VAR = 'TWILIO_API_KEY_SID';
 var TWILIO_API_KEY_SECRET_ENV_VAR = 'TWILIO_API_KEY_SECRET';
 var TWILIO_PHONE_NUMBER_ENV_VAR = 'TWILIO_PHONE_NUMBER';
 var TWILIO_MESSAGING_SERVICE_SID_ENV_VAR = 'TWILIO_MESSAGING_SERVICE_SID';
-var TWILIO_STATUS_CALLBACK_URL_ENV_VAR = 'TWILIO_STATUS_CALLBACK_URL';
 var TWILIO_SANDBOX_ENV_VAR = 'TWILIO_SANDBOX';
 /**
  * Configuration for {@link TwilioApi} and {@link TwilioService}.
  */ var TwilioServiceConfig = /*#__PURE__*/ function() {
     function TwilioServiceConfig() {
-        _class_call_check$e(this, TwilioServiceConfig);
+        _class_call_check$f(this, TwilioServiceConfig);
         /**
      * Client credentials.
-     */ _define_property$b(this, "twilio", void 0);
+     */ _define_property$e(this, "twilio", void 0);
         /**
      * Outbound message defaults.
-     */ _define_property$b(this, "messages", void 0);
+     */ _define_property$e(this, "messages", void 0);
     }
-    _create_class$8(TwilioServiceConfig, null, [
+    _create_class$9(TwilioServiceConfig, null, [
         {
             key: "assertValidConfig",
             value: function assertValidConfig(config) {
@@ -70,8 +69,97 @@ var TWILIO_SANDBOX_ENV_VAR = 'TWILIO_SANDBOX';
         }
     ]);
     return TwilioServiceConfig;
-} 
-();
+}();
+// MARK: Usable Config
+/**
+ * Values treated as unset by {@link usableTwilioServiceConfig}.
+ *
+ * These are the stand-in values a committed `.env` ships with, which are truthy and so pass
+ * {@link TwilioServiceConfig.assertValidConfig}, but crash the `twilio` SDK constructor.
+ */ var TWILIO_PLACEHOLDER_CONFIG_VALUES = [
+    '',
+    'placeholder',
+    'xxx'
+];
+/**
+ * Returns true if the input is unset or one of the {@link TWILIO_PLACEHOLDER_CONFIG_VALUES}.
+ *
+ * @param value - Configured value to check.
+ * @returns True if the value should be treated as unset.
+ */ function isPlaceholderTwilioConfigValue(value) {
+    return value == null || TWILIO_PLACEHOLDER_CONFIG_VALUES.includes(value.trim().toLowerCase());
+}
+/**
+ * Returns a copy of the input config with its placeholder and malformed values removed, or
+ * undefined if what remains cannot send SMS.
+ *
+ * A usable config has:
+ * - an Account SID starting with `AC`
+ * - an Auth Token, or an API Key SID starting with `SK` together with its secret
+ * - a sender phone number starting with `+`, or a Messaging Service SID starting with `MG`
+ *
+ * Values that are unset, one of the {@link TWILIO_PLACEHOLDER_CONFIG_VALUES}, or missing their
+ * expected prefix are dropped from the returned config, so a placeholder Messaging Service SID or
+ * API key never shadows a real sender or auth token. A status callback URL that is not an
+ * `http(s)` URL is dropped as well, since it does not affect whether the config can send.
+ *
+ * `twilioServiceConfigFactory()` uses this to remove placeholder values from a usable environment config.
+ *
+ * @param config - Config to check, typically read from the environment.
+ * @returns The usable config, or undefined if the config cannot send SMS.
+ *
+ * @example
+ * ```ts
+ * const config = usableTwilioServiceConfig(twilioServiceConfigFromConfigService(configService));
+ * ```
+ */ function usableTwilioServiceConfig(config) {
+    var realValueWithPrefix = function realValueWithPrefix(value, prefix) {
+        return !isPlaceholderTwilioConfigValue(value) && (prefix == null || value.startsWith(prefix)) ? value : undefined;
+    };
+    var result;
+    if (config) {
+        var twilio = config.twilio, messages = config.messages;
+        var accountSid = realValueWithPrefix(twilio.accountSid, 'AC');
+        var authToken = realValueWithPrefix(twilio.authToken);
+        var apiKeySid = realValueWithPrefix(twilio.apiKeySid, 'SK');
+        var apiKeySecret = realValueWithPrefix(twilio.apiKeySecret);
+        var hasApiKey = apiKeySid != null && apiKeySecret != null;
+        var defaultFrom = realValueWithPrefix(messages.defaultFrom, '+');
+        var messagingServiceSid = realValueWithPrefix(messages.messagingServiceSid, 'MG');
+        var defaultStatusCallback = realValueWithPrefix(messages.defaultStatusCallback, 'http');
+        if (accountSid && (authToken || hasApiKey) && (defaultFrom || messagingServiceSid)) {
+            result = {
+                twilio: {
+                    accountSid: accountSid,
+                    authToken: authToken,
+                    apiKeySid: hasApiKey ? apiKeySid : undefined,
+                    apiKeySecret: hasApiKey ? apiKeySecret : undefined
+                },
+                messages: {
+                    defaultFrom: defaultFrom,
+                    messagingServiceSid: messagingServiceSid,
+                    defaultStatusCallback: defaultStatusCallback,
+                    sandbox: messages.sandbox
+                }
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Returns true if {@link usableTwilioServiceConfig} can build a usable config from the input.
+ *
+ * Use it to decide whether a provided `TwilioService` can send, e.g.
+ * `isUsableTwilioServiceConfig(twilioService.twilioApi.config)`.
+ *
+ * Note that a usable config may still carry placeholder values; pass the input through
+ * {@link usableTwilioServiceConfig} to get a copy with them removed before using it.
+ *
+ * @param config - Config to check, typically read from the environment.
+ * @returns True if the config can send SMS.
+ */ function isUsableTwilioServiceConfig(config) {
+    return usableTwilioServiceConfig(config) != null;
+}
 
 function _type_of(obj) {
     "@swc/helpers - typeof";
@@ -97,10 +185,23 @@ var _twilioModule_default;
 var twilio = (_twilioModule_default = twilioModule.default) !== null && _twilioModule_default !== void 0 ? _twilioModule_default : twilioModule;
 var Twilio = twilio.Twilio, validateRequest = twilio.validateRequest;
 
-function _class_call_check$d(instance, Constructor) {
+function _class_call_check$e(instance, Constructor) {
     if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
 }
-function _define_property$a(obj, key, value) {
+function _defineProperties$8(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$8(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$8(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$d(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -111,28 +212,543 @@ function _define_property$a(obj, key, value) {
     } else obj[key] = value;
     return obj;
 }
-var TwilioApi = function TwilioApi(config) {
-    _class_call_check$d(this, TwilioApi);
-    _define_property$a(this, "config", void 0);
-    _define_property$a(this, "client", void 0);
-    this.config = config;
-    var _config_twilio = config.twilio, accountSid = _config_twilio.accountSid, authToken = _config_twilio.authToken, apiKeySid = _config_twilio.apiKeySid, apiKeySecret = _config_twilio.apiKeySecret;
-    var client;
-    if (apiKeySid && apiKeySecret) {
-        client = new Twilio(apiKeySid, apiKeySecret, {
-            accountSid: accountSid
-        });
-    } else {
-        client = new Twilio(accountSid, authToken);
+var TwilioApi = /*#__PURE__*/ function() {
+    function TwilioApi(config) {
+        _class_call_check$e(this, TwilioApi);
+        _define_property$d(this, "config", void 0);
+        _define_property$d(this, "_client", void 0);
+        this.config = config;
     }
-    this.client = client;
-};
+    _create_class$8(TwilioApi, [
+        {
+            key: "client",
+            get: /**
+     * The Twilio SDK client, created on first access.
+     *
+     * Created lazily because the SDK constructor throws when the Account SID does not start with `AC`, so a
+     * config holding the placeholder values of a committed `.env` can still be provided. Accessing the client
+     * with such a config throws.
+     *
+     * @returns The Twilio SDK client.
+     */ function get() {
+                if (!this._client) {
+                    var _this_config_twilio = this.config.twilio, accountSid = _this_config_twilio.accountSid, authToken = _this_config_twilio.authToken, apiKeySid = _this_config_twilio.apiKeySid, apiKeySecret = _this_config_twilio.apiKeySecret;
+                    this._client = apiKeySid && apiKeySecret ? new Twilio(apiKeySid, apiKeySecret, {
+                        accountSid: accountSid
+                    }) : new Twilio(accountSid, authToken);
+                }
+                return this._client;
+            }
+        }
+    ]);
+    return TwilioApi;
+}();
 TwilioApi = __decorate([
     Injectable(),
     __param(0, Inject(TwilioServiceConfig))
 ], TwilioApi);
 
-function _array_like_to_array(arr, len) {
+function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator$5(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$c(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
+function _instanceof$2(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+function _object_spread$4(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$c(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _ts_generator$5(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * The default number of messages to read back when inspecting a number's recent texts.
+ */ var DEFAULT_TWILIO_RECENT_MESSAGES_LIMIT = 20;
+/**
+ * The default window of history to inspect when reading a number's recent texts.
+ */ var DEFAULT_TWILIO_RECENT_MESSAGES_WINDOW_DAYS = 30;
+/**
+ * Twilio error codes relevant to delivery diagnosis.
+ *
+ * Twilio reports these on a failed or undelivered message, and on the error a rejected send throws. Twilio
+ * notes that the code for a given cause may change as it improves its errors, so treat them as hints and
+ * keep the error message alongside. Unknown codes are passed through untouched.
+ */ var TwilioMessageErrorCode;
+(function(TwilioMessageErrorCode) {
+    /**
+     * The `To` number is not a valid phone number.
+     */ TwilioMessageErrorCode[TwilioMessageErrorCode["INVALID_TO_NUMBER"] = 21211] = "INVALID_TO_NUMBER";
+    /**
+     * The recipient replied STOP, so the sender may not text them until they reply START.
+     */ TwilioMessageErrorCode[TwilioMessageErrorCode["UNSUBSCRIBED_RECIPIENT"] = 21610] = "UNSUBSCRIBED_RECIPIENT";
+    /**
+     * The `To` number is not a mobile number, so it cannot receive texts.
+     */ TwilioMessageErrorCode[TwilioMessageErrorCode["NOT_A_MOBILE_NUMBER"] = 21614] = "NOT_A_MOBILE_NUMBER";
+    /**
+     * The account's message queue overflowed. Temporary.
+     */ TwilioMessageErrorCode[TwilioMessageErrorCode["QUEUE_OVERFLOW"] = 30001] = "QUEUE_OVERFLOW";
+    /**
+     * The Twilio account is suspended.
+     */ TwilioMessageErrorCode[TwilioMessageErrorCode["ACCOUNT_SUSPENDED"] = 30002] = "ACCOUNT_SUSPENDED";
+    /**
+     * The phone is switched off or out of coverage. Usually temporary.
+     */ TwilioMessageErrorCode[TwilioMessageErrorCode["UNREACHABLE_DESTINATION_HANDSET"] = 30003] = "UNREACHABLE_DESTINATION_HANDSET";
+    /**
+     * The carrier or the phone blocked the message.
+     */ TwilioMessageErrorCode[TwilioMessageErrorCode["MESSAGE_BLOCKED"] = 30004] = "MESSAGE_BLOCKED";
+    /**
+     * The number does not exist or is no longer in service.
+     */ TwilioMessageErrorCode[TwilioMessageErrorCode["UNKNOWN_DESTINATION_HANDSET"] = 30005] = "UNKNOWN_DESTINATION_HANDSET";
+    /**
+     * The number is a landline, or its carrier cannot receive texts.
+     */ TwilioMessageErrorCode[TwilioMessageErrorCode["LANDLINE_OR_UNREACHABLE_CARRIER"] = 30006] = "LANDLINE_OR_UNREACHABLE_CARRIER";
+    /**
+     * The carrier filtered the message, usually as suspected spam.
+     */ TwilioMessageErrorCode[TwilioMessageErrorCode["MESSAGE_FILTERED"] = 30007] = "MESSAGE_FILTERED";
+    /**
+     * Twilio could not determine why the message failed. Often temporary.
+     */ TwilioMessageErrorCode[TwilioMessageErrorCode["UNKNOWN_ERROR"] = 30008] = "UNKNOWN_ERROR";
+    /**
+     * The sending number is not registered for A2P 10DLC messaging, so US carriers block it.
+     */ TwilioMessageErrorCode[TwilioMessageErrorCode["UNREGISTERED_NUMBER"] = 30034] = "UNREGISTERED_NUMBER";
+})(TwilioMessageErrorCode || (TwilioMessageErrorCode = {}));
+/**
+ * Converts a Twilio message instance to a {@link TwilioDiagnosticMessage}.
+ *
+ * @param message - The message instance.
+ * @returns The diagnostic message.
+ */ function twilioDiagnosticMessage(message) {
+    var sid = message.sid, status = message.status, to = message.to, errorCode = message.errorCode, errorMessage = message.errorMessage, dateSent = message.dateSent, dateCreated = message.dateCreated, dateUpdated = message.dateUpdated;
+    return {
+        sid: sid,
+        status: status,
+        to: to,
+        errorCode: errorCode !== null && errorCode !== void 0 ? errorCode : undefined,
+        errorMessage: errorMessage || undefined,
+        dateSent: dateSent !== null && dateSent !== void 0 ? dateSent : undefined,
+        dateCreated: dateCreated !== null && dateCreated !== void 0 ? dateCreated : undefined,
+        dateUpdated: dateUpdated !== null && dateUpdated !== void 0 ? dateUpdated : undefined
+    };
+}
+/**
+ * Returns the time a message last changed state: its update time, falling back to its send and creation times.
+ *
+ * @param message - The message.
+ * @returns The time, if Twilio recorded any.
+ */ function twilioDiagnosticMessageDate(message) {
+    var _ref, _message_dateUpdated;
+    return (_ref = (_message_dateUpdated = message.dateUpdated) !== null && _message_dateUpdated !== void 0 ? _message_dateUpdated : message.dateSent) !== null && _ref !== void 0 ? _ref : message.dateCreated;
+}
+/**
+ * Returns the Twilio error code of a thrown Twilio error, such as the error a rejected send throws.
+ *
+ * @param error - The thrown value.
+ * @returns The error code, if the error carries one.
+ */ function twilioErrorCode(error) {
+    var code = error === null || error === void 0 ? void 0 : error.code;
+    return typeof code === 'number' ? code : undefined;
+}
+/**
+ * Returns the HTTP status of a thrown Twilio error.
+ *
+ * @param error - The thrown value.
+ * @returns The HTTP status, if the error carries one.
+ */ function twilioErrorStatus(error) {
+    var status = error === null || error === void 0 ? void 0 : error.status;
+    return typeof status === 'number' ? status : undefined;
+}
+/**
+ * Converts a thrown value to a {@link TwilioDiagnosticError}.
+ *
+ * @param error - The thrown value.
+ * @returns The diagnostic error.
+ */ function twilioDiagnosticError(error) {
+    return {
+        message: _instanceof$2(error, Error) ? error.message : String(error),
+        status: twilioErrorStatus(error),
+        code: twilioErrorCode(error)
+    };
+}
+/**
+ * Whether a diagnostic read was refused because of the credentials, rather than failing to reach Twilio.
+ *
+ * @param error - The read's error, if it failed.
+ * @returns True if Twilio answered with 401 or 403.
+ */ function isTwilioDiagnosticPermissionError(error) {
+    return (error === null || error === void 0 ? void 0 : error.status) === 401 || (error === null || error === void 0 ? void 0 : error.status) === 403;
+}
+/**
+ * Reads the messages recently sent to a number, newest first.
+ *
+ * @param api - The Twilio API.
+ * @param to - The number the messages were sent to.
+ * @param options - How many messages to read, and how far back.
+ * @returns The messages, with `unknown` set if they could not be read.
+ */ function twilioRecentMessagesForRecipient(api, to, options) {
+    return _async_to_generator$5(function() {
+        var _ref, _ref1, limit, dateSentAfter, result, messages, e;
+        return _ts_generator$5(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    limit = (_ref = options === null || options === void 0 ? void 0 : options.limit) !== null && _ref !== void 0 ? _ref : DEFAULT_TWILIO_RECENT_MESSAGES_LIMIT;
+                    dateSentAfter = (_ref1 = options === null || options === void 0 ? void 0 : options.dateSentAfter) !== null && _ref1 !== void 0 ? _ref1 : undefined;
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    return [
+                        4,
+                        api.client.messages.list(_object_spread$4({
+                            to: to,
+                            limit: limit
+                        }, dateSentAfter ? {
+                            dateSentAfter: dateSentAfter
+                        } : {}))
+                    ];
+                case 2:
+                    messages = _state.sent();
+                    result = {
+                        messages: messages.map(function(x) {
+                            return twilioDiagnosticMessage(x);
+                        })
+                    };
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    e = _state.sent();
+                    result = {
+                        messages: [],
+                        unknown: true,
+                        error: twilioDiagnosticError(e)
+                    };
+                    return [
+                        3,
+                        4
+                    ];
+                case 4:
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Reads a single message, such as a test message whose outcome is being followed.
+ *
+ * @param api - The Twilio API.
+ * @param sid - The message SID.
+ * @returns The message, with `unknown` set if it could not be read.
+ */ function twilioMessageForSid(api, sid) {
+    return _async_to_generator$5(function() {
+        var result, message, e;
+        return _ts_generator$5(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        api.client.messages(sid).fetch()
+                    ];
+                case 1:
+                    message = _state.sent();
+                    result = {
+                        message: twilioDiagnosticMessage(message)
+                    };
+                    return [
+                        3,
+                        3
+                    ];
+                case 2:
+                    e = _state.sent();
+                    result = twilioErrorStatus(e) === 404 ? {} : {
+                        unknown: true,
+                        error: twilioDiagnosticError(e)
+                    };
+                    return [
+                        3,
+                        3
+                    ];
+                case 3:
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Reads the account's state.
+ *
+ * Twilio does not let a Standard API key read the account, so with one this is always `unknown`, with a permission
+ * error. See {@link isTwilioDiagnosticPermissionError}.
+ *
+ * An account that is not `active` sends nothing regardless of the recipient, so this distinguishes a system-wide
+ * outage from a per-recipient problem.
+ *
+ * @param api - The Twilio API.
+ * @returns The account's state, with `unknown` set if it could not be read.
+ */ function twilioAccountState(api) {
+    return _async_to_generator$5(function() {
+        var state, account, e;
+        return _ts_generator$5(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        api.client.api.v2010.account.fetch()
+                    ];
+                case 1:
+                    account = _state.sent();
+                    state = {
+                        status: account.status
+                    };
+                    return [
+                        3,
+                        3
+                    ];
+                case 2:
+                    e = _state.sent();
+                    state = {
+                        unknown: true,
+                        error: twilioDiagnosticError(e)
+                    };
+                    return [
+                        3,
+                        3
+                    ];
+                case 3:
+                    return [
+                        2,
+                        state
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Looks up a number with Twilio Lookup v2.
+ *
+ * Unlike {@link TwilioLookupService.lookup}, a failed lookup is reported as `unknown` rather than as an invalid number.
+ *
+ * @param api - The Twilio API.
+ * @param phoneNumber - The number to look up.
+ * @param includeLineType - Whether to request the line type. Twilio charges per lookup for it.
+ * @returns The diagnosis, with `unknown` set if the lookup could not be made.
+ */ function twilioLookupPhoneNumberForDiagnosis(api, phoneNumber, includeLineType) {
+    return _async_to_generator$5(function() {
+        var result, _ref, _ref1, lookup, lineTypeIntelligence, e;
+        return _ts_generator$5(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        api.client.lookups.v2.phoneNumbers(phoneNumber).fetch(includeLineType ? {
+                            fields: 'line_type_intelligence'
+                        } : {})
+                    ];
+                case 1:
+                    lookup = _state.sent();
+                    lineTypeIntelligence = lookup.lineTypeIntelligence;
+                    result = {
+                        valid: Boolean(lookup.valid),
+                        lineType: (_ref = lineTypeIntelligence === null || lineTypeIntelligence === void 0 ? void 0 : lineTypeIntelligence['type']) !== null && _ref !== void 0 ? _ref : undefined,
+                        carrierName: (_ref1 = lineTypeIntelligence === null || lineTypeIntelligence === void 0 ? void 0 : lineTypeIntelligence['carrier_name']) !== null && _ref1 !== void 0 ? _ref1 : undefined
+                    };
+                    return [
+                        3,
+                        3
+                    ];
+                case 2:
+                    e = _state.sent();
+                    result = {
+                        unknown: true,
+                        error: twilioDiagnosticError(e)
+                    };
+                    return [
+                        3,
+                        3
+                    ];
+                case 3:
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+
+function _array_like_to_array$5(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
@@ -166,7 +782,7 @@ function _async_to_generator$4(fn) {
         });
     };
 }
-function _class_call_check$c(instance, Constructor) {
+function _class_call_check$d(instance, Constructor) {
     if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
 }
 function _defineProperties$7(target, props) {
@@ -182,7 +798,7 @@ function _create_class$7(Constructor, protoProps, staticProps) {
     if (protoProps) _defineProperties$7(Constructor.prototype, protoProps);
     return Constructor;
 }
-function _define_property$9(obj, key, value) {
+function _define_property$b(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -226,7 +842,7 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _object_spread$2(target) {
+function _object_spread$3(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
         var ownKeys = Object.keys(source);
@@ -236,13 +852,13 @@ function _object_spread$2(target) {
             }));
         }
         ownKeys.forEach(function(key) {
-            _define_property$9(target, key, source[key]);
+            _define_property$b(target, key, source[key]);
         });
     }
     return target;
 }
 function _sliced_to_array(arr, i) {
-    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$5(arr, i) || _non_iterable_rest();
 }
 function _ts_generator$4(thisArg, body) {
     var f, y, t, _ = {
@@ -343,22 +959,22 @@ function _ts_generator$4(thisArg, body) {
         };
     }
 }
-function _unsupported_iterable_to_array(o, minLen) {
+function _unsupported_iterable_to_array$5(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$5(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$5(o, minLen);
 }
 /**
  * Maximum number of concurrent SMS send requests issued by {@link TwilioService.sendBulkSms}.
  */ var DEFAULT_TWILIO_SEND_SMS_MAX_PARALLEL_TASKS = 5;
 var TwilioService = /*#__PURE__*/ function() {
     function TwilioService(twilioApi) {
-        _class_call_check$c(this, TwilioService);
-        _define_property$9(this, "logger", new Logger('TwilioService'));
-        _define_property$9(this, "_twilioApi", void 0);
+        _class_call_check$d(this, TwilioService);
+        _define_property$b(this, "logger", new Logger('TwilioService'));
+        _define_property$b(this, "_twilioApi", void 0);
         this._twilioApi = twilioApi;
     }
     _create_class$7(TwilioService, [
@@ -411,7 +1027,7 @@ var TwilioService = /*#__PURE__*/ function() {
                                 ]);
                                 return [
                                     4,
-                                    this._twilioApi.client.messages.create(_object_spread$2({
+                                    this._twilioApi.client.messages.create(_object_spread$3({
                                         to: input.to,
                                         body: input.body
                                     }, messagingServiceSid ? {
@@ -445,7 +1061,8 @@ var TwilioService = /*#__PURE__*/ function() {
                                     to: input.to,
                                     status: 'failed',
                                     sandboxed: false,
-                                    error: errorMessage
+                                    error: errorMessage,
+                                    errorCode: twilioErrorCode(e)
                                 };
                                 return [
                                     3,
@@ -510,16 +1127,150 @@ TwilioService = __decorate([
     __param(0, Inject(TwilioApi))
 ], TwilioService);
 
+function _class_call_check$c(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _define_property$a(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
+/**
+ * Path of the {@link TwilioWebhookController} under the app's webhook path (`/webhook`).
+ */ var TWILIO_WEBHOOK_PATH = '/twilio';
+/**
+ * Path of the message status callback route under {@link TWILIO_WEBHOOK_PATH}.
+ */ var TWILIO_WEBHOOK_STATUS_PATH = '/status';
+/**
+ * Path of the incoming message route under {@link TWILIO_WEBHOOK_PATH}.
+ */ var TWILIO_WEBHOOK_INCOMING_PATH = '/incoming';
+/**
+ * Builds the public URLs of the {@link TwilioWebhookController} routes from the app's public webhook URL.
+ *
+ * The `baseUrl` is the origin of the webhook URL, since the verifier appends the request's full path to it.
+ * This assumes requests reach the app with their public path intact, as they do through a Firebase Hosting
+ * rewrite.
+ *
+ * @param webhookUrl - Public URL the app's `/webhook` routes are served at, e.g. `https://app.example.com/api/webhook`.
+ * @returns The Twilio webhook URLs.
+ */ function twilioWebhookUrls(webhookUrl) {
+    return {
+        baseUrl: new URL(webhookUrl).origin,
+        statusCallbackUrl: websiteUrlFromPaths(webhookUrl, [
+            TWILIO_WEBHOOK_PATH,
+            TWILIO_WEBHOOK_STATUS_PATH
+        ]),
+        incomingMessageUrl: websiteUrlFromPaths(webhookUrl, [
+            TWILIO_WEBHOOK_PATH,
+            TWILIO_WEBHOOK_INCOMING_PATH
+        ])
+    };
+}
+/**
+ * The app's public Twilio webhook URLs, provided to the Twilio modules through their `dependencyModule`.
+ *
+ * When a module built by `appTwilioModuleMetadata()` can resolve it, outbound texts request status callbacks at
+ * {@link TwilioWebhookUrls.statusCallbackUrl}. When one built by `appTwilioWebhookModuleMetadata()` can, webhook
+ * requests are verified against {@link TwilioWebhookUrls.baseUrl}.
+ *
+ * `twilioWebhookUrlsConfigProvider()` from `@dereekb/firebase-server/twilio` provides it from the server environment.
+ */ var TwilioWebhookUrlsConfig = function TwilioWebhookUrlsConfig() {
+    _class_call_check$c(this, TwilioWebhookUrlsConfig);
+    /**
+     * The URLs, or undefined when Twilio cannot reach the app's webhooks.
+     */ _define_property$a(this, "twilioWebhookUrls", void 0);
+} 
+;
+
+function _array_like_to_array$4(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$4(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$4(arr);
+}
 function _class_call_check$b(instance, Constructor) {
     if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
 }
+function _define_property$9(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
+function _iterable_to_array$4(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _non_iterable_spread$4() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$2(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$9(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$1(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$1(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else {
+        ownKeys$1(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array$4(arr) {
+    return _array_without_holes$4(arr) || _iterable_to_array$4(arr) || _unsupported_iterable_to_array$4(arr) || _non_iterable_spread$4();
+}
+function _unsupported_iterable_to_array$4(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$4(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$4(o, minLen);
+}
 /**
- * Factory that creates a {@link TwilioServiceConfig} from environment variables.
+ * Reads a {@link TwilioServiceConfig} from environment variables without validating it.
+ *
+ * {@link twilioServiceConfigFactory} builds the validated config from it.
  *
  * @param configService - NestJS config service for reading environment variables.
- * @returns A validated {@link TwilioServiceConfig}.
- */ function twilioServiceConfigFactory(configService) {
-    var config = {
+ * @returns The unvalidated {@link TwilioServiceConfig}.
+ */ function twilioServiceConfigFromConfigService(configService) {
+    return {
         twilio: {
             accountSid: configService.get(TWILIO_ACCOUNT_SID_ENV_VAR),
             authToken: configService.get(TWILIO_AUTH_TOKEN_ENV_VAR),
@@ -529,42 +1280,84 @@ function _class_call_check$b(instance, Constructor) {
         messages: {
             defaultFrom: configService.get(TWILIO_PHONE_NUMBER_ENV_VAR),
             messagingServiceSid: configService.get(TWILIO_MESSAGING_SERVICE_SID_ENV_VAR),
-            defaultStatusCallback: configService.get(TWILIO_STATUS_CALLBACK_URL_ENV_VAR),
             sandbox: configService.get(TWILIO_SANDBOX_ENV_VAR) === 'true'
         }
     };
-    TwilioServiceConfig.assertValidConfig(config);
-    return config;
 }
 /**
- * NestJS module that provides the {@link TwilioApi} and {@link TwilioService} for sending SMS
- * via Twilio.
+ * Factory that creates a {@link TwilioServiceConfig} from environment variables.
  *
- * Reads Twilio credentials and default sender configuration from environment variables.
- */ var TwilioModule = function TwilioModule() {
-    _class_call_check$b(this, TwilioModule);
-};
-TwilioModule = __decorate([
-    Module({
+ * When the environment holds a usable config, its placeholder values are removed (see
+ * {@link usableTwilioServiceConfig}), so a placeholder Messaging Service SID or API key never shadows a real
+ * sender or auth token. Otherwise the placeholder values are kept, which lets the app start; {@link TwilioApi}
+ * only creates the SDK client when it is first used.
+ *
+ * @param configService - NestJS config service for reading environment variables.
+ * @param webhookUrlsConfig - The app's public webhook URLs. When set, outbound texts request status callbacks at its status callback URL.
+ * @returns A validated {@link TwilioServiceConfig}.
+ */ function twilioServiceConfigFactory(configService, webhookUrlsConfig) {
+    var _usableTwilioServiceConfig, _ref;
+    var _webhookUrlsConfig_twilioWebhookUrls;
+    var envConfig = twilioServiceConfigFromConfigService(configService);
+    var config = (_usableTwilioServiceConfig = usableTwilioServiceConfig(envConfig)) !== null && _usableTwilioServiceConfig !== void 0 ? _usableTwilioServiceConfig : envConfig;
+    var defaultStatusCallback = (_ref = webhookUrlsConfig === null || webhookUrlsConfig === void 0 ? void 0 : (_webhookUrlsConfig_twilioWebhookUrls = webhookUrlsConfig.twilioWebhookUrls) === null || _webhookUrlsConfig_twilioWebhookUrls === void 0 ? void 0 : _webhookUrlsConfig_twilioWebhookUrls.statusCallbackUrl) !== null && _ref !== void 0 ? _ref : config.messages.defaultStatusCallback;
+    var result = _object_spread_props$1(_object_spread$2({}, config), {
+        messages: _object_spread_props$1(_object_spread$2({}, config.messages), {
+            defaultStatusCallback: defaultStatusCallback
+        })
+    });
+    TwilioServiceConfig.assertValidConfig(result);
+    return result;
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's Twilio module, which provides
+ * {@link TwilioApi} and {@link TwilioService} for sending SMS.
+ *
+ * Reads the Twilio credentials and default sender from environment variables.
+ *
+ * @param config - The module metadata configuration including the optional dependency module.
+ * @returns NestJS ModuleMetadata for registering the Twilio module.
+ */ function appTwilioModuleMetadata(config) {
+    var _ref = config !== null && config !== void 0 ? config : {}, dependencyModule = _ref.dependencyModule, imports = _ref.imports, exports = _ref.exports, providers = _ref.providers;
+    var dependencyModuleImport = dependencyModule ? [
+        dependencyModule
+    ] : [];
+    return {
         imports: [
             ConfigModule
-        ],
+        ].concat(_to_consumable_array$4(dependencyModuleImport), _to_consumable_array$4(imports !== null && imports !== void 0 ? imports : [])),
+        exports: [
+            TwilioApi,
+            TwilioService
+        ].concat(_to_consumable_array$4(exports !== null && exports !== void 0 ? exports : [])),
         providers: [
             {
                 provide: TwilioServiceConfig,
                 inject: [
-                    ConfigService
+                    ConfigService,
+                    {
+                        token: TwilioWebhookUrlsConfig,
+                        optional: true
+                    }
                 ],
                 useFactory: twilioServiceConfigFactory
             },
             TwilioApi,
             TwilioService
-        ],
-        exports: [
-            TwilioApi,
-            TwilioService
-        ]
-    })
+        ].concat(_to_consumable_array$4(providers !== null && providers !== void 0 ? providers : []))
+    };
+}
+/**
+ * NestJS module that provides the {@link TwilioApi} and {@link TwilioService} for sending SMS
+ * via Twilio.
+ *
+ * Reads Twilio credentials and default sender configuration from environment variables. Use
+ * {@link appTwilioModuleMetadata} to supply the app's webhook URLs.
+ */ var TwilioModule = function TwilioModule() {
+    _class_call_check$b(this, TwilioModule);
+};
+TwilioModule = __decorate([
+    Module(appTwilioModuleMetadata())
 ], TwilioModule);
 
 function _class_call_check$a(instance, Constructor) {
@@ -878,30 +1671,67 @@ TwilioLookupService = __decorate([
     __param(0, Inject(TwilioLookupApi))
 ], TwilioLookupService);
 
+function _array_like_to_array$3(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$3(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$3(arr);
+}
 function _class_call_check$8(instance, Constructor) {
     if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
 }
+function _iterable_to_array$3(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _non_iterable_spread$3() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array$3(arr) {
+    return _array_without_holes$3(arr) || _iterable_to_array$3(arr) || _unsupported_iterable_to_array$3(arr) || _non_iterable_spread$3();
+}
+function _unsupported_iterable_to_array$3(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
+}
 /**
- * NestJS module that exposes Twilio Lookup v2 (phone validation, carrier info).
+ * Convenience function used to generate ModuleMetadata for an app's Twilio Lookup v2 (phone validation, carrier info) module.
  *
- * Imports {@link TwilioModule} for the underlying Twilio client.
- */ var TwilioLookupModule = function TwilioLookupModule() {
-    _class_call_check$8(this, TwilioLookupModule);
-};
-TwilioLookupModule = __decorate([
-    Module({
+ * @param config - The module metadata configuration including the dependency module.
+ * @returns NestJS ModuleMetadata for registering the Twilio Lookup module.
+ */ function appTwilioLookupModuleMetadata(config) {
+    var _ref = config !== null && config !== void 0 ? config : {}, dependencyModule = _ref.dependencyModule, imports = _ref.imports, exports = _ref.exports, providers = _ref.providers;
+    return {
         imports: [
-            TwilioModule
-        ],
-        providers: [
+            dependencyModule !== null && dependencyModule !== void 0 ? dependencyModule : TwilioModule
+        ].concat(_to_consumable_array$3(imports !== null && imports !== void 0 ? imports : [])),
+        exports: [
             TwilioLookupApi,
             TwilioLookupService
-        ],
-        exports: [
+        ].concat(_to_consumable_array$3(exports !== null && exports !== void 0 ? exports : [])),
+        providers: [
             TwilioLookupApi,
             TwilioLookupService
-        ]
-    })
+        ].concat(_to_consumable_array$3(providers !== null && providers !== void 0 ? providers : []))
+    };
+}
+/**
+ * NestJS module that exposes Twilio Lookup v2 (phone validation, carrier info).
+ *
+ * Imports {@link TwilioModule} for the underlying Twilio client. Use {@link appTwilioLookupModuleMetadata}
+ * to use the app's own Twilio module instead.
+ */ var TwilioLookupModule = function TwilioLookupModule() {
+    _class_call_check$8(this, TwilioLookupModule);
+};
+TwilioLookupModule = __decorate([
+    Module(appTwilioLookupModuleMetadata())
 ], TwilioLookupModule);
 
 function _class_call_check$7(instance, Constructor) {
@@ -1287,9 +2117,36 @@ TwilioVerifyService = __decorate([
     __param(0, Inject(TwilioVerifyApi))
 ], TwilioVerifyService);
 
+function _array_like_to_array$2(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$2(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$2(arr);
+}
 function _class_call_check$4(instance, Constructor) {
     if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
 }
+function _iterable_to_array$2(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _non_iterable_spread$2() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array$2(arr) {
+    return _array_without_holes$2(arr) || _iterable_to_array$2(arr) || _unsupported_iterable_to_array$2(arr) || _non_iterable_spread$2();
+}
+function _unsupported_iterable_to_array$2(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+}
 /**
  * Factory that creates a {@link TwilioVerifyServiceConfig} from environment variables.
  *
@@ -1305,19 +2162,21 @@ function _class_call_check$4(instance, Constructor) {
     return config;
 }
 /**
- * NestJS module that exposes Twilio Verify (OTP / 2FA) for starting verifications and
- * checking submitted codes.
+ * Convenience function used to generate ModuleMetadata for an app's Twilio Verify (OTP / 2FA) module.
  *
- * Imports {@link TwilioModule} for the underlying Twilio client.
- */ var TwilioVerifyModule = function TwilioVerifyModule() {
-    _class_call_check$4(this, TwilioVerifyModule);
-};
-TwilioVerifyModule = __decorate([
-    Module({
+ * @param config - The module metadata configuration including the dependency module.
+ * @returns NestJS ModuleMetadata for registering the Twilio Verify module.
+ */ function appTwilioVerifyModuleMetadata(config) {
+    var _ref = config !== null && config !== void 0 ? config : {}, dependencyModule = _ref.dependencyModule, imports = _ref.imports, exports = _ref.exports, providers = _ref.providers;
+    return {
         imports: [
             ConfigModule,
-            TwilioModule
-        ],
+            dependencyModule !== null && dependencyModule !== void 0 ? dependencyModule : TwilioModule
+        ].concat(_to_consumable_array$2(imports !== null && imports !== void 0 ? imports : [])),
+        exports: [
+            TwilioVerifyApi,
+            TwilioVerifyService
+        ].concat(_to_consumable_array$2(exports !== null && exports !== void 0 ? exports : [])),
         providers: [
             {
                 provide: TwilioVerifyServiceConfig,
@@ -1328,12 +2187,20 @@ TwilioVerifyModule = __decorate([
             },
             TwilioVerifyApi,
             TwilioVerifyService
-        ],
-        exports: [
-            TwilioVerifyApi,
-            TwilioVerifyService
-        ]
-    })
+        ].concat(_to_consumable_array$2(providers !== null && providers !== void 0 ? providers : []))
+    };
+}
+/**
+ * NestJS module that exposes Twilio Verify (OTP / 2FA) for starting verifications and
+ * checking submitted codes.
+ *
+ * Imports {@link TwilioModule} for the underlying Twilio client. Use {@link appTwilioVerifyModuleMetadata}
+ * to use the app's own Twilio module instead.
+ */ var TwilioVerifyModule = function TwilioVerifyModule() {
+    _class_call_check$4(this, TwilioVerifyModule);
+};
+TwilioVerifyModule = __decorate([
+    Module(appTwilioVerifyModuleMetadata())
 ], TwilioVerifyModule);
 
 function _define_property$3(obj, key, value) {
@@ -1400,6 +2267,125 @@ var twilioWebhookEventHandlerConfigurerFactory = handlerConfigurerFactory({
     }
 });
 
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+}
+function _iterable_to_array$1(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _non_iterable_spread$1() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array$1(arr) {
+    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread$1();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+/**
+ * The opt-out keyword type Twilio reports on an incoming message (`OptOutType`).
+ *
+ * https://help.twilio.com/articles/31560110671259
+ */ var TwilioOptOutType;
+(function(TwilioOptOutType) {
+    /**
+     * The sender opted out. Twilio blocks every message to them until they opt back in.
+     */ TwilioOptOutType["STOP"] = "STOP";
+    /**
+     * The sender opted back in.
+     */ TwilioOptOutType["START"] = "START";
+    /**
+     * The sender asked for help.
+     */ TwilioOptOutType["HELP"] = "HELP";
+})(TwilioOptOutType || (TwilioOptOutType = {}));
+/**
+ * Twilio's default opt-out keywords.
+ */ var DEFAULT_TWILIO_OPT_OUT_KEYWORDS = [
+    'STOP',
+    'STOPALL',
+    'UNSUBSCRIBE',
+    'CANCEL',
+    'END',
+    'QUIT',
+    'REVOKE',
+    'OPTOUT'
+];
+/**
+ * Twilio's default opt-in keywords.
+ */ var DEFAULT_TWILIO_OPT_IN_KEYWORDS = [
+    'START',
+    'YES',
+    'UNSTOP'
+];
+/**
+ * Twilio's default help keywords.
+ */ var DEFAULT_TWILIO_HELP_KEYWORDS = [
+    'HELP',
+    'INFO'
+];
+var DEFAULT_TWILIO_OPT_OUT_TYPE_BY_KEYWORD = new Map(_to_consumable_array$1(DEFAULT_TWILIO_OPT_OUT_KEYWORDS.map(function(x) {
+    return [
+        x,
+        TwilioOptOutType.STOP
+    ];
+})).concat(_to_consumable_array$1(DEFAULT_TWILIO_OPT_IN_KEYWORDS.map(function(x) {
+    return [
+        x,
+        TwilioOptOutType.START
+    ];
+})), _to_consumable_array$1(DEFAULT_TWILIO_HELP_KEYWORDS.map(function(x) {
+    return [
+        x,
+        TwilioOptOutType.HELP
+    ];
+}))));
+/**
+ * Reads a {@link TwilioOptOutType} from a string, case-insensitively.
+ *
+ * @param value - The value to read, such as Twilio's `OptOutType` parameter.
+ * @returns The opt-out type, or undefined when the value is not one.
+ */ function twilioOptOutTypeFromString(value) {
+    var normalized = value === null || value === void 0 ? void 0 : value.trim().toUpperCase();
+    var result;
+    switch(normalized){
+        case TwilioOptOutType.STOP:
+        case TwilioOptOutType.START:
+        case TwilioOptOutType.HELP:
+            result = normalized;
+            break;
+    }
+    return result;
+}
+/**
+ * Returns the opt-out keyword type of an incoming message, if it is one.
+ *
+ * Twilio's `OptOutType` parameter wins when present. It is only sent for messages to a Messaging Service, or to a number with
+ * Advanced Opt-Out. Otherwise the body is matched, trimmed and case-insensitively, against Twilio's default keywords. Only a whole-body
+ * match counts, so "Stop please" is not a keyword, matching how Twilio itself handles keywords.
+ *
+ * @param payload - The incoming message.
+ * @param config - Whether to skip the default keyword fallback.
+ * @returns The opt-out type, or undefined when the message is not a keyword.
+ */ function twilioIncomingMessageOptOutType(payload, config) {
+    var result = payload.OptOutType;
+    if (result == null && !(config === null || config === void 0 ? void 0 : config.optOutTypeOnly)) {
+        result = DEFAULT_TWILIO_OPT_OUT_TYPE_BY_KEYWORD.get(payload.Body.trim().toUpperCase());
+    }
+    return result;
+}
+
 function _class_call_check$3(instance, Constructor) {
     if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
 }
@@ -1415,7 +2401,6 @@ function _define_property$2(obj, key, value) {
     return obj;
 }
 var TWILIO_WEBHOOK_AUTH_TOKEN_ENV_VAR = 'TWILIO_WEBHOOK_AUTH_TOKEN';
-var TWILIO_WEBHOOK_BASE_URL_ENV_VAR = 'TWILIO_WEBHOOK_BASE_URL';
 var TWILIO_WEBHOOK_SKIP_VERIFY_ENV_VAR = 'TWILIO_WEBHOOK_SKIP_VERIFY';
 /**
  * Configuration for the Twilio webhook controller / service.
@@ -1642,21 +2627,20 @@ function _ts_generator$1(thisArg, body) {
     }
 }
 var TwilioWebhookService = /*#__PURE__*/ function() {
-    function TwilioWebhookService(twilioApi, webhookConfig) {
+    function TwilioWebhookService(webhookConfig) {
         _class_call_check$2(this, TwilioWebhookService);
-        var _webhookConfig_twilioWebhook_authToken;
         _define_property$1(this, "logger", new Logger('TwilioWebhookService'));
         _define_property$1(this, "_verifier", void 0);
         _define_property$1(this, "handler", twilioWebhookEventHandlerFactory());
         _define_property$1(this, "configure", twilioWebhookEventHandlerConfigurerFactory(this.handler));
-        var authToken = (_webhookConfig_twilioWebhook_authToken = webhookConfig.twilioWebhook.authToken) !== null && _webhookConfig_twilioWebhook_authToken !== void 0 ? _webhookConfig_twilioWebhook_authToken : twilioApi.config.twilio.authToken;
+        var _webhookConfig_twilioWebhook = webhookConfig.twilioWebhook, authToken = _webhookConfig_twilioWebhook.authToken, baseUrl = _webhookConfig_twilioWebhook.baseUrl, skipVerify = _webhookConfig_twilioWebhook.skipVerify;
         if (!authToken) {
             throw new Error('TwilioWebhookService: authToken is required (set TWILIO_AUTH_TOKEN or TWILIO_WEBHOOK_AUTH_TOKEN).');
         }
         this._verifier = twilioWebhookVerifier({
             authToken: authToken,
-            baseUrl: webhookConfig.twilioWebhook.baseUrl,
-            skip: webhookConfig.twilioWebhook.skipVerify
+            baseUrl: baseUrl,
+            skip: skipVerify
         });
     }
     _create_class$1(TwilioWebhookService, [
@@ -1745,6 +2729,8 @@ var TwilioWebhookService = /*#__PURE__*/ function() {
                                         FromState: params['FromState'],
                                         FromZip: params['FromZip'],
                                         FromCountry: params['FromCountry'],
+                                        MessagingServiceSid: params['MessagingServiceSid'],
+                                        OptOutType: twilioOptOutTypeFromString(params['OptOutType']),
                                         mediaUrls: mediaUrls,
                                         raw: params
                                     }
@@ -1801,8 +2787,7 @@ var TwilioWebhookService = /*#__PURE__*/ function() {
 }();
 TwilioWebhookService = __decorate([
     Injectable(),
-    __param(0, Inject(TwilioApi)),
-    __param(1, Inject(TwilioWebhookServiceConfig))
+    __param(0, Inject(TwilioWebhookServiceConfig))
 ], TwilioWebhookService);
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
@@ -2016,74 +3001,141 @@ var TwilioWebhookController = /*#__PURE__*/ function() {
     return TwilioWebhookController;
 }();
 __decorate([
-    Post('status'),
+    Post(TWILIO_WEBHOOK_STATUS_PATH),
     __param(0, Req()),
     __param(1, RawBody())
 ], TwilioWebhookController.prototype, "handleStatus", null);
 __decorate([
-    Post('incoming'),
+    Post(TWILIO_WEBHOOK_INCOMING_PATH),
     __param(0, Req()),
     __param(1, RawBody())
 ], TwilioWebhookController.prototype, "handleIncoming", null);
 TwilioWebhookController = __decorate([
-    Controller('/webhook/twilio'),
+    Controller("".concat(DEFAULT_BASE_WEBHOOK_PATH).concat(TWILIO_WEBHOOK_PATH)),
     __param(0, Inject(TwilioWebhookService))
 ], TwilioWebhookController);
 
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
 function _class_call_check(instance, Constructor) {
     if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
 }
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
 /**
  * Factory that creates a {@link TwilioWebhookServiceConfig} from environment variables.
  *
+ * The auth token is read from `TWILIO_WEBHOOK_AUTH_TOKEN`, falling back to `TWILIO_AUTH_TOKEN`. A real
+ * value is preferred over a placeholder one (see {@link isPlaceholderTwilioConfigValue}), so a placeholder
+ * webhook token does not shadow a real auth token. When both are placeholders the placeholder is kept,
+ * which lets the app start and rejects every request as unverified.
+ *
+ * Requests are verified against the app's public webhook URL when `webhookUrlsConfig` is set, and otherwise
+ * against the URL rebuilt from the request headers.
+ *
  * @param configService - NestJS config service for reading environment variables.
+ * @param webhookUrlsConfig - The app's public webhook URLs.
  * @returns A populated {@link TwilioWebhookServiceConfig}.
- */ function twilioWebhookServiceConfigFactory(configService) {
+ */ function twilioWebhookServiceConfigFactory(configService, webhookUrlsConfig) {
+    var _ref, _find;
+    var _webhookUrlsConfig_twilioWebhookUrls;
+    var webhookAuthToken = configService.get(TWILIO_WEBHOOK_AUTH_TOKEN_ENV_VAR);
+    var accountAuthToken = configService.get(TWILIO_AUTH_TOKEN_ENV_VAR);
+    var authToken = (_ref = (_find = [
+        webhookAuthToken,
+        accountAuthToken
+    ].find(function(x) {
+        return !isPlaceholderTwilioConfigValue(x);
+    })) !== null && _find !== void 0 ? _find : webhookAuthToken) !== null && _ref !== void 0 ? _ref : accountAuthToken;
     var config = {
         twilioWebhook: {
-            authToken: configService.get(TWILIO_WEBHOOK_AUTH_TOKEN_ENV_VAR),
-            baseUrl: configService.get(TWILIO_WEBHOOK_BASE_URL_ENV_VAR),
+            authToken: authToken,
+            baseUrl: webhookUrlsConfig === null || webhookUrlsConfig === void 0 ? void 0 : (_webhookUrlsConfig_twilioWebhookUrls = webhookUrlsConfig.twilioWebhookUrls) === null || _webhookUrlsConfig_twilioWebhookUrls === void 0 ? void 0 : _webhookUrlsConfig_twilioWebhookUrls.baseUrl,
             skipVerify: configService.get(TWILIO_WEBHOOK_SKIP_VERIFY_ENV_VAR) === 'true'
         }
     };
     return config;
 }
 /**
- * NestJS module that handles incoming Twilio webhook requests at:
+ * Convenience function used to generate ModuleMetadata for an app's Twilio webhook module, which handles
+ * incoming Twilio webhook requests at:
  *   - `POST /webhook/twilio/status` (Message status callbacks)
  *   - `POST /webhook/twilio/incoming` (Incoming SMS / MMS messages)
  *
- * Webhook bodies are verified against the X-Twilio-Signature header before dispatch.
+ * Webhook bodies are verified against the X-Twilio-Signature header before dispatch. Only the auth
+ * token is needed for that, so this module does not depend on the Twilio module and can be imported in
+ * environments without a usable Twilio sending config.
  *
  * Requires the consuming application to register the raw-body middleware from
  * `@dereekb/nestjs` for the `/webhook/twilio` path so that signature verification can read
  * the unparsed form body.
- */ var TwilioWebhookModule = function TwilioWebhookModule() {
-    _class_call_check(this, TwilioWebhookModule);
-};
-TwilioWebhookModule = __decorate([
-    Module({
+ *
+ * Register handlers by injecting the exported {@link TwilioWebhookService} into a provider passed in `providers`.
+ *
+ * @param config - The module metadata configuration including the optional dependency module.
+ * @returns NestJS ModuleMetadata for registering the Twilio webhook module.
+ */ function appTwilioWebhookModuleMetadata(config) {
+    var _ref = config !== null && config !== void 0 ? config : {}, dependencyModule = _ref.dependencyModule, imports = _ref.imports, exports = _ref.exports, providers = _ref.providers;
+    var dependencyModuleImport = dependencyModule ? [
+        dependencyModule
+    ] : [];
+    return {
         imports: [
-            ConfigModule,
-            TwilioModule
-        ],
+            ConfigModule
+        ].concat(_to_consumable_array(dependencyModuleImport), _to_consumable_array(imports !== null && imports !== void 0 ? imports : [])),
         controllers: [
             TwilioWebhookController
         ],
+        exports: [
+            TwilioWebhookService
+        ].concat(_to_consumable_array(exports !== null && exports !== void 0 ? exports : [])),
         providers: [
             {
                 provide: TwilioWebhookServiceConfig,
                 inject: [
-                    ConfigService
+                    ConfigService,
+                    {
+                        token: TwilioWebhookUrlsConfig,
+                        optional: true
+                    }
                 ],
                 useFactory: twilioWebhookServiceConfigFactory
             },
             TwilioWebhookService
-        ],
-        exports: [
-            TwilioWebhookService
-        ]
-    })
+        ].concat(_to_consumable_array(providers !== null && providers !== void 0 ? providers : []))
+    };
+}
+/**
+ * NestJS module that handles incoming Twilio webhook requests at `/webhook/twilio`. See
+ * {@link appTwilioWebhookModuleMetadata}, which also lets the app supply its public webhook URLs.
+ */ var TwilioWebhookModule = function TwilioWebhookModule() {
+    _class_call_check(this, TwilioWebhookModule);
+};
+TwilioWebhookModule = __decorate([
+    Module(appTwilioWebhookModuleMetadata())
 ], TwilioWebhookModule);
 
-export { DEFAULT_TWILIO_SEND_SMS_MAX_PARALLEL_TASKS, TWILIO_ACCOUNT_SID_ENV_VAR, TWILIO_API_KEY_SECRET_ENV_VAR, TWILIO_API_KEY_SID_ENV_VAR, TWILIO_AUTH_TOKEN_ENV_VAR, TWILIO_MESSAGING_SERVICE_SID_ENV_VAR, TWILIO_PHONE_NUMBER_ENV_VAR, TWILIO_SANDBOX_ENV_VAR, TWILIO_STATUS_CALLBACK_URL_ENV_VAR, TWILIO_VERIFY_SERVICE_SID_ENV_VAR, TWILIO_WEBHOOK_AUTH_TOKEN_ENV_VAR, TWILIO_WEBHOOK_BASE_URL_ENV_VAR, TWILIO_WEBHOOK_SKIP_VERIFY_ENV_VAR, TwilioApi, TwilioLookupApi, TwilioLookupModule, TwilioLookupService, TwilioModule, TwilioService, TwilioServiceConfig, TwilioVerifyApi, TwilioVerifyModule, TwilioVerifyService, TwilioVerifyServiceConfig, TwilioWebhookController, TwilioWebhookModule, TwilioWebhookService, TwilioWebhookServiceConfig, parseTwilioFormBody, twilioServiceConfigFactory, twilioVerifyServiceConfigFactory, twilioWebhookEventHandlerConfigurerFactory, twilioWebhookEventHandlerFactory, twilioWebhookRequestUrl, twilioWebhookServiceConfigFactory, twilioWebhookVerifier };
+export { DEFAULT_TWILIO_HELP_KEYWORDS, DEFAULT_TWILIO_OPT_IN_KEYWORDS, DEFAULT_TWILIO_OPT_OUT_KEYWORDS, DEFAULT_TWILIO_RECENT_MESSAGES_LIMIT, DEFAULT_TWILIO_RECENT_MESSAGES_WINDOW_DAYS, DEFAULT_TWILIO_SEND_SMS_MAX_PARALLEL_TASKS, TWILIO_ACCOUNT_SID_ENV_VAR, TWILIO_API_KEY_SECRET_ENV_VAR, TWILIO_API_KEY_SID_ENV_VAR, TWILIO_AUTH_TOKEN_ENV_VAR, TWILIO_MESSAGING_SERVICE_SID_ENV_VAR, TWILIO_PHONE_NUMBER_ENV_VAR, TWILIO_PLACEHOLDER_CONFIG_VALUES, TWILIO_SANDBOX_ENV_VAR, TWILIO_VERIFY_SERVICE_SID_ENV_VAR, TWILIO_WEBHOOK_AUTH_TOKEN_ENV_VAR, TWILIO_WEBHOOK_INCOMING_PATH, TWILIO_WEBHOOK_PATH, TWILIO_WEBHOOK_SKIP_VERIFY_ENV_VAR, TWILIO_WEBHOOK_STATUS_PATH, TwilioApi, TwilioLookupApi, TwilioLookupModule, TwilioLookupService, TwilioMessageErrorCode, TwilioModule, TwilioOptOutType, TwilioService, TwilioServiceConfig, TwilioVerifyApi, TwilioVerifyModule, TwilioVerifyService, TwilioVerifyServiceConfig, TwilioWebhookController, TwilioWebhookModule, TwilioWebhookService, TwilioWebhookServiceConfig, TwilioWebhookUrlsConfig, appTwilioLookupModuleMetadata, appTwilioModuleMetadata, appTwilioVerifyModuleMetadata, appTwilioWebhookModuleMetadata, isPlaceholderTwilioConfigValue, isTwilioDiagnosticPermissionError, isUsableTwilioServiceConfig, parseTwilioFormBody, twilioAccountState, twilioDiagnosticError, twilioDiagnosticMessage, twilioDiagnosticMessageDate, twilioErrorCode, twilioErrorStatus, twilioIncomingMessageOptOutType, twilioLookupPhoneNumberForDiagnosis, twilioMessageForSid, twilioOptOutTypeFromString, twilioRecentMessagesForRecipient, twilioServiceConfigFactory, twilioServiceConfigFromConfigService, twilioVerifyServiceConfigFactory, twilioWebhookEventHandlerConfigurerFactory, twilioWebhookEventHandlerFactory, twilioWebhookRequestUrl, twilioWebhookServiceConfigFactory, twilioWebhookUrls, twilioWebhookVerifier, usableTwilioServiceConfig };