@dereekb/nestjs 13.11.18 → 13.12.1

package/twilio/index.esm.js

@@ -0,0 +1,2159 @@
+import { Injectable, Inject, Logger, Module, Post, Req, Controller, ForbiddenException } from '@nestjs/common';
+import { Twilio, validateRequest } from 'twilio';
+import { performAsyncTasks, handlerFactory, handlerConfigurerFactory, handlerMappedSetFunctionFactory } from '@dereekb/util';
+import { ConfigService, ConfigModule } from '@nestjs/config';
+import { RawBody } from '@dereekb/nestjs';
+
+function _class_call_check$e(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+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 (staticProps) _defineProperties$8(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$b(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;
+}
+var TWILIO_ACCOUNT_SID_ENV_VAR = 'TWILIO_ACCOUNT_SID';
+var TWILIO_AUTH_TOKEN_ENV_VAR = 'TWILIO_AUTH_TOKEN';
+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);
+        /**
+     * Client credentials.
+     */ _define_property$b(this, "twilio", void 0);
+        /**
+     * Outbound message defaults.
+     */ _define_property$b(this, "messages", void 0);
+    }
+    _create_class$8(TwilioServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+                if (!config.twilio.accountSid) {
+                    throw new Error('TwilioServiceConfig: TWILIO_ACCOUNT_SID is required.');
+                }
+                var hasAuthToken = Boolean(config.twilio.authToken);
+                var hasApiKey = Boolean(config.twilio.apiKeySid) && Boolean(config.twilio.apiKeySecret);
+                if (!hasAuthToken && !hasApiKey) {
+                    throw new Error('TwilioServiceConfig: TWILIO_AUTH_TOKEN (or TWILIO_API_KEY_SID + TWILIO_API_KEY_SECRET) is required.');
+                }
+                if (!config.messages.defaultFrom && !config.messages.messagingServiceSid) {
+                    throw new Error('TwilioServiceConfig: TWILIO_PHONE_NUMBER or TWILIO_MESSAGING_SERVICE_SID is required.');
+                }
+            }
+        }
+    ]);
+    return TwilioServiceConfig;
+} 
+();
+
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ((typeof Reflect === "undefined" ? "undefined" : _type_of(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function _class_call_check$d(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;
+}
+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);
+    }
+    this.client = client;
+};
+TwilioApi = __decorate([
+    Injectable(),
+    __param(0, Inject(TwilioServiceConfig))
+], TwilioApi);
+
+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_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep$4(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$4(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$c(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$7(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$7(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$7(Constructor.prototype, protoProps);
+    return Constructor;
+}
+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 _instanceof$1(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 _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+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) {
+    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 _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();
+}
+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);
+}
+function _ts_generator$4(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
+        };
+    }
+}
+/**
+ * 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);
+        this._twilioApi = twilioApi;
+    }
+    _create_class$7(TwilioService, [
+        {
+            key: "twilioApi",
+            get: function get() {
+                return this._twilioApi;
+            }
+        },
+        {
+            key: "sendSms",
+            value: /**
+     * Sends a single SMS through Twilio. Honors the configured sandbox flag.
+     *
+     * @param input - Recipient, body, and optional sender/callback/media overrides.
+     * @returns The result of the send attempt, including the Twilio Message SID on success.
+     */ function sendSms(input) {
+                return _async_to_generator$4(function() {
+                    var messages, isSandbox, result, _ref, _input_from, _ref1, _input_messagingServiceSid, _ref2, _input_statusCallback, from, messagingServiceSid, statusCallback, _input_mediaUrl, message, e, errorMessage;
+                    return _ts_generator$4(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                messages = this._twilioApi.config.messages;
+                                isSandbox = messages.sandbox === true;
+                                if (!isSandbox) return [
+                                    3,
+                                    1
+                                ];
+                                result = {
+                                    sid: null,
+                                    to: input.to,
+                                    status: 'queued',
+                                    sandboxed: true
+                                };
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 1:
+                                from = (_ref = (_input_from = input.from) !== null && _input_from !== void 0 ? _input_from : messages.defaultFrom) !== null && _ref !== void 0 ? _ref : undefined;
+                                messagingServiceSid = (_ref1 = (_input_messagingServiceSid = input.messagingServiceSid) !== null && _input_messagingServiceSid !== void 0 ? _input_messagingServiceSid : messages.messagingServiceSid) !== null && _ref1 !== void 0 ? _ref1 : undefined;
+                                statusCallback = (_ref2 = (_input_statusCallback = input.statusCallback) !== null && _input_statusCallback !== void 0 ? _input_statusCallback : messages.defaultStatusCallback) !== null && _ref2 !== void 0 ? _ref2 : undefined;
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                return [
+                                    4,
+                                    this._twilioApi.client.messages.create(_object_spread$2({
+                                        to: input.to,
+                                        body: input.body
+                                    }, messagingServiceSid ? {
+                                        messagingServiceSid: messagingServiceSid
+                                    } : {
+                                        from: from
+                                    }, statusCallback ? {
+                                        statusCallback: statusCallback
+                                    } : {}, ((_input_mediaUrl = input.mediaUrl) === null || _input_mediaUrl === void 0 ? void 0 : _input_mediaUrl.length) ? {
+                                        mediaUrl: input.mediaUrl
+                                    } : {}))
+                                ];
+                            case 3:
+                                message = _state.sent();
+                                result = {
+                                    sid: message.sid,
+                                    to: input.to,
+                                    status: message.status,
+                                    sandboxed: false
+                                };
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
+                                e = _state.sent();
+                                errorMessage = _instanceof$1(e, Error) ? e.message : String(e);
+                                this.logger.error("Failed sending SMS to ".concat(input.to, ": ").concat(errorMessage));
+                                result = {
+                                    sid: null,
+                                    to: input.to,
+                                    status: 'failed',
+                                    sandboxed: false,
+                                    error: errorMessage
+                                };
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 5:
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "sendBulkSms",
+            value: /**
+     * Sends a batch of SMS messages through Twilio with bounded parallelism. Failures are
+     * captured per-message and never reject the returned promise.
+     *
+     * @param inputs - Array of SMS send inputs, one per recipient.
+     * @param maxParallelTasks - Maximum concurrent Twilio requests in flight.
+     * @returns One {@link TwilioSendSmsResult} per input, in input order.
+     */ function sendBulkSms(_0) {
+                return _async_to_generator$4(function(inputs) {
+                    var _this, maxParallelTasks, results;
+                    var _arguments = arguments;
+                    return _ts_generator$4(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this = this;
+                                maxParallelTasks = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : DEFAULT_TWILIO_SEND_SMS_MAX_PARALLEL_TASKS;
+                                return [
+                                    4,
+                                    performAsyncTasks(inputs, function(input) {
+                                        return _this.sendSms(input);
+                                    }, {
+                                        maxParallelTasks: maxParallelTasks,
+                                        throwError: false
+                                    })
+                                ];
+                            case 1:
+                                results = _state.sent().results;
+                                return [
+                                    2,
+                                    results.map(function(param) {
+                                        var _param = _sliced_to_array(param, 2), result = _param[1];
+                                        return result;
+                                    })
+                                ];
+                        }
+                    });
+                }).apply(this, arguments);
+            }
+        }
+    ]);
+    return TwilioService;
+}();
+TwilioService = __decorate([
+    Injectable(),
+    __param(0, Inject(TwilioApi))
+], TwilioService);
+
+function _class_call_check$b(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+/**
+ * Factory that creates a {@link TwilioServiceConfig} from environment variables.
+ *
+ * @param configService - NestJS config service for reading environment variables.
+ * @returns A validated {@link TwilioServiceConfig}.
+ */ function twilioServiceConfigFactory(configService) {
+    var config = {
+        twilio: {
+            accountSid: configService.get(TWILIO_ACCOUNT_SID_ENV_VAR),
+            authToken: configService.get(TWILIO_AUTH_TOKEN_ENV_VAR),
+            apiKeySid: configService.get(TWILIO_API_KEY_SID_ENV_VAR),
+            apiKeySecret: configService.get(TWILIO_API_KEY_SECRET_ENV_VAR)
+        },
+        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.
+ *
+ * Reads Twilio credentials and default sender configuration from environment variables.
+ */ var TwilioModule = function TwilioModule() {
+    _class_call_check$b(this, TwilioModule);
+};
+TwilioModule = __decorate([
+    Module({
+        imports: [
+            ConfigModule
+        ],
+        providers: [
+            {
+                provide: TwilioServiceConfig,
+                inject: [
+                    ConfigService
+                ],
+                useFactory: twilioServiceConfigFactory
+            },
+            TwilioApi,
+            TwilioService
+        ],
+        exports: [
+            TwilioApi,
+            TwilioService
+        ]
+    })
+], TwilioModule);
+
+function _class_call_check$a(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$6(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$6(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$6(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$8(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;
+}
+var TwilioLookupApi = /*#__PURE__*/ function() {
+    function TwilioLookupApi(twilioApi) {
+        _class_call_check$a(this, TwilioLookupApi);
+        _define_property$8(this, "_twilioApi", void 0);
+        this._twilioApi = twilioApi;
+    }
+    _create_class$6(TwilioLookupApi, [
+        {
+            key: "twilioApi",
+            get: function get() {
+                return this._twilioApi;
+            }
+        },
+        {
+            key: "phoneNumbers",
+            get: function get() {
+                return this._twilioApi.client.lookups.v2.phoneNumbers;
+            }
+        }
+    ]);
+    return TwilioLookupApi;
+}();
+TwilioLookupApi = __decorate([
+    Injectable(),
+    __param(0, Inject(TwilioApi))
+], TwilioLookupApi);
+
+function asyncGeneratorStep$3(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$3(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$9(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$5(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$5(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$5(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$7(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(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 _ts_generator$3(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
+        };
+    }
+}
+var TwilioLookupService = /*#__PURE__*/ function() {
+    function TwilioLookupService(twilioLookupApi) {
+        _class_call_check$9(this, TwilioLookupService);
+        _define_property$7(this, "logger", new Logger('TwilioLookupService'));
+        _define_property$7(this, "_twilioLookupApi", void 0);
+        this._twilioLookupApi = twilioLookupApi;
+    }
+    _create_class$5(TwilioLookupService, [
+        {
+            key: "twilioLookupApi",
+            get: function get() {
+                return this._twilioLookupApi;
+            }
+        },
+        {
+            key: "lookup",
+            value: /**
+     * Validates and normalizes a phone number via Twilio Lookup v2. Optionally returns carrier
+     * information when `includeCarrier` is set (additional Twilio charges apply).
+     *
+     * @param input - Phone number to look up plus optional carrier / country-code flags.
+     * @returns The lookup result, with `valid: false` when Twilio cannot resolve the number.
+     */ function lookup(input) {
+                return _async_to_generator$3(function() {
+                    var phoneNumberInstance, fetchInput, result, lookup, carrier, lti, e;
+                    return _ts_generator$3(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                phoneNumberInstance = this._twilioLookupApi.phoneNumbers(input.phoneNumber);
+                                fetchInput = {};
+                                if (input.includeCarrier) {
+                                    fetchInput.fields = 'line_type_intelligence';
+                                }
+                                if (input.countryCode) {
+                                    fetchInput.countryCode = input.countryCode;
+                                }
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    phoneNumberInstance.fetch(fetchInput)
+                                ];
+                            case 2:
+                                lookup = _state.sent();
+                                if (input.includeCarrier && lookup.lineTypeIntelligence) {
+                                    lti = lookup.lineTypeIntelligence;
+                                    carrier = {
+                                        carrierName: lti['carrier_name'],
+                                        type: lti['type'],
+                                        mobileCountryCode: lti['mobile_country_code'],
+                                        mobileNetworkCode: lti['mobile_network_code']
+                                    };
+                                }
+                                result = {
+                                    valid: Boolean(lookup.valid),
+                                    phoneNumber: lookup.phoneNumber,
+                                    countryCode: lookup.countryCode,
+                                    nationalFormat: lookup.nationalFormat,
+                                    carrier: carrier
+                                };
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                e = _state.sent();
+                                this.logger.warn("Failed to lookup phone number ".concat(input.phoneNumber, ": ").concat(_instanceof(e, Error) ? e.message : String(e)));
+                                result = {
+                                    valid: false,
+                                    phoneNumber: input.phoneNumber
+                                };
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 4:
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return TwilioLookupService;
+}();
+TwilioLookupService = __decorate([
+    Injectable(),
+    __param(0, Inject(TwilioLookupApi))
+], TwilioLookupService);
+
+function _class_call_check$8(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+/**
+ * NestJS module that exposes Twilio Lookup v2 (phone validation, carrier info).
+ *
+ * Imports {@link TwilioModule} for the underlying Twilio client.
+ */ var TwilioLookupModule = function TwilioLookupModule() {
+    _class_call_check$8(this, TwilioLookupModule);
+};
+TwilioLookupModule = __decorate([
+    Module({
+        imports: [
+            TwilioModule
+        ],
+        providers: [
+            TwilioLookupApi,
+            TwilioLookupService
+        ],
+        exports: [
+            TwilioLookupApi,
+            TwilioLookupService
+        ]
+    })
+], TwilioLookupModule);
+
+function _class_call_check$7(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$4(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$4(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties$4(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$6(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;
+}
+var TWILIO_VERIFY_SERVICE_SID_ENV_VAR = 'TWILIO_VERIFY_SERVICE_SID';
+/**
+ * Configuration for {@link TwilioVerifyApi} and {@link TwilioVerifyService}.
+ */ var TwilioVerifyServiceConfig = /*#__PURE__*/ function() {
+    function TwilioVerifyServiceConfig() {
+        _class_call_check$7(this, TwilioVerifyServiceConfig);
+        _define_property$6(this, "twilioVerify", void 0);
+    }
+    _create_class$4(TwilioVerifyServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+                if (!config.twilioVerify.verifyServiceSid) {
+                    throw new Error('TwilioVerifyServiceConfig: TWILIO_VERIFY_SERVICE_SID is required.');
+                }
+            }
+        }
+    ]);
+    return TwilioVerifyServiceConfig;
+} 
+();
+
+function _class_call_check$6(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$3(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$3(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$3(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$5(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;
+}
+var TwilioVerifyApi = /*#__PURE__*/ function() {
+    function TwilioVerifyApi(twilioApi, config) {
+        _class_call_check$6(this, TwilioVerifyApi);
+        _define_property$5(this, "_twilioApi", void 0);
+        _define_property$5(this, "_config", void 0);
+        this._twilioApi = twilioApi;
+        this._config = config;
+    }
+    _create_class$3(TwilioVerifyApi, [
+        {
+            key: "twilioApi",
+            get: function get() {
+                return this._twilioApi;
+            }
+        },
+        {
+            key: "verifyService",
+            get: function get() {
+                return this._twilioApi.client.verify.v2.services(this._config.twilioVerify.verifyServiceSid);
+            }
+        },
+        {
+            key: "config",
+            get: function get() {
+                return this._config;
+            }
+        }
+    ]);
+    return TwilioVerifyApi;
+}();
+TwilioVerifyApi = __decorate([
+    Injectable(),
+    __param(0, Inject(TwilioApi)),
+    __param(1, Inject(TwilioVerifyServiceConfig))
+], TwilioVerifyApi);
+
+function asyncGeneratorStep$2(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$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$5(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$2(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$2(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$2(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$4(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 _object_spread$1(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$4(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _ts_generator$2(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
+        };
+    }
+}
+var TwilioVerifyService = /*#__PURE__*/ function() {
+    function TwilioVerifyService(twilioVerifyApi) {
+        _class_call_check$5(this, TwilioVerifyService);
+        _define_property$4(this, "_twilioVerifyApi", void 0);
+        this._twilioVerifyApi = twilioVerifyApi;
+    }
+    _create_class$2(TwilioVerifyService, [
+        {
+            key: "twilioVerifyApi",
+            get: function get() {
+                return this._twilioVerifyApi;
+            }
+        },
+        {
+            key: "startVerification",
+            value: /**
+     * Starts a verification for the given recipient. Twilio generates and dispatches the code.
+     *
+     * @param input - Recipient, optional channel override, optional locale and customCode.
+     * @returns The Twilio verification record (status, channel, SID).
+     */ function startVerification(input) {
+                return _async_to_generator$2(function() {
+                    var _ref, _input_channel, channel, verification, result;
+                    return _ts_generator$2(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                channel = (_ref = (_input_channel = input.channel) !== null && _input_channel !== void 0 ? _input_channel : this._twilioVerifyApi.config.twilioVerify.defaultChannel) !== null && _ref !== void 0 ? _ref : 'sms';
+                                return [
+                                    4,
+                                    this._twilioVerifyApi.verifyService.verifications.create(_object_spread$1({
+                                        to: input.to,
+                                        channel: channel
+                                    }, input.locale ? {
+                                        locale: input.locale
+                                    } : {}, input.customCode ? {
+                                        customCode: input.customCode
+                                    } : {}))
+                                ];
+                            case 1:
+                                verification = _state.sent();
+                                result = {
+                                    sid: verification.sid,
+                                    to: verification.to,
+                                    channel: verification.channel,
+                                    status: verification.status,
+                                    valid: verification.valid
+                                };
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "checkVerification",
+            value: /**
+     * Checks a previously-issued verification code.
+     *
+     * Returns `valid: true` only when Twilio reports the verification as `approved`.
+     *
+     * @param input - Recipient address and the submitted code.
+     * @returns The verification-check result, with `valid` reflecting Twilio's `approved` status.
+     */ function checkVerification(input) {
+                return _async_to_generator$2(function() {
+                    var check, status, result;
+                    return _ts_generator$2(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this._twilioVerifyApi.verifyService.verificationChecks.create({
+                                        to: input.to,
+                                        code: input.code
+                                    })
+                                ];
+                            case 1:
+                                check = _state.sent();
+                                status = check.status;
+                                result = {
+                                    sid: check.sid,
+                                    to: check.to,
+                                    status: status,
+                                    valid: status === 'approved'
+                                };
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return TwilioVerifyService;
+}();
+TwilioVerifyService = __decorate([
+    Injectable(),
+    __param(0, Inject(TwilioVerifyApi))
+], TwilioVerifyService);
+
+function _class_call_check$4(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+/**
+ * Factory that creates a {@link TwilioVerifyServiceConfig} from environment variables.
+ *
+ * @param configService - NestJS config service for reading environment variables.
+ * @returns A validated {@link TwilioVerifyServiceConfig}.
+ */ function twilioVerifyServiceConfigFactory(configService) {
+    var config = {
+        twilioVerify: {
+            verifyServiceSid: configService.get(TWILIO_VERIFY_SERVICE_SID_ENV_VAR)
+        }
+    };
+    TwilioVerifyServiceConfig.assertValidConfig(config);
+    return config;
+}
+/**
+ * NestJS module that exposes Twilio Verify (OTP / 2FA) for starting verifications and
+ * checking submitted codes.
+ *
+ * Imports {@link TwilioModule} for the underlying Twilio client.
+ */ var TwilioVerifyModule = function TwilioVerifyModule() {
+    _class_call_check$4(this, TwilioVerifyModule);
+};
+TwilioVerifyModule = __decorate([
+    Module({
+        imports: [
+            ConfigModule,
+            TwilioModule
+        ],
+        providers: [
+            {
+                provide: TwilioVerifyServiceConfig,
+                inject: [
+                    ConfigService
+                ],
+                useFactory: twilioVerifyServiceConfigFactory
+            },
+            TwilioVerifyApi,
+            TwilioVerifyService
+        ],
+        exports: [
+            TwilioVerifyApi,
+            TwilioVerifyService
+        ]
+    })
+], TwilioVerifyModule);
+
+function _define_property$3(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 _object_spread(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$3(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(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(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+var twilioWebhookEventHandlerFactory = handlerFactory(function(x) {
+    return x.type;
+});
+var twilioWebhookEventHandlerConfigurerFactory = handlerConfigurerFactory({
+    configurerForAccessor: function configurerForAccessor(accessor) {
+        // The `any` generics mirror the loose typing used by `openai`/`stripe` webhook configurers:
+        // each `handle*` field is typed for a specific event subtype, but the underlying handler
+        // set is keyed on the union type. The `any` widens the input position so the assignments
+        // below type-check without per-field unsafe casts.
+        var fnWithKey = handlerMappedSetFunctionFactory(accessor, function(x) {
+            return x;
+        });
+        var configurer = _object_spread_props(_object_spread({}, accessor), {
+            handleStatusCallback: fnWithKey('status'),
+            handleIncomingMessage: fnWithKey('incoming')
+        });
+        return configurer;
+    }
+});
+
+function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property$2(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;
+}
+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.
+ */ var TwilioWebhookServiceConfig = function TwilioWebhookServiceConfig() {
+    _class_call_check$3(this, TwilioWebhookServiceConfig);
+    _define_property$2(this, "twilioWebhook", void 0);
+} 
+;
+
+/**
+ * Parses a `application/x-www-form-urlencoded` raw body into a plain `Record<string, string>`.
+ *
+ * Twilio's status callback and incoming-message webhooks use this content type by default.
+ *
+ * @param rawBody - The unparsed request body bytes.
+ * @returns Form parameters as a flat string-keyed object.
+ */ function parseTwilioFormBody(rawBody) {
+    var params = new URLSearchParams(rawBody.toString('utf8'));
+    var out = {};
+    params.forEach(function(value, key) {
+        out[key] = value;
+    });
+    return out;
+}
+/**
+ * Builds the full URL Twilio used when computing the request signature. Twilio computes
+ * the signature over the URL it called (including query string).
+ *
+ * @param req - Incoming Express request.
+ * @param baseUrl - Optional explicit base URL (used when the server sits behind a proxy
+ *   and the request's `Host` header does not match the public URL).
+ * @returns The full URL string Twilio would have signed.
+ */ function twilioWebhookRequestUrl(req, baseUrl) {
+    var url;
+    if (baseUrl) {
+        var _req_originalUrl;
+        var trimmed = baseUrl.replace(/\/$/, '');
+        url = "".concat(trimmed).concat((_req_originalUrl = req.originalUrl) !== null && _req_originalUrl !== void 0 ? _req_originalUrl : req.url);
+    } else {
+        var _req_headers_xforwardedproto, _req_headers_xforwardedhost, _req_originalUrl1;
+        var protocol = (_req_headers_xforwardedproto = req.headers['x-forwarded-proto']) !== null && _req_headers_xforwardedproto !== void 0 ? _req_headers_xforwardedproto : req.protocol;
+        var host = (_req_headers_xforwardedhost = req.headers['x-forwarded-host']) !== null && _req_headers_xforwardedhost !== void 0 ? _req_headers_xforwardedhost : req.get('host');
+        url = "".concat(protocol, "://").concat(host).concat((_req_originalUrl1 = req.originalUrl) !== null && _req_originalUrl1 !== void 0 ? _req_originalUrl1 : req.url);
+    }
+    return url;
+}
+/**
+ * Creates a verifier that validates the `X-Twilio-Signature` header against the request body
+ * using Twilio's HMAC-SHA1 signature scheme.
+ *
+ * @param config - Verification config (auth token, optional baseUrl, optional skip flag).
+ * @returns A verifier function that, given a request and raw body, returns the validity
+ *   and parsed form params.
+ */ function twilioWebhookVerifier(config) {
+    return function(req, rawBody) {
+        var params = parseTwilioFormBody(rawBody);
+        var valid;
+        if (config.skip === true) {
+            valid = true;
+        } else {
+            var _req_headers_xtwiliosignature;
+            var signature = (_req_headers_xtwiliosignature = req.headers['x-twilio-signature']) !== null && _req_headers_xtwiliosignature !== void 0 ? _req_headers_xtwiliosignature : '';
+            var url = twilioWebhookRequestUrl(req, config.baseUrl);
+            valid = validateRequest(config.authToken, signature, url, params);
+        }
+        var result = {
+            valid: valid,
+            params: params
+        };
+        return result;
+    };
+}
+
+function asyncGeneratorStep$1(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$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$1(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$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$1(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 _ts_generator$1(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
+        };
+    }
+}
+var TwilioWebhookService = /*#__PURE__*/ function() {
+    function TwilioWebhookService(twilioApi, 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;
+        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
+        });
+    }
+    _create_class$1(TwilioWebhookService, [
+        {
+            key: "handleStatusCallback",
+            value: function handleStatusCallback(req, rawBody) {
+                return _async_to_generator$1(function() {
+                    var _this__verifier, valid, params, _params_AccountSid, event;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this__verifier = this._verifier(req, rawBody), valid = _this__verifier.valid, params = _this__verifier.params;
+                                if (!!valid) return [
+                                    3,
+                                    1
+                                ];
+                                this.logger.warn('Received Twilio status callback with invalid signature.');
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 1:
+                                event = {
+                                    type: 'status',
+                                    payload: {
+                                        MessageSid: params['MessageSid'],
+                                        MessageStatus: params['MessageStatus'],
+                                        AccountSid: (_params_AccountSid = params['AccountSid']) !== null && _params_AccountSid !== void 0 ? _params_AccountSid : '',
+                                        From: params['From'],
+                                        To: params['To'],
+                                        ApiVersion: params['ApiVersion'],
+                                        ErrorCode: params['ErrorCode'],
+                                        ErrorMessage: params['ErrorMessage'],
+                                        raw: params
+                                    }
+                                };
+                                return [
+                                    4,
+                                    this.dispatchEvent(event)
+                                ];
+                            case 2:
+                                _state.sent();
+                                _state.label = 3;
+                            case 3:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "handleIncomingMessage",
+            value: function handleIncomingMessage(req, rawBody) {
+                return _async_to_generator$1(function() {
+                    var _this__verifier, valid, params, _params_NumMedia, _params_AccountSid, _params_Body, numMedia, numSegments, mediaUrls, i, url, event;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this__verifier = this._verifier(req, rawBody), valid = _this__verifier.valid, params = _this__verifier.params;
+                                if (!!valid) return [
+                                    3,
+                                    1
+                                ];
+                                this.logger.warn('Received Twilio incoming message with invalid signature.');
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 1:
+                                numMedia = Number((_params_NumMedia = params['NumMedia']) !== null && _params_NumMedia !== void 0 ? _params_NumMedia : '0');
+                                numSegments = params['NumSegments'] !== undefined ? Number(params['NumSegments']) : undefined;
+                                mediaUrls = [];
+                                for(i = 0; i < numMedia; i++){
+                                    url = params["MediaUrl".concat(i)];
+                                    if (url) {
+                                        mediaUrls.push(url);
+                                    }
+                                }
+                                event = {
+                                    type: 'incoming',
+                                    payload: {
+                                        MessageSid: params['MessageSid'],
+                                        AccountSid: (_params_AccountSid = params['AccountSid']) !== null && _params_AccountSid !== void 0 ? _params_AccountSid : '',
+                                        From: params['From'],
+                                        To: params['To'],
+                                        Body: (_params_Body = params['Body']) !== null && _params_Body !== void 0 ? _params_Body : '',
+                                        NumMedia: numMedia,
+                                        NumSegments: numSegments,
+                                        FromCity: params['FromCity'],
+                                        FromState: params['FromState'],
+                                        FromZip: params['FromZip'],
+                                        FromCountry: params['FromCountry'],
+                                        mediaUrls: mediaUrls,
+                                        raw: params
+                                    }
+                                };
+                                return [
+                                    4,
+                                    this.dispatchEvent(event)
+                                ];
+                            case 2:
+                                _state.sent();
+                                _state.label = 3;
+                            case 3:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "dispatchEvent",
+            value: function dispatchEvent(event) {
+                return _async_to_generator$1(function() {
+                    var handled;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.handler(event)
+                                ];
+                            case 1:
+                                handled = _state.sent();
+                                if (!handled) {
+                                    this.logger.debug('Received unhandled Twilio webhook event of type "'.concat(event.type, '".'));
+                                }
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return TwilioWebhookService;
+}();
+TwilioWebhookService = __decorate([
+    Injectable(),
+    __param(0, Inject(TwilioApi)),
+    __param(1, Inject(TwilioWebhookServiceConfig))
+], TwilioWebhookService);
+
+function asyncGeneratorStep(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(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(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(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property(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 _ts_generator(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
+        };
+    }
+}
+var TwilioWebhookController = /*#__PURE__*/ function() {
+    function TwilioWebhookController(twilioWebhookService) {
+        _class_call_check$1(this, TwilioWebhookController);
+        _define_property(this, "_twilioWebhookService", void 0);
+        this._twilioWebhookService = twilioWebhookService;
+    }
+    _create_class(TwilioWebhookController, [
+        {
+            key: "handleStatus",
+            value: function handleStatus(req, rawBody) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!rawBody) {
+                                    throw new ForbiddenException('Missing request body.');
+                                }
+                                return [
+                                    4,
+                                    this._twilioWebhookService.handleStatusCallback(req, rawBody)
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "handleIncoming",
+            value: function handleIncoming(req, rawBody) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!rawBody) {
+                                    throw new ForbiddenException('Missing request body.');
+                                }
+                                return [
+                                    4,
+                                    this._twilioWebhookService.handleIncomingMessage(req, rawBody)
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return TwilioWebhookController;
+}();
+__decorate([
+    Post('status'),
+    __param(0, Req()),
+    __param(1, RawBody())
+], TwilioWebhookController.prototype, "handleStatus", null);
+__decorate([
+    Post('incoming'),
+    __param(0, Req()),
+    __param(1, RawBody())
+], TwilioWebhookController.prototype, "handleIncoming", null);
+TwilioWebhookController = __decorate([
+    Controller('/webhook/twilio'),
+    __param(0, Inject(TwilioWebhookService))
+], TwilioWebhookController);
+
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+/**
+ * Factory that creates a {@link TwilioWebhookServiceConfig} from environment variables.
+ *
+ * @param configService - NestJS config service for reading environment variables.
+ * @returns A populated {@link TwilioWebhookServiceConfig}.
+ */ function twilioWebhookServiceConfigFactory(configService) {
+    var config = {
+        twilioWebhook: {
+            authToken: configService.get(TWILIO_WEBHOOK_AUTH_TOKEN_ENV_VAR),
+            baseUrl: configService.get(TWILIO_WEBHOOK_BASE_URL_ENV_VAR),
+            skipVerify: configService.get(TWILIO_WEBHOOK_SKIP_VERIFY_ENV_VAR) === 'true'
+        }
+    };
+    return config;
+}
+/**
+ * NestJS module that 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.
+ *
+ * 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({
+        imports: [
+            ConfigModule,
+            TwilioModule
+        ],
+        controllers: [
+            TwilioWebhookController
+        ],
+        providers: [
+            {
+                provide: TwilioWebhookServiceConfig,
+                inject: [
+                    ConfigService
+                ],
+                useFactory: twilioWebhookServiceConfigFactory
+            },
+            TwilioWebhookService
+        ],
+        exports: [
+            TwilioWebhookService
+        ]
+    })
+], 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 };