@dereekb/nestjs 13.11.18 → 13.12.1

package/twilio/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@dereekb/nestjs/twilio",
+  "version": "13.12.1",
+  "peerDependencies": {
+    "@dereekb/date": "13.12.1",
+    "@dereekb/model": "13.12.1",
+    "@dereekb/nestjs": "13.12.1",
+    "@dereekb/rxjs": "13.12.1",
+    "@dereekb/util": "13.12.1",
+    "@nestjs/common": "^11.1.19",
+    "@nestjs/config": "^4.0.4",
+    "express": "^5.2.1",
+    "twilio": "^6.0.2"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "types": "./index.d.ts",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    }
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "types": "./index.d.ts"
+}

package/twilio/src/index.d.ts

@@ -0,0 +1 @@
+export * from './lib';

package/twilio/src/lib/index.d.ts

@@ -0,0 +1,8 @@
+export * from './twilio.type';
+export * from './twilio.config';
+export * from './twilio.api';
+export * from './twilio.service';
+export * from './twilio.module';
+export * from './lookup';
+export * from './verify';
+export * from './webhook';

package/twilio/src/lib/lookup/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lookup.type';
+export * from './lookup.api';
+export * from './lookup.service';
+export * from './lookup.module';

package/twilio/src/lib/lookup/lookup.api.d.ts

@@ -0,0 +1,7 @@
+import { TwilioApi } from '../twilio.api';
+export declare class TwilioLookupApi {
+    private readonly _twilioApi;
+    constructor(twilioApi: TwilioApi);
+    get twilioApi(): TwilioApi;
+    get phoneNumbers(): import("twilio/lib/rest/lookups/v2/phoneNumber").PhoneNumberListInstance;
+}

package/twilio/src/lib/lookup/lookup.module.d.ts

@@ -0,0 +1,7 @@
+/**
+ * NestJS module that exposes Twilio Lookup v2 (phone validation, carrier info).
+ *
+ * Imports {@link TwilioModule} for the underlying Twilio client.
+ */
+export declare class TwilioLookupModule {
+}

package/twilio/src/lib/lookup/lookup.service.d.ts

@@ -0,0 +1,39 @@
+import { type Maybe } from '@dereekb/util';
+import { TwilioLookupApi } from './lookup.api';
+import { type TwilioLookupResult } from './lookup.type';
+export interface TwilioLookupInput {
+    /**
+     * Phone number to look up. Can be in any format Twilio accepts.
+     */
+    readonly phoneNumber: string;
+    /**
+     * When true, requests the `line_type_intelligence` data set so that carrier info is included
+     * in the result. NOTE: Twilio charges per-lookup for this data set; do not enable in hot paths
+     * without an explicit need.
+     */
+    readonly includeCarrier?: Maybe<boolean>;
+    /**
+     * ISO 3166-1 alpha-2 country code Twilio uses when interpreting nationally-formatted numbers.
+     */
+    readonly countryCode?: Maybe<string>;
+}
+export declare class TwilioLookupService {
+    private readonly logger;
+    private readonly _twilioLookupApi;
+    constructor(twilioLookupApi: TwilioLookupApi);
+    get twilioLookupApi(): TwilioLookupApi;
+    /**
+     * 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.
+     */
+    lookup(input: TwilioLookupInput): Promise<TwilioLookupResult>;
+}
+/**
+ * Provides a reference to a TwilioLookupService instance.
+ */
+export interface TwilioLookupServiceRef {
+    readonly twilioLookupService: TwilioLookupService;
+}

package/twilio/src/lib/lookup/lookup.type.d.ts

@@ -0,0 +1,37 @@
+import { type Maybe } from '@dereekb/util';
+import { type TwilioPhoneNumber } from '../twilio.type';
+/**
+ * Carrier information returned by the Twilio Lookup v2 API when the `line_type_intelligence`
+ * data set is requested.
+ */
+export interface TwilioLookupCarrierInfo {
+    readonly carrierName?: Maybe<string>;
+    readonly type?: Maybe<string>;
+    readonly mobileCountryCode?: Maybe<string>;
+    readonly mobileNetworkCode?: Maybe<string>;
+}
+/**
+ * Result of a Twilio Lookup v2 phone-number lookup.
+ */
+export interface TwilioLookupResult {
+    /**
+     * Whether Twilio could resolve the number to a valid phone number.
+     */
+    readonly valid: boolean;
+    /**
+     * The phone number in E.164 format, as normalized by Twilio.
+     */
+    readonly phoneNumber: TwilioPhoneNumber;
+    /**
+     * ISO country code (alpha-2) for the phone number.
+     */
+    readonly countryCode?: Maybe<string>;
+    /**
+     * National-format representation of the number.
+     */
+    readonly nationalFormat?: Maybe<string>;
+    /**
+     * Carrier information, populated only when `includeCarrier` was set on the lookup request.
+     */
+    readonly carrier?: Maybe<TwilioLookupCarrierInfo>;
+}

package/twilio/src/lib/twilio.api.d.ts

@@ -0,0 +1,13 @@
+import { Twilio } from 'twilio';
+import { TwilioServiceConfig } from './twilio.config';
+export declare class TwilioApi {
+    readonly config: TwilioServiceConfig;
+    readonly client: Twilio;
+    constructor(config: TwilioServiceConfig);
+}
+/**
+ * Provides a reference to a TwilioApi instance.
+ */
+export interface TwilioApiRef {
+    readonly twilioApi: TwilioApi;
+}

package/twilio/src/lib/twilio.config.d.ts

@@ -0,0 +1,71 @@
+import { type Maybe } from '@dereekb/util';
+import { type TwilioAccountSid, type TwilioApiKeySecret, type TwilioApiKeySid, type TwilioAuthToken, type TwilioMessagingServiceSid, type TwilioPhoneNumber, type TwilioStatusCallbackUrl } from './twilio.type';
+export declare const TWILIO_ACCOUNT_SID_ENV_VAR = "TWILIO_ACCOUNT_SID";
+export declare const TWILIO_AUTH_TOKEN_ENV_VAR = "TWILIO_AUTH_TOKEN";
+export declare const TWILIO_API_KEY_SID_ENV_VAR = "TWILIO_API_KEY_SID";
+export declare const TWILIO_API_KEY_SECRET_ENV_VAR = "TWILIO_API_KEY_SECRET";
+export declare const TWILIO_PHONE_NUMBER_ENV_VAR = "TWILIO_PHONE_NUMBER";
+export declare const TWILIO_MESSAGING_SERVICE_SID_ENV_VAR = "TWILIO_MESSAGING_SERVICE_SID";
+export declare const TWILIO_STATUS_CALLBACK_URL_ENV_VAR = "TWILIO_STATUS_CALLBACK_URL";
+export declare const TWILIO_SANDBOX_ENV_VAR = "TWILIO_SANDBOX";
+/**
+ * Twilio client credentials. Either {@link authToken} or the {@link apiKeySid}/{@link apiKeySecret}
+ * pair is required.
+ */
+export interface TwilioCredentials {
+    /**
+     * Twilio Account SID. Required.
+     */
+    readonly accountSid: TwilioAccountSid;
+    /**
+     * Twilio Auth Token. Required unless an API key SID + secret is provided.
+     */
+    readonly authToken?: Maybe<TwilioAuthToken>;
+    /**
+     * Twilio API Key SID. When provided together with `apiKeySecret`, this is used in place of the
+     * raw auth token when authenticating SDK requests.
+     */
+    readonly apiKeySid?: Maybe<TwilioApiKeySid>;
+    /**
+     * Secret value paired with `apiKeySid`.
+     */
+    readonly apiKeySecret?: Maybe<TwilioApiKeySecret>;
+}
+/**
+ * Default values for outbound message sends.
+ */
+export interface TwilioMessagesConfig {
+    /**
+     * Default sender phone number (E.164). Optional if `messagingServiceSid` is provided.
+     */
+    readonly defaultFrom?: Maybe<TwilioPhoneNumber>;
+    /**
+     * Default Twilio Messaging Service SID. When set, Twilio chooses the sender from the
+     * messaging service's number pool.
+     */
+    readonly messagingServiceSid?: Maybe<TwilioMessagingServiceSid>;
+    /**
+     * Default status callback URL applied to outbound messages when the caller does not
+     * supply one explicitly.
+     */
+    readonly defaultStatusCallback?: Maybe<TwilioStatusCallbackUrl>;
+    /**
+     * When true, suppresses real SDK calls and returns a synthetic result. Mirrors the
+     * mailgun sandbox flag for local development and testing.
+     */
+    readonly sandbox?: Maybe<boolean>;
+}
+/**
+ * Configuration for {@link TwilioApi} and {@link TwilioService}.
+ */
+export declare abstract class TwilioServiceConfig {
+    /**
+     * Client credentials.
+     */
+    readonly twilio: TwilioCredentials;
+    /**
+     * Outbound message defaults.
+     */
+    readonly messages: TwilioMessagesConfig;
+    static assertValidConfig(config: TwilioServiceConfig): void;
+}

package/twilio/src/lib/twilio.module.d.ts

@@ -0,0 +1,17 @@
+import { ConfigService } from '@nestjs/config';
+import { TwilioServiceConfig } from './twilio.config';
+/**
+ * Factory that creates a {@link TwilioServiceConfig} from environment variables.
+ *
+ * @param configService - NestJS config service for reading environment variables.
+ * @returns A validated {@link TwilioServiceConfig}.
+ */
+export declare function twilioServiceConfigFactory(configService: ConfigService): TwilioServiceConfig;
+/**
+ * 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.
+ */
+export declare class TwilioModule {
+}

package/twilio/src/lib/twilio.service.d.ts

@@ -0,0 +1,91 @@
+import { type Maybe } from '@dereekb/util';
+import { TwilioApi } from './twilio.api';
+import { type TwilioMessageSid, type TwilioMessageStatus, type TwilioMessagingServiceSid, type TwilioPhoneNumber, type TwilioStatusCallbackUrl } from './twilio.type';
+/**
+ * Maximum number of concurrent SMS send requests issued by {@link TwilioService.sendBulkSms}.
+ */
+export declare const DEFAULT_TWILIO_SEND_SMS_MAX_PARALLEL_TASKS = 5;
+/**
+ * Input for sending a single SMS message via Twilio.
+ */
+export interface TwilioSendSmsInput {
+    /**
+     * Recipient phone number in E.164 format.
+     */
+    readonly to: TwilioPhoneNumber;
+    /**
+     * Message body. Twilio segments any body longer than 160 GSM-7 chars (or 70 UCS-2 chars).
+     */
+    readonly body: string;
+    /**
+     * Sender phone number (E.164). Overrides the configured default. Ignored when
+     * `messagingServiceSid` is provided.
+     */
+    readonly from?: Maybe<TwilioPhoneNumber>;
+    /**
+     * Twilio Messaging Service SID to send from. Overrides the configured default and
+     * takes precedence over `from`.
+     */
+    readonly messagingServiceSid?: Maybe<TwilioMessagingServiceSid>;
+    /**
+     * Status callback URL. Overrides the configured default.
+     */
+    readonly statusCallback?: Maybe<TwilioStatusCallbackUrl>;
+    /**
+     * Optional URLs of media (MMS) to attach.
+     */
+    readonly mediaUrl?: Maybe<string[]>;
+}
+/**
+ * Result of a single SMS send attempt.
+ */
+export interface TwilioSendSmsResult {
+    /**
+     * Twilio Message SID assigned by the API. `null` when the send was suppressed by sandbox mode.
+     */
+    readonly sid: Maybe<TwilioMessageSid>;
+    /**
+     * Recipient phone number this result corresponds to.
+     */
+    readonly to: TwilioPhoneNumber;
+    /**
+     * Twilio-reported status at the time of the API response.
+     */
+    readonly status: TwilioMessageStatus;
+    /**
+     * When true, the message was suppressed by sandbox mode and never sent to Twilio.
+     */
+    readonly sandboxed: boolean;
+    /**
+     * Error message captured if the send failed.
+     */
+    readonly error?: Maybe<string>;
+}
+export declare class TwilioService {
+    private readonly logger;
+    private readonly _twilioApi;
+    constructor(twilioApi: TwilioApi);
+    get twilioApi(): TwilioApi;
+    /**
+     * 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.
+     */
+    sendSms(input: TwilioSendSmsInput): Promise<TwilioSendSmsResult>;
+    /**
+     * 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.
+     */
+    sendBulkSms(inputs: TwilioSendSmsInput[], maxParallelTasks?: number): Promise<TwilioSendSmsResult[]>;
+}
+/**
+ * Provides a reference to a TwilioService instance.
+ */
+export interface TwilioServiceRef {
+    readonly twilioService: TwilioService;
+}

package/twilio/src/lib/twilio.type.d.ts

@@ -0,0 +1,53 @@
+import { type E164PhoneNumber } from '@dereekb/util';
+/**
+ * Twilio Account SID (starts with `AC`).
+ */
+export type TwilioAccountSid = string;
+/**
+ * Twilio Auth Token used for API authentication.
+ */
+export type TwilioAuthToken = string;
+/**
+ * Twilio API Key SID (starts with `SK`). Optional alternative to using the auth token directly.
+ */
+export type TwilioApiKeySid = string;
+/**
+ * Secret value paired with a TwilioApiKeySid.
+ */
+export type TwilioApiKeySecret = string;
+/**
+ * Twilio Messaging Service SID (starts with `MG`).
+ */
+export type TwilioMessagingServiceSid = string;
+/**
+ * Twilio Verify Service SID (starts with `VA`).
+ */
+export type TwilioVerifyServiceSid = string;
+/**
+ * Twilio Message SID (starts with `SM` or `MM`).
+ */
+export type TwilioMessageSid = string;
+/**
+ * URL of a Twilio status callback endpoint.
+ */
+export type TwilioStatusCallbackUrl = string;
+/**
+ * Phone number in E.164 format used as either a sender or recipient.
+ */
+export type TwilioPhoneNumber = E164PhoneNumber;
+/**
+ * Status values reported by Twilio for a Message resource.
+ *
+ * https://www.twilio.com/docs/sms/api/message-resource#message-status-values
+ */
+export type TwilioMessageStatus = 'accepted' | 'queued' | 'sending' | 'sent' | 'receiving' | 'received' | 'delivered' | 'undelivered' | 'failed' | 'read' | 'canceled' | 'scheduled' | 'partially_delivered';
+/**
+ * Status values reported by Twilio Verify for a verification attempt.
+ *
+ * https://www.twilio.com/docs/verify/api/verification#verification-properties
+ */
+export type TwilioVerificationStatus = 'pending' | 'approved' | 'canceled' | 'max_attempts_reached' | 'deleted' | 'failed' | 'expired';
+/**
+ * Channel a Twilio Verify verification is delivered through.
+ */
+export type TwilioVerifyChannel = 'sms' | 'call' | 'email' | 'whatsapp';

package/twilio/src/lib/verify/index.d.ts

@@ -0,0 +1,4 @@
+export * from './verify.config';
+export * from './verify.api';
+export * from './verify.service';
+export * from './verify.module';

package/twilio/src/lib/verify/verify.api.d.ts

@@ -0,0 +1,10 @@
+import { TwilioApi } from '../twilio.api';
+import { TwilioVerifyServiceConfig } from './verify.config';
+export declare class TwilioVerifyApi {
+    private readonly _twilioApi;
+    private readonly _config;
+    constructor(twilioApi: TwilioApi, config: TwilioVerifyServiceConfig);
+    get twilioApi(): TwilioApi;
+    get verifyService(): import("twilio/lib/rest/verify/v2/service").ServiceContext;
+    get config(): TwilioVerifyServiceConfig;
+}

package/twilio/src/lib/verify/verify.config.d.ts

@@ -0,0 +1,22 @@
+import { type Maybe } from '@dereekb/util';
+import { type TwilioVerifyServiceSid } from '../twilio.type';
+export declare const TWILIO_VERIFY_SERVICE_SID_ENV_VAR = "TWILIO_VERIFY_SERVICE_SID";
+export interface TwilioVerifyConfig {
+    /**
+     * Twilio Verify Service SID. Required.
+     */
+    readonly verifyServiceSid: TwilioVerifyServiceSid;
+    /**
+     * Default channel used when starting a verification.
+     *
+     * Defaults to `'sms'`.
+     */
+    readonly defaultChannel?: Maybe<'sms' | 'call' | 'email' | 'whatsapp'>;
+}
+/**
+ * Configuration for {@link TwilioVerifyApi} and {@link TwilioVerifyService}.
+ */
+export declare abstract class TwilioVerifyServiceConfig {
+    readonly twilioVerify: TwilioVerifyConfig;
+    static assertValidConfig(config: TwilioVerifyServiceConfig): void;
+}

package/twilio/src/lib/verify/verify.module.d.ts

@@ -0,0 +1,17 @@
+import { ConfigService } from '@nestjs/config';
+import { TwilioVerifyServiceConfig } from './verify.config';
+/**
+ * Factory that creates a {@link TwilioVerifyServiceConfig} from environment variables.
+ *
+ * @param configService - NestJS config service for reading environment variables.
+ * @returns A validated {@link TwilioVerifyServiceConfig}.
+ */
+export declare function twilioVerifyServiceConfigFactory(configService: ConfigService): TwilioVerifyServiceConfig;
+/**
+ * NestJS module that exposes Twilio Verify (OTP / 2FA) for starting verifications and
+ * checking submitted codes.
+ *
+ * Imports {@link TwilioModule} for the underlying Twilio client.
+ */
+export declare class TwilioVerifyModule {
+}

package/twilio/src/lib/verify/verify.service.d.ts

@@ -0,0 +1,83 @@
+import { type Maybe } from '@dereekb/util';
+import { type TwilioPhoneNumber, type TwilioVerificationStatus, type TwilioVerifyChannel } from '../twilio.type';
+import { TwilioVerifyApi } from './verify.api';
+/**
+ * Input for starting a Twilio Verify check.
+ */
+export interface TwilioStartVerificationInput {
+    /**
+     * Recipient phone number / address (E.164 for SMS/call, email for email channel).
+     */
+    readonly to: string;
+    /**
+     * Delivery channel. Defaults to the configured default channel.
+     */
+    readonly channel?: Maybe<TwilioVerifyChannel>;
+    /**
+     * BCP-47 locale code for the verification message template (e.g. `en`, `es`).
+     */
+    readonly locale?: Maybe<string>;
+    /**
+     * Optional custom code (Twilio Verify Premium feature).
+     */
+    readonly customCode?: Maybe<string>;
+}
+/**
+ * Result of a started verification.
+ */
+export interface TwilioStartVerificationResult {
+    readonly sid: string;
+    readonly to: string;
+    readonly channel: TwilioVerifyChannel;
+    readonly status: TwilioVerificationStatus;
+    readonly valid: boolean;
+}
+/**
+ * Input for checking a verification code.
+ */
+export interface TwilioCheckVerificationInput {
+    /**
+     * The phone number / address the code was sent to.
+     */
+    readonly to: TwilioPhoneNumber | string;
+    /**
+     * The code supplied by the user.
+     */
+    readonly code: string;
+}
+/**
+ * Result of a verification check.
+ */
+export interface TwilioCheckVerificationResult {
+    readonly sid: string;
+    readonly to: string;
+    readonly status: TwilioVerificationStatus;
+    readonly valid: boolean;
+}
+export declare class TwilioVerifyService {
+    private readonly _twilioVerifyApi;
+    constructor(twilioVerifyApi: TwilioVerifyApi);
+    get twilioVerifyApi(): TwilioVerifyApi;
+    /**
+     * 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).
+     */
+    startVerification(input: TwilioStartVerificationInput): Promise<TwilioStartVerificationResult>;
+    /**
+     * 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.
+     */
+    checkVerification(input: TwilioCheckVerificationInput): Promise<TwilioCheckVerificationResult>;
+}
+/**
+ * Provides a reference to a TwilioVerifyService instance.
+ */
+export interface TwilioVerifyServiceRef {
+    readonly twilioVerifyService: TwilioVerifyService;
+}

package/twilio/src/lib/webhook/index.d.ts

@@ -0,0 +1,6 @@
+export * from './webhook.twilio';
+export * from './webhook.twilio.config';
+export * from './webhook.twilio.verify';
+export * from './webhook.twilio.service';
+export * from './webhook.twilio.controller';
+export * from './webhook.twilio.module';

package/twilio/src/lib/webhook/webhook.twilio.config.d.ts

@@ -0,0 +1,28 @@
+import { type Maybe } from '@dereekb/util';
+export declare const TWILIO_WEBHOOK_AUTH_TOKEN_ENV_VAR = "TWILIO_WEBHOOK_AUTH_TOKEN";
+export declare const TWILIO_WEBHOOK_BASE_URL_ENV_VAR = "TWILIO_WEBHOOK_BASE_URL";
+export declare const TWILIO_WEBHOOK_SKIP_VERIFY_ENV_VAR = "TWILIO_WEBHOOK_SKIP_VERIFY";
+export interface TwilioWebhookConfig {
+    /**
+     * Twilio Auth Token used to verify the X-Twilio-Signature header. When unset, the value
+     * configured on {@link TwilioServiceConfig} is used.
+     */
+    readonly authToken?: Maybe<string>;
+    /**
+     * Base URL of the deployed webhook (e.g. `https://api.example.com`). Twilio computes the
+     * request signature over the full URL it called, so behind a proxy the public URL must be
+     * supplied here for verification to succeed.
+     */
+    readonly baseUrl?: Maybe<string>;
+    /**
+     * When true, signature verification is skipped. Intended for local development against
+     * Twilio's test mode; never enable in production.
+     */
+    readonly skipVerify?: Maybe<boolean>;
+}
+/**
+ * Configuration for the Twilio webhook controller / service.
+ */
+export declare abstract class TwilioWebhookServiceConfig {
+    readonly twilioWebhook: TwilioWebhookConfig;
+}

package/twilio/src/lib/webhook/webhook.twilio.controller.d.ts

@@ -0,0 +1,9 @@
+import { type RawBodyBuffer } from '@dereekb/nestjs';
+import { type Request } from 'express';
+import { TwilioWebhookService } from './webhook.twilio.service';
+export declare class TwilioWebhookController {
+    private readonly _twilioWebhookService;
+    constructor(twilioWebhookService: TwilioWebhookService);
+    handleStatus(req: Request, rawBody: RawBodyBuffer): Promise<void>;
+    handleIncoming(req: Request, rawBody: RawBodyBuffer): Promise<void>;
+}

package/twilio/src/lib/webhook/webhook.twilio.d.ts

@@ -0,0 +1,68 @@
+import { type Maybe, type Handler, type HandlerBindAccessor, type HandlerMappedSetFunction } from '@dereekb/util';
+import { type TwilioAccountSid, type TwilioMessageSid, type TwilioMessageStatus, type TwilioPhoneNumber } from '../twilio.type';
+/**
+ * Twilio webhook event type.
+ */
+export type TwilioWebhookEventType = 'status' | 'incoming';
+/**
+ * Parameters delivered by Twilio for a Message status callback.
+ *
+ * https://www.twilio.com/docs/messaging/api/message-resource#message-status-callback-parameters
+ */
+export interface TwilioStatusCallbackPayload {
+    readonly MessageSid: TwilioMessageSid;
+    readonly MessageStatus: TwilioMessageStatus;
+    readonly AccountSid: TwilioAccountSid;
+    readonly From?: Maybe<TwilioPhoneNumber>;
+    readonly To?: Maybe<TwilioPhoneNumber>;
+    readonly ApiVersion?: Maybe<string>;
+    readonly ErrorCode?: Maybe<string>;
+    readonly ErrorMessage?: Maybe<string>;
+    /**
+     * The full set of fields Twilio sent, in case the consumer needs non-standard ones.
+     */
+    readonly raw: Readonly<Record<string, string>>;
+}
+/**
+ * Parameters delivered by Twilio for an incoming SMS / MMS.
+ *
+ * https://www.twilio.com/docs/messaging/guides/webhook-request#incoming-message-parameters
+ */
+export interface TwilioIncomingMessagePayload {
+    readonly MessageSid: TwilioMessageSid;
+    readonly AccountSid: TwilioAccountSid;
+    readonly From: TwilioPhoneNumber;
+    readonly To: TwilioPhoneNumber;
+    readonly Body: string;
+    readonly NumMedia: number;
+    readonly NumSegments?: Maybe<number>;
+    readonly FromCity?: Maybe<string>;
+    readonly FromState?: Maybe<string>;
+    readonly FromZip?: Maybe<string>;
+    readonly FromCountry?: Maybe<string>;
+    /**
+     * Resolved MediaUrl0..MediaUrlN entries, ordered by index. Empty array when no media.
+     */
+    readonly mediaUrls: readonly string[];
+    /**
+     * The full set of fields Twilio sent.
+     */
+    readonly raw: Readonly<Record<string, string>>;
+}
+export type TwilioStatusCallbackEvent = {
+    readonly type: 'status';
+    readonly payload: TwilioStatusCallbackPayload;
+};
+export type TwilioIncomingMessageEvent = {
+    readonly type: 'incoming';
+    readonly payload: TwilioIncomingMessagePayload;
+};
+export type TwilioWebhookEvent = TwilioStatusCallbackEvent | TwilioIncomingMessageEvent;
+export declare const twilioWebhookEventHandlerFactory: import("@dereekb/util").HandlerFactory<TwilioWebhookEvent, TwilioWebhookEventType, boolean>;
+export type TwilioHandlerMappedSetFunction<T extends TwilioWebhookEvent = TwilioWebhookEvent> = HandlerMappedSetFunction<T>;
+export interface TwilioWebhookEventHandlerConfigurer extends HandlerBindAccessor<TwilioWebhookEvent, TwilioWebhookEventType> {
+    readonly handleStatusCallback: TwilioHandlerMappedSetFunction<TwilioStatusCallbackEvent>;
+    readonly handleIncomingMessage: TwilioHandlerMappedSetFunction<TwilioIncomingMessageEvent>;
+}
+export declare const twilioWebhookEventHandlerConfigurerFactory: import("@dereekb/util").HandlerConfigurerFactory<TwilioWebhookEventHandlerConfigurer, TwilioWebhookEvent, TwilioWebhookEventType, boolean>;
+export type TwilioWebhookEventHandler = Handler<TwilioWebhookEvent, TwilioWebhookEventType>;