@crvouga/mockingbird-service-twilio 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1148 @@
+import { Hono } from 'hono';
+
+/**
+ * Anything that can answer a Fetch `Request` with a `Response`.
+ *
+ * Every Mockingbird service implements this, and every runtime adapter consumes it.
+ * It is the only contract shared across the whole graph.
+ */
+interface FetchAPI$1 {
+    fetch(request: Request): Promise<Response>;
+}
+
+/**
+ * The single source of time for a service.
+ *
+ * Every timestamp a mock writes reads from here, so a suite moves time instead of
+ * sleeping: appointment windows, result delays and expiries become reachable in
+ * milliseconds. A frozen clock also makes timestamps reproducible from a seed.
+ */
+type ClockState = {
+    /** Current epoch milliseconds. */
+    now: number;
+    /** True while time does not advance on its own. */
+    frozen: boolean;
+    /** Milliseconds this clock adds to its underlying source. */
+    offsetMs: number;
+};
+type Clock = {
+    now(): number;
+    /** Pin the clock to an exact instant, keeping it frozen if it already was. */
+    set(epochMs: number): void;
+    /** Move the clock forward, or back with a negative delta. */
+    advance(deltaMs: number): void;
+    /** Stop time at the current instant. */
+    freeze(): void;
+    /** Resume from the current instant. */
+    unfreeze(): void;
+    /** Drop back to the underlying source, live. */
+    reset(): void;
+    state(): ClockState;
+};
+
+/** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
+type SqliteValue$1 = null | number | bigint | string | Uint8Array | boolean;
+/** Mutation counters returned by {@link SqliteStatement.run}. */
+type SqliteRunResult$1 = {
+    changes: number;
+    lastInsertRowid: number | bigint;
+};
+/**
+ * Prepared statement bound to a {@link SqliteClient}.
+ *
+ * Pass bind values as rest arguments on each call (no sticky `bind()`).
+ */
+interface SqliteStatement$1 {
+    run(...params: SqliteValue$1[]): SqliteRunResult$1;
+    all<T = Record<string, unknown>>(...params: SqliteValue$1[]): T[];
+    get<T = Record<string, unknown>>(...params: SqliteValue$1[]): T | undefined;
+}
+/**
+ * Sync SQLite client port owned by Mockingbird.
+ *
+ * Duck-typed so `@crvouga/mockingbird-service-sqlite` `Database`, better-sqlite3, and wrapped
+ * `bun:sqlite` instances all work when they expose this surface.
+ */
+interface SqliteClient$1 {
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatement$1;
+    transaction<T>(fn: () => T): T;
+}
+
+/** Every stored record carries a monotonically increasing sequence for stable ordering. */
+type Stored<T> = {
+    seq: number;
+    value: T;
+};
+type ListRecordsOptions<T> = {
+    /** Keep only records passing the predicate. */
+    where?: (value: T, seq: number) => boolean;
+    /** Sort order; default newest first. */
+    order?: "newest" | "oldest";
+};
+/**
+ * A SQLite-backed table of JSON records addressed by id. Ordering is by insertion
+ * sequence, never by id lexicographic order, so list semantics stay stable.
+ */
+declare class Collection<T> {
+    private readonly sqlite;
+    private readonly namespace;
+    private readonly name;
+    constructor(sqlite: SqliteClient$1, namespace: string, name: string);
+    private bumpCollectionSeq;
+    nextSequence(): number;
+    get(id: string): T | undefined;
+    has(id: string): boolean;
+    /** Insert a new record, assigning it the next sequence number. */
+    insert(id: string, value: T): Stored<T>;
+    /** Replace an existing record's value, keeping its position. */
+    update(id: string, value: T): Stored<T> | undefined;
+    delete(id: string): boolean;
+    /** How many records the collection holds, without reading them. */
+    count(): number;
+    list(options?: ListRecordsOptions<T>): Array<Stored<T> & {
+        id: string;
+    }>;
+}
+
+/**
+ * Seeded pseudo-random numbers, so anything a mock invents — ids, jitter, which
+ * request a percentage fault hits — is reproducible from a seed.
+ *
+ * mulberry32: small, fast, and stable across runtimes, which matters more here
+ * than statistical quality.
+ */
+type Rng = {
+    /** Next value in `[0, 1)`. */
+    next(): number;
+    /** Next integer in `[min, max]`. */
+    int(min: number, max: number): number;
+    /** Restart the stream from its seed. */
+    reset(): void;
+    /** Serializable engine state used by deterministic checkpoints. */
+    state(): number;
+    /** Restore a state previously returned by {@link state}. */
+    setState(state: number): void;
+    seed: number;
+};
+
+/**
+ * A deliberate failure injected in front of an operation.
+ *
+ * This is how a suite reaches the vendor's failure modes without the vendor: the
+ * quota error that only appears when a shared sandbox is full, the 429 that only
+ * appears under load, the 5xx that proves a retry path works.
+ */
+type FaultRule = {
+    /** Stable id, so a suite can retire exactly the rule it added. */
+    id: string;
+    /** Fault only this operation. Omit to match every operation. */
+    operationId?: string;
+    /** Fault only this HTTP method, case-insensitive. Omit to match every method. */
+    method?: string;
+    /** Fault only paths starting with this prefix. Omit to match every path. */
+    pathPrefix?: string;
+    /**
+     * Fault only this namespace. Omit (or `"*"`) to fault every namespace — which is what
+     * an in-process caller usually wants, and what a parallel worker usually does not:
+     * rules added through `POST /__admin/faults` default to the calling namespace.
+     */
+    namespace?: string;
+    /**
+     * Status of the injected response. Omit for a rule that only delays (`delayMs` /
+     * `latencyMs`), only drops the connection (`drop`), or only switches on an `effect`:
+     * the request then still reaches the service.
+     */
+    status?: number;
+    /** Response body, serialized as JSON. A string is sent as-is. */
+    body?: unknown;
+    headers?: Record<string, string>;
+    /** Retire the rule after this many faults. Omit to keep it until removed. */
+    count?: number;
+    /** Fault this fraction of matching requests, `0`–`1`. Default `1`. */
+    rate?: number;
+    /** Hold the response back this long, to exercise timeouts. */
+    delayMs?: number;
+    /** Alias of `delayMs`. */
+    latencyMs?: number;
+    /**
+     * Drop the connection instead of answering: an in-process `fetch` rejects with a
+     * `TypeError`, and a served mock destroys the socket. Models "unknown outcome" failures.
+     */
+    drop?: boolean;
+    /**
+     * A named service behaviour to switch on for the matching request instead of (or
+     * before) a canned response, e.g. `created_but_500` or `numeric_tracking_id`. Services
+     * read it with `faultEffects(request)`.
+     */
+    effect?: string;
+    /** Parameters for `effect`. */
+    params?: Record<string, unknown>;
+    /** From the preset this rule was expanded from, if any. */
+    preset?: string;
+};
+/** A fault that fired for one request. */
+type FaultHit = {
+    id: string;
+    /** The injected response; absent when the rule only delays, drops, or sets an effect. */
+    response?: Response;
+    drop?: boolean;
+    effect?: {
+        name: string;
+        params: Record<string, unknown>;
+    };
+};
+/**
+ * A named, documented fault a suite switches on by name
+ * (`POST /__admin/faults {"preset": "rate_limited"}`): one or more rules, and optionally a
+ * webhook delivery fault.
+ */
+type FaultPreset = {
+    description: string;
+    rules?: Omit<FaultRule, "id">[];
+    webhook?: {
+        mode: "duplicate" | "reorder" | "drop";
+        count?: number;
+    };
+};
+/** What a request looks like to the fault matcher. */
+type FaultCandidate = {
+    operationId: string | undefined;
+    method: string;
+    path: string;
+    namespace: string;
+};
+type FaultRegistry = {
+    add(rule: FaultRule): FaultRule;
+    list(): (FaultRule & {
+        remaining: number | null;
+        hits: number;
+    })[];
+    remove(id: string): boolean;
+    clear(): void;
+    /**
+     * Every fault this request should get, in rule order, stopping at the first that answers
+     * or drops (effect-only and delay-only rules let later rules match too). Consumes one of
+     * each matching rule's remaining uses.
+     */
+    take(candidate: FaultCandidate): Promise<FaultHit[]>;
+};
+
+/** One handled request, as the structured log sees it. */
+type RequestLog = {
+    service: string;
+    namespace: string;
+    operationId: string | undefined;
+    method: string;
+    path: string;
+    status: number;
+    durationMs: number;
+    /** True when the path matched no operation in the contract. */
+    unmatched: boolean;
+    /** Set when a fault rule produced the response. */
+    faultId?: string;
+    /** Resource ids the handler touched (`userId`, `orderId`, …), when the service reports them. */
+    ids?: Record<string, string>;
+    /** Set when the service created a resource the request referred to but that did not exist. */
+    adopted?: boolean;
+};
+type MetricsReport = {
+    requests: number;
+    /** Counts keyed `<operationId> <status>`. */
+    byOperation: Record<string, number>;
+    /**
+     * Paths that matched no operation, most frequent first.
+     *
+     * This is the early-warning signal: a consumer calling something the mock does
+     * not implement shows up here as a count, before it fails a suite as a 404.
+     */
+    unmatched: {
+        method: string;
+        path: string;
+        count: number;
+    }[];
+    faults: number;
+    totalDurationMs: number;
+};
+type Metrics = {
+    record(entry: RequestLog): void;
+    report(): MetricsReport;
+    reset(): void;
+};
+
+/** One journal entry: a request log stamped with when (on the mock clock) it was handled. */
+type JournalEntry = RequestLog & {
+    at: string;
+};
+type JournalQuery = {
+    /** Only this namespace. Omit for every namespace, oldest first across all of them. */
+    namespace?: string;
+    operationId?: string;
+    status?: number;
+    /** Only entries at or after this instant (epoch ms). */
+    since?: number;
+    /** At most this many, the most recent kept. */
+    limit?: number;
+};
+type Journal = {
+    readonly size: number;
+    record(entry: JournalEntry): void;
+    list(query?: JournalQuery): JournalEntry[];
+    /** Forget one namespace's entries, or every namespace's. */
+    clear(namespace?: string): void;
+};
+
+/** Credential → namespace mapping behind `PUT /__admin/credentials`. */
+type CredentialRegistry = {
+    set(credential: string, namespace: string): void;
+    get(credential: string): string | undefined;
+    remove(credential: string): boolean;
+    clear(): void;
+    entries(): {
+        credential: string;
+        namespace: string;
+    }[];
+};
+
+/** A stable identifier for a point in a {@link Timeline}. */
+type CheckpointId = string;
+/** An immutable node in a timeline's checkpoint DAG. */
+type Checkpoint<T> = Readonly<{
+    id: CheckpointId;
+    branch: string;
+    parent: CheckpointId | null;
+    /** Logical time supplied by the timeline's injected clock. */
+    at: number;
+    value: T;
+}>;
+type TimelineOptions = {
+    /** Logical clock used to stamp checkpoints. Defaults to a deterministic counter. */
+    now?: () => number;
+    /** Maximum retained checkpoints. Branch heads are never collected. Default 1,000. */
+    maxCheckpoints?: number;
+    /** Customize deterministic checkpoint IDs. */
+    id?: (sequence: number) => CheckpointId;
+};
+type CommitOptions = {
+    branch?: string;
+    /** Parent checkpoint. Defaults to the selected branch's current head. */
+    parent?: CheckpointId | null;
+};
+type ForkOptions = {
+    /** Checkpoint to fork from. Defaults to the main branch's head. */
+    from?: CheckpointId;
+};
+/**
+ * Small, storage-agnostic checkpoint DAG shared by service runtimes. Its values may be immutable
+ * records, namespace images, or copy-on-write SQL engine snapshots.
+ *
+ * Values are retained by reference. Engines can therefore use persistent/COW snapshots while
+ * simpler services can use immutable values. IDs and GC order are deterministic, and all IO
+ * (the logical clock) is injected.
+ */
+declare class Timeline<T> {
+    readonly maxCheckpoints: number;
+    private readonly now;
+    private readonly makeId;
+    private readonly nodes;
+    private readonly heads;
+    /** Unreferenced nodes in the exact order they became collectible. */
+    private readonly evictable;
+    /** Branch heads plus explicit retainers. Absent means zero. */
+    private readonly references;
+    private readonly explicitPins;
+    private sequence;
+    constructor(options?: TimelineOptions);
+    /** Capture a new immutable value and move `branch` to it. */
+    commit(value: T, options?: CommitOptions): Checkpoint<T>;
+    /** Create a branch pointer without copying its checkpoint value. */
+    fork(branch: string, options?: ForkOptions): Checkpoint<T> | undefined;
+    /** Move a branch pointer to an existing checkpoint. */
+    checkout(branch: string, id: CheckpointId): Checkpoint<T>;
+    get(id: CheckpointId): Checkpoint<T>;
+    head(branch?: string): Checkpoint<T> | undefined;
+    hasBranch(branch: string): boolean;
+    branches(): Readonly<Record<string, CheckpointId>>;
+    checkpoints(): readonly Checkpoint<T>[];
+    /** Number of retained checkpoints without allocating an array. */
+    get size(): number;
+    /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
+    retain(id: CheckpointId): Checkpoint<T>;
+    /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
+    release(id: CheckpointId): boolean;
+    deleteBranch(branch: string): boolean;
+    /**
+     * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
+     * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
+     * storage dependency, so a retained node remains usable after pruning.
+     */
+    gc(max?: number): CheckpointId[];
+    private collect;
+    private moveHead;
+    private addReference;
+    private removeReference;
+    private assertBranch;
+}
+
+/**
+ * Anything that can answer a Fetch `Request` with a `Response`.
+ *
+ * Every Mockingbird service implements this, and every runtime adapter consumes it.
+ * It is the only contract shared across the whole graph.
+ */
+interface FetchAPI {
+    fetch(request: Request): Promise<Response>;
+}
+
+/**
+ * A point-in-time copy of everything a service namespace holds.
+ *
+ * All service state lives in the two core tables keyed by namespace, so a snapshot
+ * is generic: any service gets per-test rollback without knowing its own schema.
+ * Restoring is much cheaper than rebuilding a namespace from a corpus.
+ */
+type NamespaceSnapshot = {
+    namespace: string;
+    records: {
+        collection: string;
+        id: string;
+        seq: number;
+        value: string;
+    }[];
+    sequences: {
+        name: string;
+        kind: string;
+        value: number;
+    }[];
+};
+
+type WebhookEndpoint = {
+    /** Stable id; generated when omitted. */
+    id?: string;
+    url: string;
+    secret?: string;
+    /** Event types to deliver; omit or include `"*"` for every type. */
+    events?: string[];
+    /** Deliver only messages whose tags include all of these (e.g. `{ account: "mso" }`). */
+    tags?: Record<string, string>;
+    /** The public URL the receiver verifies signatures against (Twilio), when it differs. */
+    signUrl?: string;
+    headers?: Record<string, string>;
+};
+type WebhookMessage = {
+    id: string;
+    namespace: string;
+    type: string;
+    body: string;
+    contentType: string;
+    tags: Record<string, string>;
+    headers?: Record<string, string>;
+    /** Wall-clock ISO-8601 time of publication. */
+    publishedAt: string;
+};
+type WebhookAttempt = {
+    attempt: number;
+    at: string;
+    status: number | null;
+    error: string | null;
+    durationMs: number;
+    /** Exact receiver response body, when one was returned. */
+    responseBody?: string | null;
+};
+type WebhookDelivery = {
+    id: string;
+    messageId: string;
+    namespace: string;
+    type: string;
+    endpointId: string;
+    url: string;
+    state: "pending" | "delivered" | "failed" | "dropped";
+    attempts: WebhookAttempt[];
+};
+/** A delivery-level fault: what happens to the next `count` messages in a namespace. */
+type WebhookFault = {
+    mode: "duplicate" | "reorder" | "drop";
+    /** Messages affected; default 1. */
+    count?: number;
+};
+type PublishInput = {
+    namespace: string;
+    type: string;
+    /** Exact body; objects are JSON-encoded. */
+    body: string | Record<string, unknown> | unknown[];
+    /** Default `application/json`, or form-encoded when `form` is given. */
+    contentType?: string;
+    /** Form parameters, when the vendor posts `application/x-www-form-urlencoded`. */
+    form?: Record<string, string>;
+    tags?: Record<string, string>;
+    /** Message-specific delivery headers, captured as part of durable message state. */
+    headers?: Record<string, string>;
+    /** Message id; generated when omitted. */
+    id?: string;
+};
+type WebhookHub = {
+    publish(input: PublishInput): WebhookMessage;
+    /** Replace a namespace's own endpoints (`PUT /__admin/webhook-endpoints`). */
+    setEndpoints(namespace: string, endpoints: WebhookEndpoint[]): WebhookEndpoint[];
+    /** The endpoints a namespace delivers to: its own, plus the global ones. */
+    endpoints(namespace: string): WebhookEndpoint[];
+    messages(namespace?: string): WebhookMessage[];
+    deliveries(namespace?: string): WebhookDelivery[];
+    replay(deliveryId: string): Promise<WebhookDelivery | undefined>;
+    /** Run every pending retry (and release held reordered messages) now. */
+    flush(): Promise<void>;
+    /** Resolve once nothing is in flight. */
+    idle(): Promise<void>;
+    fault(namespace: string, fault: WebhookFault): void;
+    clear(namespace?: string): void;
+};
+
+/** What the runtime needs from a service: a Fetch handler it can reset. */
+type ServiceInstance = FetchAPI & {
+    reset(): Promise<void>;
+};
+type ServiceTimelineState = Readonly<{
+    snapshot: NamespaceSnapshot;
+    clock: Readonly<ReturnType<Clock["state"]>>;
+    rngState: number;
+}>;
+type ServiceCheckpoint = Checkpoint<ServiceTimelineState>;
+type ServiceRuntime<T extends ServiceInstance> = FetchAPI & {
+    readonly name: string;
+    readonly sqlite: SqliteClient$1;
+    readonly clock: Clock;
+    readonly faults: FaultRegistry;
+    readonly metrics: Metrics;
+    readonly journal: Journal;
+    readonly rng: Rng;
+    readonly credentials: CredentialRegistry;
+    /** The webhook hub, when the service has outbound webhooks. */
+    readonly webhooks: WebhookHub | undefined;
+    /** Expand a named preset into fault rules (and webhook faults) for `namespace`. */
+    applyPreset(name: string, namespace?: string, overrides?: Partial<FaultRule>): FaultRule[];
+    /** The instance behind `namespace` (the default one when omitted), created on first use. */
+    instance(namespace?: string): T;
+    /** Public names of every namespace created so far. */
+    namespaces(): string[];
+    /** Reset one namespace, or every namespace with `"*"`. */
+    reset(namespace?: string): Promise<void>;
+    snapshot(namespace?: string): NamespaceSnapshot;
+    restore(snapshot: NamespaceSnapshot, namespace?: string): void;
+    /** Capture the current branch. Mutating HTTP calls do this automatically. */
+    checkpoint(namespace?: string, branch?: string): ServiceCheckpoint;
+    /** Create an isolated branch, optionally from a historical checkpoint. */
+    branch(name: string, options?: {
+        namespace?: string;
+        at?: string;
+    }): ServiceCheckpoint;
+    /** Restore a branch, clock, and PRNG to a checkpoint. */
+    checkout(checkpoint: string, options?: {
+        namespace?: string;
+        branch?: string;
+    }): void;
+    /** Inspect the retained history for a namespace. */
+    timeline(namespace?: string): Timeline<ServiceTimelineState>;
+};
+
+/**
+ * What a comms vendor "sent" (an SMS, an email, a Slack post), kept per namespace so a
+ * suite can assert on it and read codes and links out of it. Stored in SQLite beside the
+ * service's other records, so reset, snapshot and restore cover it.
+ */
+type OutboxItem = {
+    id: string;
+    /** Recipient(s): a phone number, email address, channel or webhook path. */
+    to: string | string[];
+    /** ISO-8601 on the mock clock. */
+    createdAt: string;
+};
+type OutboxQuery = {
+    /** Case-insensitive match on any recipient. */
+    to?: string;
+    /** Only items at or after this instant (epoch ms). */
+    since?: number;
+    /** Extra filter over the item. */
+    where?: (item: Record<string, unknown>) => boolean;
+    limit?: number;
+};
+declare class OutboxStore<T extends OutboxItem = OutboxItem> {
+    private readonly items;
+    constructor(sqlite: SqliteClient$1, namespace: string, name?: string);
+    record(item: T): T;
+    get(id: string): T | undefined;
+    update(id: string, item: T): void;
+    /** Oldest first, so a suite reads messages in the order they were sent. */
+    list(query?: OutboxQuery): T[];
+}
+
+/** Options every provider constructor accepts. */
+type APIOptions = {
+    /** Sync SQLite client. Defaults to `@crvouga/mockingbird-service-sqlite`. */
+    sqlite?: SqliteClient$1;
+    /** Clock used for `created`-style fields. Default `Date.now`. */
+    now?: () => number;
+    /**
+     * Storage namespace for this instance's records. Instances sharing one SQLite
+     * client stay isolated when their namespaces differ. Defaults to the service name.
+     */
+    namespace?: string;
+};
+
+/** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
+type SqliteValue = null | number | bigint | string | Uint8Array | boolean;
+/** Mutation counters returned by {@link SqliteStatement.run}. */
+type SqliteRunResult = {
+    changes: number;
+    lastInsertRowid: number | bigint;
+};
+/**
+ * Prepared statement bound to a {@link SqliteClient}.
+ *
+ * Pass bind values as rest arguments on each call (no sticky `bind()`).
+ */
+interface SqliteStatement {
+    run(...params: SqliteValue[]): SqliteRunResult;
+    all<T = Record<string, unknown>>(...params: SqliteValue[]): T[];
+    get<T = Record<string, unknown>>(...params: SqliteValue[]): T | undefined;
+}
+/**
+ * Sync SQLite client port owned by Mockingbird.
+ *
+ * Duck-typed so `@crvouga/mockingbird-service-sqlite` `Database`, better-sqlite3, and wrapped
+ * `bun:sqlite` instances all work when they expose this surface.
+ */
+interface SqliteClient {
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatement;
+    transaction<T>(fn: () => T): T;
+}
+
+/**
+ * Lookup v2 number validation, modelled on what the live API answers (it is libphonenumber:
+ * the validation errors are libphonenumber's reasons). Verified live for fictional 555-01xx
+ * numbers and malformed inputs; see scripts/parity.ts.
+ */
+type ValidationError = "TOO_SHORT" | "TOO_LONG" | "INVALID_BUT_POSSIBLE" | "INVALID_COUNTRY_CODE" | "INVALID_LENGTH" | "NOT_A_NUMBER";
+type LookupResult = {
+    calling_country_code: string | null;
+    country_code: string | null;
+    phone_number: string;
+    national_format: string | null;
+    valid: boolean;
+    validation_errors: ValidationError[];
+};
+/**
+ * Validate the way Lookup v2 does. `raw` is the decoded path segment; `countryCode` the
+ * optional `CountryCode` query parameter (the region for a national-format number).
+ */
+declare const lookup: (raw: string, countryCode?: string) => LookupResult;
+/** `+` and digits only: the key admin routes and overrides use. */
+declare const e164Key: (value: string) => string;
+
+type VerificationStatus = "pending" | "approved" | "canceled" | "expired";
+/**
+ * One Verify verification. `code` never leaves the mock through the vendor API: tests read it
+ * with `GET /__admin/verify/:e164/latest` (or from the outbox), as a phone would receive it.
+ */
+type VerificationRecord = {
+    sid: string;
+    serviceSid: string;
+    accountSid: string;
+    to: string;
+    channel: string;
+    code: string;
+    status: VerificationStatus;
+    /** Check attempts made against this verification (right or wrong). */
+    attempts: number;
+    sendAttempts: {
+        attemptSid: string;
+        channel: string;
+        time: string;
+        timeMs: number;
+    }[];
+    createdAtMs: number;
+    dateCreated: string;
+    dateUpdated: string;
+};
+/** A Message resource as `Messages.json` answers it. */
+type MessageRecord = {
+    sid: string;
+    account_sid: string;
+    api_version: "2010-04-01";
+    body: string;
+    to: string;
+    from: string | null;
+    messaging_service_sid: string | null;
+    status: "queued" | "accepted";
+    direction: "outbound-api";
+    num_segments: string;
+    num_media: string;
+    price: null;
+    price_unit: "USD";
+    error_code: null;
+    error_message: null;
+    date_created: string;
+    date_updated: string;
+    date_sent: null;
+    uri: string;
+    subresource_uris: {
+        media: string;
+        feedback: string;
+    };
+};
+type RecordingRecord = {
+    sid: string;
+    accountSid: string;
+    callSid: string;
+    /** The WAV exactly as served with `RequestedChannels=2`. */
+    wavBase64: string;
+    channels: number;
+    duration: number;
+    createdAt: string;
+    deleted: boolean;
+};
+/** What the mock "sent": outbound SMS and every Verify code delivery. */
+type TwilioOutboxItem = OutboxItem & {
+    kind: "sms" | "verify";
+    sid: string;
+    to: string;
+    from: string | null;
+    messagingServiceSid: string | null;
+    body: string;
+    channel: string;
+    /** The Verify code, for `kind: "verify"`. */
+    code?: string;
+    mediaUrls?: string[];
+};
+type LookupOverride = {
+    valid: boolean;
+    validationErrors: ValidationError[];
+};
+/** Per-namespace Verify knobs, set through `PUT /__admin/verify`; cleared on reset. */
+type VerifySettings = {
+    /** Every new verification gets this code; `null` means a random 6-digit code. */
+    fixedCode: string | null;
+    /** Verifications expire this long after creation, on the mock clock (Twilio: 10 min). */
+    ttlSeconds: number;
+    /** Checks allowed per verification; the next one is 429 60202. */
+    maxCheckAttempts: number;
+    /** Sends allowed per number and service within `sendWindowSeconds`; the next is 429 60203. */
+    maxSendAttempts: number;
+    sendWindowSeconds: number;
+};
+declare const DEFAULT_VERIFY_SETTINGS: VerifySettings;
+declare class TwilioState {
+    private readonly namespace;
+    private readonly seed;
+    readonly verifications: Collection<VerificationRecord>;
+    readonly messages: Collection<MessageRecord>;
+    readonly recordings: Collection<RecordingRecord>;
+    readonly lookups: Collection<LookupOverride>;
+    readonly settings: Collection<VerifySettings>;
+    readonly outbox: OutboxStore<TwilioOutboxItem>;
+    private readonly ids;
+    constructor(sqlite: SqliteClient, namespace: string, seed?: Partial<VerifySettings>);
+    /** A Twilio sid: two-letter prefix plus 32 hex characters, deterministic per history. */
+    sid(prefix: string): string;
+    /** A random-looking but reproducible 6-digit code for a new verification. */
+    code(sid: string, length?: number): string;
+    verify(): VerifySettings;
+    updateVerify(patch: Partial<VerifySettings>): VerifySettings;
+    /** Newest first. */
+    verificationsTo(to: string, serviceSid?: string): VerificationRecord[];
+}
+
+/**
+ * The slice of OpenAPI 3.1 (and JSON Schema 2020-12) Mockingbird understands.
+ * Unknown keys (including `x-*` extensions) are preserved on every object.
+ */
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type ReferenceObject = {
+    $ref: string;
+    description?: string;
+    summary?: string;
+};
+type SchemaType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
+type SchemaObject = {
+    $ref?: string;
+    type?: SchemaType | SchemaType[];
+    title?: string;
+    description?: string;
+    format?: string;
+    enum?: JsonValue[];
+    const?: JsonValue;
+    default?: JsonValue;
+    example?: JsonValue;
+    examples?: JsonValue[];
+    nullable?: boolean;
+    deprecated?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    items?: SchemaObject;
+    prefixItems?: SchemaObject[];
+    minProperties?: number;
+    maxProperties?: number;
+    required?: string[];
+    properties?: Record<string, SchemaObject>;
+    additionalProperties?: boolean | SchemaObject;
+    propertyNames?: SchemaObject;
+    oneOf?: SchemaObject[];
+    anyOf?: SchemaObject[];
+    allOf?: SchemaObject[];
+    not?: SchemaObject;
+    discriminator?: {
+        propertyName: string;
+        mapping?: Record<string, string>;
+    };
+    [extension: `x-${string}`]: unknown;
+};
+type ParameterLocation = "path" | "query" | "header" | "cookie";
+type ParameterObject = {
+    name: string;
+    in: ParameterLocation;
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    style?: string;
+    explode?: boolean;
+    schema?: SchemaObject;
+    content?: Record<string, MediaTypeObject>;
+    example?: JsonValue;
+    [extension: `x-${string}`]: unknown;
+};
+type MediaTypeObject = {
+    schema?: SchemaObject;
+    example?: JsonValue;
+    examples?: Record<string, unknown>;
+    encoding?: Record<string, unknown>;
+    [extension: `x-${string}`]: unknown;
+};
+type RequestBodyObject = {
+    description?: string;
+    required?: boolean;
+    content: Record<string, MediaTypeObject>;
+    [extension: `x-${string}`]: unknown;
+};
+type HeaderObject = {
+    description?: string;
+    required?: boolean;
+    schema?: SchemaObject;
+    [extension: `x-${string}`]: unknown;
+};
+type ResponseObject = {
+    description: string;
+    headers?: Record<string, HeaderObject | ReferenceObject>;
+    content?: Record<string, MediaTypeObject>;
+    [extension: `x-${string}`]: unknown;
+};
+type ResponsesObject = Record<string, ResponseObject | ReferenceObject>;
+type SecurityRequirementObject = Record<string, string[]>;
+type OperationObject = {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    deprecated?: boolean;
+    parameters?: Array<ParameterObject | ReferenceObject>;
+    requestBody?: RequestBodyObject | ReferenceObject;
+    responses: ResponsesObject;
+    security?: SecurityRequirementObject[];
+    [extension: `x-${string}`]: unknown;
+};
+declare const HTTP_METHODS: readonly ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+type HttpMethod = (typeof HTTP_METHODS)[number];
+type PathItemObject = {
+    summary?: string;
+    description?: string;
+    parameters?: Array<ParameterObject | ReferenceObject>;
+    [extension: `x-${string}`]: unknown;
+} & Partial<Record<HttpMethod, OperationObject>>;
+type SecuritySchemeObject = {
+    type: "apiKey" | "http" | "oauth2" | "openIdConnect" | "mutualTLS";
+    description?: string;
+    name?: string;
+    in?: ParameterLocation;
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: Record<string, unknown>;
+    openIdConnectUrl?: string;
+    [extension: `x-${string}`]: unknown;
+};
+type ComponentsObject = {
+    schemas?: Record<string, SchemaObject>;
+    responses?: Record<string, ResponseObject>;
+    parameters?: Record<string, ParameterObject>;
+    requestBodies?: Record<string, RequestBodyObject>;
+    headers?: Record<string, HeaderObject>;
+    securitySchemes?: Record<string, SecuritySchemeObject>;
+    [extension: `x-${string}`]: unknown;
+};
+type ServerObject = {
+    url: string;
+    description?: string;
+    variables?: Record<string, unknown>;
+    [extension: `x-${string}`]: unknown;
+};
+type InfoObject = {
+    title: string;
+    version: string;
+    description?: string;
+    [extension: `x-${string}`]: unknown;
+};
+type OpenAPIDocument = {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: Record<string, PathItemObject>;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: Array<{
+        name: string;
+        description?: string;
+    }>;
+    [extension: `x-${string}`]: unknown;
+};
+
+declare const document: OpenAPIDocument;
+type OperationId = "FetchPhoneNumber" | "CreateVerification" | "FetchVerification" | "UpdateVerification" | "CreateVerificationCheck" | "CreateMessage" | "FetchMessage" | "FetchRecordingMedia" | "FetchRecording" | "DeleteRecording";
+type SupportedOperationId = "FetchPhoneNumber" | "CreateVerification" | "FetchVerification" | "UpdateVerification" | "CreateVerificationCheck" | "CreateMessage" | "FetchMessage" | "FetchRecordingMedia" | "FetchRecording" | "DeleteRecording";
+declare const operationIds: readonly ["FetchPhoneNumber", "CreateVerification", "FetchVerification", "UpdateVerification", "CreateVerificationCheck", "CreateMessage", "FetchMessage", "FetchRecordingMedia", "FetchRecording", "DeleteRecording"];
+declare const supportedOperationIds: readonly ["FetchPhoneNumber", "CreateVerification", "FetchVerification", "UpdateVerification", "CreateVerificationCheck", "CreateMessage", "FetchMessage", "FetchRecordingMedia", "FetchRecording", "DeleteRecording"];
+
+/**
+ * Routing Twilio's per-product hosts onto one mock origin.
+ *
+ * twilio-node builds absolute URLs on a host per product (`https://verify.twilio.com/v2/…`,
+ * `https://lookups.twilio.com/v2/…`, `https://api.twilio.com/2010-04-01/…`). The mock serves
+ * them all on one port and tells them apart by the product carried as the first path segment:
+ * `{mock}/verify/v2/…`, `{mock}/lookups/v2/…`, `{mock}/api/2010-04-01/…`.
+ */
+/** The products the mock serves, by their host's first label. */
+declare const TWILIO_PRODUCTS: readonly ["api", "verify", "lookups"];
+/**
+ * The mock URL for an upstream Twilio URL: `https://verify.twilio.com/v2/Services/VA…/Verifications`
+ * with base `http://127.0.0.1:8798` becomes `http://127.0.0.1:8798/verify/v2/Services/VA…/Verifications`.
+ * A base with a path (`http://127.0.0.1:8798/ns/worker-1`) keeps it. Non-Twilio URLs are
+ * returned unchanged.
+ */
+declare const twilioMockUrl: (uri: string, mockBaseUrl: string) => string;
+
+/**
+ * Just enough RIFF/WAVE for the Recordings surface: synthesise a PCM recording, read a WAV's
+ * format, and mix a dual-channel recording down to mono (what Twilio serves unless the
+ * request asks for `RequestedChannels=2`).
+ */
+type WavFormat = {
+    audioFormat: number;
+    channels: number;
+    sampleRate: number;
+    bitsPerSample: number;
+    /** Offset and length of the `data` chunk, when present. */
+    dataOffset: number;
+    dataLength: number;
+};
+/** The `fmt ` and `data` chunks of a RIFF/WAVE file, or `undefined` when it is not one. */
+declare const readWav: (bytes: Uint8Array) => WavFormat | undefined;
+/**
+ * A 16-bit PCM WAV like a Twilio call recording (8 kHz). Each channel carries a quiet tone at a
+ * different pitch, so a mix-down is observably not either channel.
+ */
+declare const synthesizeWav: (options?: {
+    channels?: number;
+    seconds?: number;
+}) => Uint8Array<ArrayBuffer>;
+/** Average a 16-bit PCM WAV's channels into one; anything else is returned unchanged. */
+declare const mixDownToMono: (bytes: Uint8Array) => Uint8Array;
+
+/**
+ * Every named Twilio misbehaviour our consumer branches on, switched on with
+ * `POST /__admin/faults {"preset": "<name>"}` (add `count` to limit it). Our code branches on
+ * HTTP status class and transport errors only, never on Twilio's numeric codes.
+ */
+declare const TWILIO_PRESETS: Record<string, FaultPreset>;
+/** Event types the hub publishes; endpoints can filter on them (`PUT /__admin/webhook-endpoints`). */
+declare const TWILIO_WEBHOOK_EVENTS: {
+    readonly "sms.inbound": "/messaging/inbound/sms";
+    readonly "voice.twiml": "/admin/messaging/voice/twiml";
+    readonly "voice.disclosure": "/admin/messaging/voice/disclosure";
+    readonly "voice.status": "/admin/messaging/voice/status";
+    readonly "voice.recording": "/admin/messaging/voice/recording";
+};
+type VoiceWebhookKind = "twiml" | "disclosure" | "status" | "recording";
+/**
+ * Where Twilio's inbound webhooks go: the app's origin, the public base URL it verifies
+ * signatures against (`TWILIO_VOICE_WEBHOOK_BASE_URL`), and the auth token it verifies with.
+ */
+type TwilioAppWebhooks = {
+    /** Where the mock posts, e.g. `http://127.0.0.1:3000`. */
+    url: string;
+    /** The public base URL the app signs against. Default: `url`. */
+    publicBaseUrl?: string;
+    /** The app's `TWILIO_AUTH_TOKEN` (the HMAC key). */
+    authToken: string;
+    /** `AccountSid` in the payloads. Default {@link DEFAULT_ACCOUNT_SID}. */
+    accountSid?: string;
+    /** `To` of inbound SMS (the app requires `TWILIO_VOICE_CALLER_ID`). */
+    callerId?: string;
+    /** `MessagingServiceSid` of inbound SMS, when the number belongs to one. */
+    messagingServiceSid?: string;
+};
+type TwilioRuntimeOptions = {
+    sqlite?: SqliteClient;
+    clock?: Clock;
+    seed?: number | string;
+    adminKey?: string;
+    onLog?: (entry: RequestLog) => void;
+    /** Initial Verify settings for every namespace (e.g. `{fixedCode: "000000"}`). */
+    verify?: Partial<VerifySettings>;
+    /** Accepted `AccountSid → AuthToken` pairs; omitted, any `AC…` sid with a token works. */
+    accounts?: Record<string, string>;
+    /** Inbound SMS and voice webhooks to the app. */
+    app?: TwilioAppWebhooks;
+    /** Delay before each webhook attempt. Default `[0]`: Twilio does not retry these. */
+    retryDelaysMs?: readonly number[];
+    /** Sends webhooks (tests pass an in-process receiver). Default global `fetch`. */
+    fetch?: (request: Request) => Promise<Response>;
+};
+type InboundSmsInput = {
+    from: string;
+    body: string;
+    /** Default: the configured `callerId`. */
+    to?: string;
+    /** Media URLs (https) or `{url, contentType}`; makes the sid `MM…`. */
+    media?: (string | {
+        url: string;
+        contentType?: string;
+    })[];
+    messageSid?: string;
+    accountSid?: string;
+    /** Extra form parameters, verbatim. */
+    params?: Record<string, string>;
+};
+/** One delivery of an admin-triggered webhook, with what the app answered. */
+type DeliveryOutcome = {
+    url: string;
+    state: string;
+    status: number | null;
+    error: string | null;
+    response: string | null;
+};
+type TwilioRuntime = ServiceRuntime<TwilioAPI> & {
+    readonly webhooks: WebhookHub;
+    /** Sign and post an inbound SMS to the app; resolves once delivered (or failed). */
+    inboundSms(input: InboundSmsInput, namespace?: string): Promise<SentWebhook>;
+    /** Sign and post a voice webhook (`twiml`, `disclosure`, `status`, `recording`). */
+    voiceWebhook(kind: VoiceWebhookKind, params?: Record<string, string>, namespace?: string): Promise<SentWebhook>;
+};
+type SentWebhook = {
+    params: Record<string, string>;
+    deliveries: DeliveryOutcome[];
+};
+/**
+ * The Twilio mock with Mockingbird's full service contract: `/health`, `/__admin/*`,
+ * namespaces by header, by `/ns/<name>` prefix, or by AccountSid
+ * (`PUT /__admin/credentials {"credentials": {"<AccountSid>": "<namespace>"}}`), clock
+ * control, fault presets, an outbox, and signed inbound SMS and voice webhooks.
+ */
+declare const createRuntime: (options?: TwilioRuntimeOptions) => TwilioRuntime;
+
+declare const TWILIO_NAMESPACE = "twilio";
+/** The account sid used when a request carries an API key (`SK…`) instead of an account sid. */
+declare const DEFAULT_ACCOUNT_SID = "AC00000000000000000000000000000000";
+type TwilioAPIOptions = APIOptions & {
+    /** Initial Verify settings for the namespace (fixed code, expiry, attempt limits). */
+    verify?: Partial<VerifySettings>;
+    /**
+     * Accepted `AccountSid → AuthToken` pairs. Omitted: any `AC…`/`SK…` username with a
+     * non-empty password authenticates (Twilio's test credentials included).
+     */
+    accounts?: Record<string, string>;
+};
+/** Twilio's JSON error body, `{code, message, more_info, status}`, with `X-Twilio-Error-Code`. */
+declare const twilioError: (status: number, code: number, message: string) => Response;
+type LatestVerification = {
+    sid: string;
+    code: string;
+    status: VerificationRecord["status"];
+    to: string;
+    channel: string;
+    serviceSid: string;
+    attempts: number;
+    sendAttempts: number;
+    createdAt: string;
+    expiresAt: string;
+};
+type PutRecordingInput = {
+    /** WAV bytes; omitted means a synthesised 16-bit 8 kHz PCM recording. */
+    wav?: Uint8Array;
+    /** For a synthesised recording. Default 2 (a dual-channel call recording). */
+    channels?: number;
+    seconds?: number;
+    accountSid?: string;
+    callSid?: string;
+};
+/**
+ * Stateful mock of Twilio Lookup v2, Verify v2, Programmable Messaging and call Recordings,
+ * with each product routed by its host carried as a path prefix (`/lookups`, `/verify`,
+ * `/api`).
+ */
+declare class TwilioAPI implements FetchAPI$1 {
+    readonly app: Hono;
+    readonly sqlite: SqliteClient;
+    readonly state: TwilioState;
+    private readonly service;
+    private readonly now;
+    private readonly accounts;
+    constructor(options?: TwilioAPIOptions);
+    fetch(request: Request): Promise<Response>;
+    reset(): Promise<void>;
+    private authenticate;
+    /** The account a request acts for: the path's, else the Basic username when it is one. */
+    private accountOf;
+    private requireAccount;
+    /** Lookup validity, with any `PUT /__admin/lookups/:e164` override applied. */
+    resolveLookup(raw: string, countryCode?: string): LookupResult;
+    private fetchPhoneNumber;
+    private requireService;
+    /** The verification as of now: a pending one past its expiry becomes `expired`. */
+    private current;
+    private verificationBody;
+    /** `To` as Verify accepts it: an email for the email channel, else a valid E.164 number. */
+    private verifyRecipient;
+    private createVerification;
+    private findVerification;
+    private fetchVerification;
+    private updateVerification;
+    private createVerificationCheck;
+    private createMessage;
+    private fetchMessage;
+    private findRecording;
+    private fetchRecordingMedia;
+    private recordingBody;
+    private fetchRecording;
+    private deleteRecording;
+    /** The newest verification to a number (what `GET /__admin/verify/:e164/latest` answers). */
+    latestVerification(to: string): LatestVerification | undefined;
+    setLookup(e164: string, override: LookupOverride): void;
+    /** Store (or synthesise) a recording so `GET …/Recordings/{sid}.wav` serves it. */
+    putRecording(sid: string, input?: PutRecordingInput): RecordingRecord;
+    outbox(): TwilioOutboxItem[];
+    messages(): MessageRecord[];
+}
+
+export { DEFAULT_ACCOUNT_SID, DEFAULT_VERIFY_SETTINGS, TWILIO_NAMESPACE, TWILIO_PRESETS, TWILIO_PRODUCTS, TWILIO_WEBHOOK_EVENTS, TwilioAPI, createRuntime, document, e164Key, lookup, mixDownToMono, operationIds, readWav, supportedOperationIds, synthesizeWav, twilioError, twilioMockUrl };
+export type { FetchAPI$1 as FetchAPI, InboundSmsInput, LatestVerification, LookupOverride, LookupResult, MessageRecord, OperationId, PutRecordingInput, RecordingRecord, SqliteClient, SupportedOperationId, TwilioAPIOptions, TwilioAppWebhooks, TwilioOutboxItem, TwilioRuntime, TwilioRuntimeOptions, ValidationError, VerificationRecord, VerificationStatus, VerifySettings, VoiceWebhookKind, WavFormat };