@fonoster/common 0.27.0 → 0.30.0

package/dist/session/schema.d.ts

@@ -0,0 +1,1951 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { FromSchema } from "json-schema-to-ts";
+export declare const SESSION_PROTOCOL = "fonoster.session.v1";
+export declare const sessionStartSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "protocol", "sessionRef", "callRef", "appRef", "direction", "from", "to", "metadata", "handoff", "audio", "tracks", "speech"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "session.start";
+        };
+        readonly protocol: {
+            readonly const: "fonoster.session.v1";
+        };
+        readonly sessionRef: {
+            readonly type: "string";
+        };
+        readonly callRef: {
+            readonly type: "string";
+        };
+        readonly appRef: {
+            readonly type: "string";
+        };
+        readonly direction: {
+            readonly enum: readonly ["inbound", "outbound"];
+        };
+        readonly from: {
+            readonly type: "string";
+        };
+        readonly to: {
+            readonly type: "string";
+        };
+        readonly metadata: {
+            readonly type: "object";
+        };
+        readonly handoff: {
+            readonly oneOf: readonly [{
+                readonly type: "null";
+            }, {
+                readonly type: "object";
+            }];
+        };
+        readonly audio: {
+            readonly type: "object";
+            readonly required: readonly ["codec", "rate"];
+            readonly properties: {
+                readonly codec: {
+                    readonly enum: readonly ["pcm16", "pcmu"];
+                };
+                readonly rate: {
+                    readonly enum: readonly [8000, 16000, 24000];
+                };
+            };
+        };
+        readonly tracks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["id", "side", "kind", "codec"];
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly maximum: 255;
+                    };
+                    readonly side: {
+                        readonly enum: readonly ["inbound", "outbound"];
+                    };
+                    readonly kind: {
+                        readonly enum: readonly ["audio"];
+                    };
+                    readonly codec: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        readonly speech: {
+            readonly type: "object";
+            readonly required: readonly ["voice", "language"];
+            readonly properties: {
+                readonly voice: {
+                    readonly type: "string";
+                };
+                readonly language: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+};
+export declare const SESSION_END_REASONS: readonly ["caller_hangup", "app_hangup", "transfer", "handoff", "error", "timeout"];
+export declare const sessionEndSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "reason"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "session.end";
+        };
+        readonly reason: {
+            readonly enum: readonly ["caller_hangup", "app_hangup", "transfer", "handoff", "error", "timeout"];
+        };
+    };
+};
+export declare const ERROR_CODES: readonly ["bad_message", "unknown_command", "read_only", "not_supported_by_protocol", "provider_unavailable", "provider_timeout", "invalid_catalog_id", "feature_not_supported", "transfer_failed", "on_hold", "queue_full", "play_fetch_failed", "internal"];
+export declare const errorSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "code", "message", "fatal"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "error";
+        };
+        readonly code: {
+            readonly type: "string";
+        };
+        readonly message: {
+            readonly type: "string";
+        };
+        readonly fatal: {
+            readonly type: "boolean";
+        };
+        readonly relatesTo: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+    };
+};
+export declare const turnUserStartedSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "turn.user_started";
+        };
+    };
+};
+export declare const turnLikelyEndedSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "text"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "turn.likely_ended";
+        };
+        readonly text: {
+            readonly type: "string";
+        };
+    };
+};
+export declare const turnEndedSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "text", "language", "confidence", "durationMs"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "turn.ended";
+        };
+        readonly text: {
+            readonly type: "string";
+        };
+        readonly language: {
+            readonly type: "string";
+        };
+        readonly confidence: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly maximum: 1;
+        };
+        readonly durationMs: {
+            readonly type: "number";
+            readonly minimum: 0;
+        };
+        /** No speech followed turn.user_started for 10 s (noise, a dropped line). */
+        readonly abandoned: {
+            readonly type: "boolean";
+        };
+    };
+};
+export declare const turnResumedSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "turn.resumed";
+        };
+    };
+};
+export declare const turnBackchannelSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "text"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "turn.backchannel";
+        };
+        readonly text: {
+            readonly type: "string";
+        };
+    };
+};
+export declare const turnEstimateSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "eot", "speaking", "kind"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "turn.estimate";
+        };
+        readonly eot: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly maximum: 1;
+        };
+        readonly speaking: {
+            readonly type: "boolean";
+        };
+        readonly kind: {
+            readonly enum: readonly ["speech", "backchannel", "interruption", "none"];
+        };
+    };
+};
+export declare const transcriptPartialSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "text"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "transcript.partial";
+        };
+        readonly text: {
+            readonly type: "string";
+        };
+        readonly language: {
+            readonly type: "string";
+        };
+    };
+};
+export declare const outputStartedSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "id"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "output.started";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+    };
+};
+export declare const outputDoneSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "id"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "output.done";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+        readonly heardMs: {
+            readonly type: "number";
+            readonly minimum: 0;
+        };
+    };
+};
+export declare const outputInterruptedSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "id", "heardText", "heardMs"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "output.interrupted";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+        readonly heardText: {
+            readonly type: "string";
+        };
+        readonly heardMs: {
+            readonly type: "number";
+            readonly minimum: 0;
+        };
+    };
+};
+export declare const markEventSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "name", "cleared"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "mark";
+        };
+        readonly name: {
+            readonly type: "string";
+        };
+        readonly cleared: {
+            readonly type: "boolean";
+        };
+    };
+};
+export declare const dtmfEventSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "digit"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "dtmf";
+        };
+        readonly digit: {
+            readonly type: "string";
+            readonly pattern: "^[0-9A-D*#]$";
+        };
+    };
+};
+/** Answering-machine detection, once per call, for apps with `amd` (add-media-node 4.3). */
+export declare const amdResultSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "status", "confidence", "detector", "audioMs"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "amd.result";
+        };
+        readonly status: {
+            readonly enum: readonly ["human", "voicemail", "ivr", "machine", "unknown"];
+        };
+        readonly confidence: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly maximum: 1;
+        };
+        readonly detector: {
+            readonly type: "string";
+        };
+        /** How much caller audio the verdict is based on, from when the caller started speaking. */
+        readonly audioMs: {
+            readonly type: "number";
+            readonly minimum: 0;
+        };
+        /** Caller audio received before speech began (unset when the caller never spoke). */
+        readonly speechOnsetMs: {
+            readonly type: "number";
+            readonly minimum: 0;
+        };
+        /** Why detection could not run (status unknown): no_audio, no_speech, no_classifier, call_ended, … */
+        readonly reason: {
+            readonly type: "string";
+        };
+    };
+};
+export declare const speakSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "text"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "speak";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+        readonly text: {
+            readonly type: "string";
+        };
+        readonly last: {
+            readonly type: "boolean";
+        };
+        readonly voice: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly language: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly interruptible: {
+            readonly type: "boolean";
+        };
+        readonly preempt: {
+            readonly type: "boolean";
+        };
+    };
+};
+export declare const playSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "url"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "play";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+        readonly url: {
+            readonly type: "string";
+            readonly pattern: "^https?://";
+        };
+        readonly loop: {
+            readonly type: "boolean";
+        };
+        readonly interruptible: {
+            readonly type: "boolean";
+        };
+        readonly preempt: {
+            readonly type: "boolean";
+        };
+    };
+};
+export declare const listenUpdateSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "listen.update";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+        readonly language: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly hints: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        /** How long the Turn Detector waits before turn.ended. */
+        readonly patience: {
+            readonly enum: readonly ["low", "normal", "high"];
+        };
+    };
+};
+export declare const SUBSCRIBABLE_EVENTS: readonly ["turn.estimate", "transcript.partial"];
+export declare const subscribeSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "events"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "subscribe";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+        readonly events: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+    };
+};
+export declare const markCommandSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "name"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "mark";
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+    };
+};
+export declare const clearSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "clear";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+    };
+};
+export declare const hangupSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "hangup";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+    };
+};
+export declare const dtmfSendSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "digits"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "dtmf.send";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+        readonly digits: {
+            readonly type: "string";
+            readonly pattern: "^[0-9A-D*#w]+$";
+        };
+    };
+};
+export declare const TRANSFER_MODES: readonly ["cold", "warm", "refer"];
+export declare const transferSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "to"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "transfer";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+        readonly to: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly headers: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+        };
+        readonly mode: {
+            readonly enum: readonly ["cold", "warm", "refer"];
+        };
+        /** Warm transfers: what the caller hears while waiting. */
+        readonly music: {
+            readonly type: "string";
+        };
+    };
+};
+export declare const transferCompleteSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "id"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "transfer.complete";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+    };
+};
+export declare const holdSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "hold";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+        readonly music: {
+            readonly type: "string";
+        };
+    };
+};
+export declare const resumeSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "resume";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+    };
+};
+export declare const handoffSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "app"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "handoff";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+        readonly app: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly payload: {
+            readonly type: "object";
+        };
+    };
+};
+export declare const recordNoteSchema: {
+    readonly type: "object";
+    readonly required: readonly ["type", "data"];
+    readonly properties: {
+        readonly type: {
+            readonly const: "record.note";
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+        readonly data: {
+            readonly type: "object";
+        };
+    };
+};
+export type SessionStart = FromSchema<typeof sessionStartSchema>;
+export type SessionEnd = FromSchema<typeof sessionEndSchema>;
+export type SessionEndReason = (typeof SESSION_END_REASONS)[number];
+export type SessionError = FromSchema<typeof errorSchema>;
+export type ErrorCode = (typeof ERROR_CODES)[number];
+export type TurnUserStarted = FromSchema<typeof turnUserStartedSchema>;
+export type TurnLikelyEnded = FromSchema<typeof turnLikelyEndedSchema>;
+export type TurnEnded = FromSchema<typeof turnEndedSchema>;
+export type TurnResumed = FromSchema<typeof turnResumedSchema>;
+export type TurnBackchannel = FromSchema<typeof turnBackchannelSchema>;
+export type TurnEstimate = FromSchema<typeof turnEstimateSchema>;
+export type TranscriptPartial = FromSchema<typeof transcriptPartialSchema>;
+export type OutputStarted = FromSchema<typeof outputStartedSchema>;
+export type OutputDone = FromSchema<typeof outputDoneSchema>;
+export type OutputInterrupted = FromSchema<typeof outputInterruptedSchema>;
+export type MarkEvent = FromSchema<typeof markEventSchema>;
+export type DtmfEvent = FromSchema<typeof dtmfEventSchema>;
+export type AmdResult = FromSchema<typeof amdResultSchema>;
+export type Speak = FromSchema<typeof speakSchema>;
+export type Play = FromSchema<typeof playSchema>;
+export type ListenUpdate = FromSchema<typeof listenUpdateSchema>;
+export type Subscribe = FromSchema<typeof subscribeSchema>;
+export type MarkCommand = FromSchema<typeof markCommandSchema>;
+export type Clear = FromSchema<typeof clearSchema>;
+export type Hangup = FromSchema<typeof hangupSchema>;
+export type DtmfSend = FromSchema<typeof dtmfSendSchema>;
+export type Transfer = FromSchema<typeof transferSchema>;
+export type TransferMode = (typeof TRANSFER_MODES)[number];
+export type TransferComplete = FromSchema<typeof transferCompleteSchema>;
+export type Hold = FromSchema<typeof holdSchema>;
+export type Resume = FromSchema<typeof resumeSchema>;
+export type Handoff = FromSchema<typeof handoffSchema>;
+export type RecordNote = FromSchema<typeof recordNoteSchema>;
+export type GatewayMessage = SessionStart | SessionEnd | SessionError | TurnUserStarted | TurnLikelyEnded | TurnEnded | TurnResumed | TurnBackchannel | TurnEstimate | TranscriptPartial | OutputStarted | OutputDone | OutputInterrupted | MarkEvent | DtmfEvent | AmdResult;
+export type AppCommand = Speak | Play | ListenUpdate | Subscribe | MarkCommand | Clear | Hangup | DtmfSend | Transfer | TransferComplete | Hold | Resume | Handoff | RecordNote;
+/** Schemas by message type, per direction. "mark" exists in both directions. */
+export declare const GATEWAY_MESSAGE_SCHEMAS: {
+    readonly "session.start": {
+        readonly type: "object";
+        readonly required: readonly ["type", "protocol", "sessionRef", "callRef", "appRef", "direction", "from", "to", "metadata", "handoff", "audio", "tracks", "speech"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "session.start";
+            };
+            readonly protocol: {
+                readonly const: "fonoster.session.v1";
+            };
+            readonly sessionRef: {
+                readonly type: "string";
+            };
+            readonly callRef: {
+                readonly type: "string";
+            };
+            readonly appRef: {
+                readonly type: "string";
+            };
+            readonly direction: {
+                readonly enum: readonly ["inbound", "outbound"];
+            };
+            readonly from: {
+                readonly type: "string";
+            };
+            readonly to: {
+                readonly type: "string";
+            };
+            readonly metadata: {
+                readonly type: "object";
+            };
+            readonly handoff: {
+                readonly oneOf: readonly [{
+                    readonly type: "null";
+                }, {
+                    readonly type: "object";
+                }];
+            };
+            readonly audio: {
+                readonly type: "object";
+                readonly required: readonly ["codec", "rate"];
+                readonly properties: {
+                    readonly codec: {
+                        readonly enum: readonly ["pcm16", "pcmu"];
+                    };
+                    readonly rate: {
+                        readonly enum: readonly [8000, 16000, 24000];
+                    };
+                };
+            };
+            readonly tracks: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["id", "side", "kind", "codec"];
+                    readonly properties: {
+                        readonly id: {
+                            readonly type: "integer";
+                            readonly minimum: 0;
+                            readonly maximum: 255;
+                        };
+                        readonly side: {
+                            readonly enum: readonly ["inbound", "outbound"];
+                        };
+                        readonly kind: {
+                            readonly enum: readonly ["audio"];
+                        };
+                        readonly codec: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+            readonly speech: {
+                readonly type: "object";
+                readonly required: readonly ["voice", "language"];
+                readonly properties: {
+                    readonly voice: {
+                        readonly type: "string";
+                    };
+                    readonly language: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+    };
+    readonly "session.end": {
+        readonly type: "object";
+        readonly required: readonly ["type", "reason"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "session.end";
+            };
+            readonly reason: {
+                readonly enum: readonly ["caller_hangup", "app_hangup", "transfer", "handoff", "error", "timeout"];
+            };
+        };
+    };
+    readonly error: {
+        readonly type: "object";
+        readonly required: readonly ["type", "code", "message", "fatal"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "error";
+            };
+            readonly code: {
+                readonly type: "string";
+            };
+            readonly message: {
+                readonly type: "string";
+            };
+            readonly fatal: {
+                readonly type: "boolean";
+            };
+            readonly relatesTo: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+        };
+    };
+    readonly "turn.user_started": {
+        readonly type: "object";
+        readonly required: readonly ["type"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "turn.user_started";
+            };
+        };
+    };
+    readonly "turn.likely_ended": {
+        readonly type: "object";
+        readonly required: readonly ["type", "text"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "turn.likely_ended";
+            };
+            readonly text: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly "turn.ended": {
+        readonly type: "object";
+        readonly required: readonly ["type", "text", "language", "confidence", "durationMs"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "turn.ended";
+            };
+            readonly text: {
+                readonly type: "string";
+            };
+            readonly language: {
+                readonly type: "string";
+            };
+            readonly confidence: {
+                readonly type: "number";
+                readonly minimum: 0;
+                readonly maximum: 1;
+            };
+            readonly durationMs: {
+                readonly type: "number";
+                readonly minimum: 0;
+            };
+            /** No speech followed turn.user_started for 10 s (noise, a dropped line). */
+            readonly abandoned: {
+                readonly type: "boolean";
+            };
+        };
+    };
+    readonly "turn.resumed": {
+        readonly type: "object";
+        readonly required: readonly ["type"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "turn.resumed";
+            };
+        };
+    };
+    readonly "turn.backchannel": {
+        readonly type: "object";
+        readonly required: readonly ["type", "text"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "turn.backchannel";
+            };
+            readonly text: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly "turn.estimate": {
+        readonly type: "object";
+        readonly required: readonly ["type", "eot", "speaking", "kind"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "turn.estimate";
+            };
+            readonly eot: {
+                readonly type: "number";
+                readonly minimum: 0;
+                readonly maximum: 1;
+            };
+            readonly speaking: {
+                readonly type: "boolean";
+            };
+            readonly kind: {
+                readonly enum: readonly ["speech", "backchannel", "interruption", "none"];
+            };
+        };
+    };
+    readonly "transcript.partial": {
+        readonly type: "object";
+        readonly required: readonly ["type", "text"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "transcript.partial";
+            };
+            readonly text: {
+                readonly type: "string";
+            };
+            readonly language: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly "output.started": {
+        readonly type: "object";
+        readonly required: readonly ["type", "id"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "output.started";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+        };
+    };
+    readonly "output.done": {
+        readonly type: "object";
+        readonly required: readonly ["type", "id"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "output.done";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly heardMs: {
+                readonly type: "number";
+                readonly minimum: 0;
+            };
+        };
+    };
+    readonly "output.interrupted": {
+        readonly type: "object";
+        readonly required: readonly ["type", "id", "heardText", "heardMs"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "output.interrupted";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly heardText: {
+                readonly type: "string";
+            };
+            readonly heardMs: {
+                readonly type: "number";
+                readonly minimum: 0;
+            };
+        };
+    };
+    readonly mark: {
+        readonly type: "object";
+        readonly required: readonly ["type", "name", "cleared"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "mark";
+            };
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly cleared: {
+                readonly type: "boolean";
+            };
+        };
+    };
+    readonly dtmf: {
+        readonly type: "object";
+        readonly required: readonly ["type", "digit"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "dtmf";
+            };
+            readonly digit: {
+                readonly type: "string";
+                readonly pattern: "^[0-9A-D*#]$";
+            };
+        };
+    };
+    readonly "amd.result": {
+        readonly type: "object";
+        readonly required: readonly ["type", "status", "confidence", "detector", "audioMs"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "amd.result";
+            };
+            readonly status: {
+                readonly enum: readonly ["human", "voicemail", "ivr", "machine", "unknown"];
+            };
+            readonly confidence: {
+                readonly type: "number";
+                readonly minimum: 0;
+                readonly maximum: 1;
+            };
+            readonly detector: {
+                readonly type: "string";
+            };
+            /** How much caller audio the verdict is based on, from when the caller started speaking. */
+            readonly audioMs: {
+                readonly type: "number";
+                readonly minimum: 0;
+            };
+            /** Caller audio received before speech began (unset when the caller never spoke). */
+            readonly speechOnsetMs: {
+                readonly type: "number";
+                readonly minimum: 0;
+            };
+            /** Why detection could not run (status unknown): no_audio, no_speech, no_classifier, call_ended, … */
+            readonly reason: {
+                readonly type: "string";
+            };
+        };
+    };
+};
+export declare const APP_COMMAND_SCHEMAS: {
+    readonly speak: {
+        readonly type: "object";
+        readonly required: readonly ["type", "text"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "speak";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly text: {
+                readonly type: "string";
+            };
+            readonly last: {
+                readonly type: "boolean";
+            };
+            readonly voice: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly language: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly interruptible: {
+                readonly type: "boolean";
+            };
+            readonly preempt: {
+                readonly type: "boolean";
+            };
+        };
+    };
+    readonly play: {
+        readonly type: "object";
+        readonly required: readonly ["type", "url"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "play";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly url: {
+                readonly type: "string";
+                readonly pattern: "^https?://";
+            };
+            readonly loop: {
+                readonly type: "boolean";
+            };
+            readonly interruptible: {
+                readonly type: "boolean";
+            };
+            readonly preempt: {
+                readonly type: "boolean";
+            };
+        };
+    };
+    readonly "listen.update": {
+        readonly type: "object";
+        readonly required: readonly ["type"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "listen.update";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly language: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly hints: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            /** How long the Turn Detector waits before turn.ended. */
+            readonly patience: {
+                readonly enum: readonly ["low", "normal", "high"];
+            };
+        };
+    };
+    readonly subscribe: {
+        readonly type: "object";
+        readonly required: readonly ["type", "events"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "subscribe";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly events: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+    readonly mark: {
+        readonly type: "object";
+        readonly required: readonly ["type", "name"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "mark";
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+    };
+    readonly clear: {
+        readonly type: "object";
+        readonly required: readonly ["type"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "clear";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+        };
+    };
+    readonly hangup: {
+        readonly type: "object";
+        readonly required: readonly ["type"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "hangup";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+        };
+    };
+    readonly "dtmf.send": {
+        readonly type: "object";
+        readonly required: readonly ["type", "digits"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "dtmf.send";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly digits: {
+                readonly type: "string";
+                readonly pattern: "^[0-9A-D*#w]+$";
+            };
+        };
+    };
+    readonly transfer: {
+        readonly type: "object";
+        readonly required: readonly ["type", "to"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "transfer";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly to: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly headers: {
+                readonly type: "object";
+                readonly additionalProperties: {
+                    readonly type: "string";
+                };
+            };
+            readonly mode: {
+                readonly enum: readonly ["cold", "warm", "refer"];
+            };
+            /** Warm transfers: what the caller hears while waiting. */
+            readonly music: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly "transfer.complete": {
+        readonly type: "object";
+        readonly required: readonly ["type", "id"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "transfer.complete";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+        };
+    };
+    readonly hold: {
+        readonly type: "object";
+        readonly required: readonly ["type"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "hold";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly music: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly resume: {
+        readonly type: "object";
+        readonly required: readonly ["type"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "resume";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+        };
+    };
+    readonly handoff: {
+        readonly type: "object";
+        readonly required: readonly ["type", "app"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "handoff";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly app: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly payload: {
+                readonly type: "object";
+            };
+        };
+    };
+    readonly "record.note": {
+        readonly type: "object";
+        readonly required: readonly ["type", "data"];
+        readonly properties: {
+            readonly type: {
+                readonly const: "record.note";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+            };
+            readonly data: {
+                readonly type: "object";
+            };
+        };
+    };
+};
+export type AppCommandType = keyof typeof APP_COMMAND_SCHEMAS;
+export type GatewayMessageType = keyof typeof GATEWAY_MESSAGE_SCHEMAS;
+/** The whole protocol as one JSON Schema document, as exported to schema/session.v1.json. */
+export declare function sessionProtocolDocument(): {
+    $schema: string;
+    $id: string;
+    title: string;
+    description: string;
+    protocol: string;
+    gatewayToApp: {
+        readonly "session.start": {
+            readonly type: "object";
+            readonly required: readonly ["type", "protocol", "sessionRef", "callRef", "appRef", "direction", "from", "to", "metadata", "handoff", "audio", "tracks", "speech"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "session.start";
+                };
+                readonly protocol: {
+                    readonly const: "fonoster.session.v1";
+                };
+                readonly sessionRef: {
+                    readonly type: "string";
+                };
+                readonly callRef: {
+                    readonly type: "string";
+                };
+                readonly appRef: {
+                    readonly type: "string";
+                };
+                readonly direction: {
+                    readonly enum: readonly ["inbound", "outbound"];
+                };
+                readonly from: {
+                    readonly type: "string";
+                };
+                readonly to: {
+                    readonly type: "string";
+                };
+                readonly metadata: {
+                    readonly type: "object";
+                };
+                readonly handoff: {
+                    readonly oneOf: readonly [{
+                        readonly type: "null";
+                    }, {
+                        readonly type: "object";
+                    }];
+                };
+                readonly audio: {
+                    readonly type: "object";
+                    readonly required: readonly ["codec", "rate"];
+                    readonly properties: {
+                        readonly codec: {
+                            readonly enum: readonly ["pcm16", "pcmu"];
+                        };
+                        readonly rate: {
+                            readonly enum: readonly [8000, 16000, 24000];
+                        };
+                    };
+                };
+                readonly tracks: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly required: readonly ["id", "side", "kind", "codec"];
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "integer";
+                                readonly minimum: 0;
+                                readonly maximum: 255;
+                            };
+                            readonly side: {
+                                readonly enum: readonly ["inbound", "outbound"];
+                            };
+                            readonly kind: {
+                                readonly enum: readonly ["audio"];
+                            };
+                            readonly codec: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                };
+                readonly speech: {
+                    readonly type: "object";
+                    readonly required: readonly ["voice", "language"];
+                    readonly properties: {
+                        readonly voice: {
+                            readonly type: "string";
+                        };
+                        readonly language: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+        };
+        readonly "session.end": {
+            readonly type: "object";
+            readonly required: readonly ["type", "reason"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "session.end";
+                };
+                readonly reason: {
+                    readonly enum: readonly ["caller_hangup", "app_hangup", "transfer", "handoff", "error", "timeout"];
+                };
+            };
+        };
+        readonly error: {
+            readonly type: "object";
+            readonly required: readonly ["type", "code", "message", "fatal"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "error";
+                };
+                readonly code: {
+                    readonly type: "string";
+                };
+                readonly message: {
+                    readonly type: "string";
+                };
+                readonly fatal: {
+                    readonly type: "boolean";
+                };
+                readonly relatesTo: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+            };
+        };
+        readonly "turn.user_started": {
+            readonly type: "object";
+            readonly required: readonly ["type"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "turn.user_started";
+                };
+            };
+        };
+        readonly "turn.likely_ended": {
+            readonly type: "object";
+            readonly required: readonly ["type", "text"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "turn.likely_ended";
+                };
+                readonly text: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly "turn.ended": {
+            readonly type: "object";
+            readonly required: readonly ["type", "text", "language", "confidence", "durationMs"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "turn.ended";
+                };
+                readonly text: {
+                    readonly type: "string";
+                };
+                readonly language: {
+                    readonly type: "string";
+                };
+                readonly confidence: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly maximum: 1;
+                };
+                readonly durationMs: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                /** No speech followed turn.user_started for 10 s (noise, a dropped line). */
+                readonly abandoned: {
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly "turn.resumed": {
+            readonly type: "object";
+            readonly required: readonly ["type"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "turn.resumed";
+                };
+            };
+        };
+        readonly "turn.backchannel": {
+            readonly type: "object";
+            readonly required: readonly ["type", "text"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "turn.backchannel";
+                };
+                readonly text: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly "turn.estimate": {
+            readonly type: "object";
+            readonly required: readonly ["type", "eot", "speaking", "kind"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "turn.estimate";
+                };
+                readonly eot: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly maximum: 1;
+                };
+                readonly speaking: {
+                    readonly type: "boolean";
+                };
+                readonly kind: {
+                    readonly enum: readonly ["speech", "backchannel", "interruption", "none"];
+                };
+            };
+        };
+        readonly "transcript.partial": {
+            readonly type: "object";
+            readonly required: readonly ["type", "text"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "transcript.partial";
+                };
+                readonly text: {
+                    readonly type: "string";
+                };
+                readonly language: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly "output.started": {
+            readonly type: "object";
+            readonly required: readonly ["type", "id"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "output.started";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+            };
+        };
+        readonly "output.done": {
+            readonly type: "object";
+            readonly required: readonly ["type", "id"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "output.done";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly heardMs: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+            };
+        };
+        readonly "output.interrupted": {
+            readonly type: "object";
+            readonly required: readonly ["type", "id", "heardText", "heardMs"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "output.interrupted";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly heardText: {
+                    readonly type: "string";
+                };
+                readonly heardMs: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+            };
+        };
+        readonly mark: {
+            readonly type: "object";
+            readonly required: readonly ["type", "name", "cleared"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "mark";
+                };
+                readonly name: {
+                    readonly type: "string";
+                };
+                readonly cleared: {
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly dtmf: {
+            readonly type: "object";
+            readonly required: readonly ["type", "digit"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "dtmf";
+                };
+                readonly digit: {
+                    readonly type: "string";
+                    readonly pattern: "^[0-9A-D*#]$";
+                };
+            };
+        };
+        readonly "amd.result": {
+            readonly type: "object";
+            readonly required: readonly ["type", "status", "confidence", "detector", "audioMs"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "amd.result";
+                };
+                readonly status: {
+                    readonly enum: readonly ["human", "voicemail", "ivr", "machine", "unknown"];
+                };
+                readonly confidence: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly maximum: 1;
+                };
+                readonly detector: {
+                    readonly type: "string";
+                };
+                /** How much caller audio the verdict is based on, from when the caller started speaking. */
+                readonly audioMs: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                /** Caller audio received before speech began (unset when the caller never spoke). */
+                readonly speechOnsetMs: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                /** Why detection could not run (status unknown): no_audio, no_speech, no_classifier, call_ended, … */
+                readonly reason: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+    appToGateway: {
+        readonly speak: {
+            readonly type: "object";
+            readonly required: readonly ["type", "text"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "speak";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly text: {
+                    readonly type: "string";
+                };
+                readonly last: {
+                    readonly type: "boolean";
+                };
+                readonly voice: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly language: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly interruptible: {
+                    readonly type: "boolean";
+                };
+                readonly preempt: {
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly play: {
+            readonly type: "object";
+            readonly required: readonly ["type", "url"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "play";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly url: {
+                    readonly type: "string";
+                    readonly pattern: "^https?://";
+                };
+                readonly loop: {
+                    readonly type: "boolean";
+                };
+                readonly interruptible: {
+                    readonly type: "boolean";
+                };
+                readonly preempt: {
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly "listen.update": {
+            readonly type: "object";
+            readonly required: readonly ["type"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "listen.update";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly language: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly hints: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                /** How long the Turn Detector waits before turn.ended. */
+                readonly patience: {
+                    readonly enum: readonly ["low", "normal", "high"];
+                };
+            };
+        };
+        readonly subscribe: {
+            readonly type: "object";
+            readonly required: readonly ["type", "events"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "subscribe";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly events: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        readonly mark: {
+            readonly type: "object";
+            readonly required: readonly ["type", "name"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "mark";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+        };
+        readonly clear: {
+            readonly type: "object";
+            readonly required: readonly ["type"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "clear";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+            };
+        };
+        readonly hangup: {
+            readonly type: "object";
+            readonly required: readonly ["type"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "hangup";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+            };
+        };
+        readonly "dtmf.send": {
+            readonly type: "object";
+            readonly required: readonly ["type", "digits"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "dtmf.send";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly digits: {
+                    readonly type: "string";
+                    readonly pattern: "^[0-9A-D*#w]+$";
+                };
+            };
+        };
+        readonly transfer: {
+            readonly type: "object";
+            readonly required: readonly ["type", "to"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "transfer";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly to: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly headers: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly mode: {
+                    readonly enum: readonly ["cold", "warm", "refer"];
+                };
+                /** Warm transfers: what the caller hears while waiting. */
+                readonly music: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly "transfer.complete": {
+            readonly type: "object";
+            readonly required: readonly ["type", "id"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "transfer.complete";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+            };
+        };
+        readonly hold: {
+            readonly type: "object";
+            readonly required: readonly ["type"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "hold";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly music: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly resume: {
+            readonly type: "object";
+            readonly required: readonly ["type"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "resume";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+            };
+        };
+        readonly handoff: {
+            readonly type: "object";
+            readonly required: readonly ["type", "app"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "handoff";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly app: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly payload: {
+                    readonly type: "object";
+                };
+            };
+        };
+        readonly "record.note": {
+            readonly type: "object";
+            readonly required: readonly ["type", "data"];
+            readonly properties: {
+                readonly type: {
+                    readonly const: "record.note";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly data: {
+                    readonly type: "object";
+                };
+            };
+        };
+    };
+};