@superpanel-sdk/runtime 0.2.1 → 0.2.3

package/dist/core/stage/index.js

@@ -1,9 +1,12 @@
+export { E164_NUMBER, SIP_URI, interpolateFromSnapshot, interpolateTemplate, isTransferDestinationLiteral, resolveTransferArguments, resolveTransferDestinations, resolveTransferSay, transferArgumentsJson, validateTransferDestinations, } from './transfer-spec.js';
 export { collectJsonRulesFacts, evaluateJsonRules, extractTemplateFields, isOtherwise, jsonRules, looksLikeJsonRules, normalizeJsonRules, otherwise, parseJsonRules, } from './condition.js';
 export { andCompiledWhen, compileAuthoringWhen, compileFinishWhen, compileWhen, evaluateFinishWhen, evaluateWhen, finishWhenFields, notAnyWhen, whenFields, } from './finish-when.js';
-export { action, agenda, branch, section, switchOn, topic, transfer } from './builders.js';
+export { action, agenda, branch, ivr, section, switchOn, topic, transfer } from './builders.js';
 export { extractBlocksFromTree, flattenAgendaConfig, flattenAgendaPlacements, flattenAgendaTree, isAgendaTree, isSequenceAgendas, normalizeSequenceAgendas, treeToPlacements, } from './flatten.js';
-export { LAST_TRANSFER_RESULT_FIELD, collectTransferBlocks, registerTransferSessionFields, transferFieldKey, transferResultField, } from './transfer-fields.js';
+export { CASE_LAST_TRANSFER_AT, CASE_LAST_TRANSFER_RESULT, CASE_TRANSFER_ATTEMPT_COUNT, LAST_TRANSFER_RESULT_FIELD, collectTransferBlocks, registerTransferSessionFields, transferFieldKey, transferResultField, } from './transfer-fields.js';
+export { collectIvrBlocks, ivrAttempted, ivrResultField, registerIvrSessionFields, } from './ivr-fields.js';
 export { fatalAgendaIssues, validateCompiledAgenda } from './validate.js';
+export { RESERVED_INTERRUPT_TOOL_NAMES, collectTransferInterruptHeaders, headerHasTransferInterrupt, CONTACT_LANGUAGE_FIELD, getContactLang, inboundIvrCollect, isSpokenLanguage, ivrOf, languageFieldOf, validateInterrupts, } from './interrupts.js';
 export { unresolvedFinishWhenFields, walkAgenda, } from './walk.js';
 export { simulateAgenda } from './simulate.js';
 export { DEFAULT_MAX_ACTIONS_PER_TURN, advanceAgenda, driveAgenda, transferWrites, watchdogHint, } from './drive.js';

package/dist/core/stage/interrupts.d.ts

@@ -0,0 +1,28 @@
+import type { FieldPath } from '../slot/path.js';
+import type { CompiledSlotSchema, ValidationIssue } from '../slot/types.js';
+import type { AgendaHeader, FlatAgendaItem, FlatIvrItem, Interrupt, IvrDigit, IvrFallbackAction } from './types.js';
+export type SpokenLanguage = string;
+export declare const CONTACT_LANGUAGE_FIELD: "contact.language";
+export declare const RESERVED_INTERRUPT_TOOL_NAMES: Set<string>;
+export declare function isSpokenLanguage(value: unknown): value is SpokenLanguage;
+export declare function ivrOf(items: FlatAgendaItem[] | null | undefined): FlatIvrItem | null;
+export declare function languageFieldOf(): FieldPath;
+/** Voice language. Empty / missing / non-language value → english. */
+export declare function getContactLang(readField?: (path: FieldPath) => unknown): SpokenLanguage;
+export declare function inboundIvrCollect(items: FlatAgendaItem[] | null | undefined): {
+    id: string;
+    fallbackAction: IvrFallbackAction;
+    confirmTimeoutMs: number;
+    pauseAfterSayMs: number;
+    finishOnKey?: IvrDigit | null;
+    minDigits?: number | null;
+    maxDigits?: number | null;
+    validateDigits: IvrDigit[];
+} | null;
+export declare function headerHasTransferInterrupt(header: AgendaHeader | null | undefined): boolean;
+export declare function collectTransferInterruptHeaders(headers: Array<AgendaHeader | null | undefined>): boolean;
+export declare function validateInterrupts(interrupts: Interrupt[], options: {
+    schema: CompiledSlotSchema;
+    agendaId?: string;
+}): ValidationIssue[];
+//# sourceMappingURL=interrupts.d.ts.map

package/dist/core/stage/interrupts.js

@@ -0,0 +1,120 @@
+import { getCompiledTable } from '../slot/compile-schema.js';
+import { validateTransferDestinations } from './transfer-spec.js';
+export const CONTACT_LANGUAGE_FIELD = 'contact.language';
+export const RESERVED_INTERRUPT_TOOL_NAMES = new Set(['voice_turn', 'record_opt_out', 'advance']);
+export function isSpokenLanguage(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+export function ivrOf(items) {
+    return items?.find((item) => item.kind === 'ivr') ?? null;
+}
+export function languageFieldOf() {
+    return CONTACT_LANGUAGE_FIELD;
+}
+function looksLikeSpokenLanguage(value) {
+    return isSpokenLanguage(value) && /[a-zA-Z]/.test(value);
+}
+/** Voice language. Empty / missing / non-language value → english. */
+export function getContactLang(readField) {
+    if (!readField)
+        return 'english';
+    const raw = readField(CONTACT_LANGUAGE_FIELD);
+    return looksLikeSpokenLanguage(raw) ? raw.trim() : 'english';
+}
+export function inboundIvrCollect(items) {
+    const ivr = ivrOf(items);
+    if (!ivr)
+        return null;
+    const validateDigits = (ivr.validateDigits ?? []).filter((digit) => Boolean(digit?.trim()));
+    if (!ivr.finishOnKey && validateDigits.length === 0)
+        return null;
+    return {
+        id: ivr.id,
+        fallbackAction: ivr.fallbackAction,
+        confirmTimeoutMs: ivr.confirmTimeoutMs,
+        pauseAfterSayMs: ivr.pauseAfterSayMs,
+        finishOnKey: ivr.finishOnKey,
+        minDigits: ivr.minDigits,
+        maxDigits: ivr.maxDigits,
+        validateDigits,
+    };
+}
+export function headerHasTransferInterrupt(header) {
+    return header?.interrupts.some((interrupt) => interrupt.action.type === 'transfer') ?? false;
+}
+export function collectTransferInterruptHeaders(headers) {
+    return headers.some((header) => headerHasTransferInterrupt(header));
+}
+export function validateInterrupts(interrupts, options) {
+    const issues = [];
+    const prefix = `${options.agendaId ?? 'agenda'}/header/interrupts`;
+    const names = new Set();
+    const priorities = new Set();
+    for (const interrupt of interrupts) {
+        const path = `${prefix}/${interrupt.id}`;
+        if (RESERVED_INTERRUPT_TOOL_NAMES.has(interrupt.tool.name)) {
+            issues.push({
+                code: 'interrupt-tool-reserved',
+                message: `Interrupt tool name '${interrupt.tool.name}' is reserved`,
+                path,
+            });
+        }
+        if (names.has(interrupt.tool.name)) {
+            issues.push({
+                code: 'interrupt-tool-duplicate',
+                message: `Interrupt tool name '${interrupt.tool.name}' is not unique`,
+                path,
+            });
+        }
+        names.add(interrupt.tool.name);
+        if (priorities.has(interrupt.priority)) {
+            issues.push({
+                code: 'interrupt-priority-tie',
+                message: `Interrupt priority ${interrupt.priority} is not unique`,
+                path,
+            });
+        }
+        priorities.add(interrupt.priority);
+        if (interrupt.action.type === 'switch-language') {
+            if (interrupt.action.languages.length === 0) {
+                issues.push({
+                    code: 'interrupt-languages-empty',
+                    message: 'switch-language languages must not be empty',
+                    path: `${path}/languages`,
+                });
+            }
+            if (!getCompiledTable(options.schema, 'contact')?.fields.language) {
+                issues.push({
+                    code: 'interrupt-language-field',
+                    message: `switch-language requires ${CONTACT_LANGUAGE_FIELD}`,
+                    path: `${path}/languages`,
+                });
+            }
+        }
+        if (interrupt.action.type === 'transfer') {
+            issues.push(...validateTransferDestinations(interrupt.action.numbers, {
+                path: `${path}/numbers`,
+                code: 'interrupt-transfer-number',
+            }));
+            issues.push(...validateCriteriaList(interrupt.action.escalateCriteria, `${path}/escalateCriteria`));
+            issues.push(...validateCriteriaList(interrupt.action.noEscalationCriteria, `${path}/noEscalationCriteria`));
+        }
+    }
+    return issues;
+}
+function validateCriteriaList(list, path) {
+    if (!list)
+        return [];
+    const issues = [];
+    for (let index = 0; index < list.length; index++) {
+        if (list[index]?.trim())
+            continue;
+        issues.push({
+            code: 'interrupt-escalation-criteria',
+            message: 'escalation criteria entry must not be empty',
+            path: `${path}[${index}]`,
+        });
+    }
+    return issues;
+}
+//# sourceMappingURL=interrupts.js.map

package/dist/core/stage/ivr-fields.d.ts

@@ -0,0 +1,9 @@
+import type { FieldPath } from '../slot/path.js';
+import type { CompiledSlotSchema, RuntimeSlotsSnapshot } from '../slot/types.js';
+import type { AgendaBlock, AuthoringNode, FlatIvrItem, IvrBlock } from './types.js';
+export type IvrAttemptResult = 'collected' | 'failed';
+export declare function ivrResultField(nodeId: string): FieldPath;
+export declare function ivrAttempted(item: FlatIvrItem, snapshot: RuntimeSlotsSnapshot): boolean;
+export declare function collectIvrBlocks(blocks: Record<string, AgendaBlock>, nodes?: AuthoringNode[]): IvrBlock[];
+export declare function registerIvrSessionFields(schema: CompiledSlotSchema, ivrIds: Iterable<string>): CompiledSlotSchema;
+//# sourceMappingURL=ivr-fields.d.ts.map

package/dist/core/stage/ivr-fields.js

@@ -0,0 +1,75 @@
+import { idField } from '../slot/schema.js';
+import { isResolved } from '../slot/field.js';
+import { getSingleField } from '../slot/snapshot.js';
+import { getCompiledTable } from '../slot/compile-schema.js';
+import { formatFieldPath } from '../slot/path.js';
+import { transferFieldKey } from './transfer-fields.js';
+const RESULT_ENUM = ['collected', 'failed'];
+function ivrFieldCore(label) {
+    return {
+        derived: false,
+        label,
+        dataType: 'string',
+        source: 'system',
+        extraction: 'Platform IVR result',
+        enum: [...RESULT_ENUM],
+        nullable: true,
+        identifier: null,
+        ref: null,
+    };
+}
+export function ivrResultField(nodeId) {
+    return formatFieldPath('session', `ivr_${transferFieldKey(nodeId)}_result`);
+}
+export function ivrAttempted(item, snapshot) {
+    return isResolved(getSingleField(snapshot, item.resultField));
+}
+export function collectIvrBlocks(blocks, nodes = []) {
+    const out = [];
+    const seen = new Set();
+    for (const block of Object.values(blocks)) {
+        if (block.kind === 'ivr' && !seen.has(block.id)) {
+            seen.add(block.id);
+            out.push(block);
+        }
+    }
+    visit(nodes);
+    return out;
+    function visit(list) {
+        for (const node of list) {
+            if (node.kind === 'ivr' && !seen.has(node.id)) {
+                seen.add(node.id);
+                out.push(node);
+            }
+            else if (node.kind === 'section' || node.kind === 'branch') {
+                visit(node.children);
+            }
+            else if (node.kind === 'switchOn') {
+                for (const children of Object.values(node.cases))
+                    visit(children);
+                if (node.otherwise)
+                    visit(node.otherwise);
+            }
+        }
+    }
+}
+export function registerIvrSessionFields(schema, ivrIds) {
+    const ids = [...new Set(ivrIds)];
+    if (ids.length === 0)
+        return schema;
+    const session = getCompiledTable(schema, 'session');
+    if (!session)
+        return schema;
+    const fields = { ...session.fields };
+    if (!fields.id)
+        fields.id = { ...idField, ref: null };
+    for (const id of ids) {
+        const name = `ivr_${transferFieldKey(id)}_result`;
+        if (!fields[name]) {
+            fields[name] = ivrFieldCore(`IVR ${id} result`);
+        }
+    }
+    const nextSession = { ...session, fields };
+    return { ...schema, session: nextSession };
+}
+//# sourceMappingURL=ivr-fields.js.map

package/dist/core/stage/transfer-fields.d.ts

@@ -5,10 +5,15 @@ import type { AgendaBlock, AuthoringNode, TransferBlock } from './types.js';
 export declare function transferFieldKey(nodeId: string): string;
 export declare function transferResultField(nodeId: string): FieldPath;
 export declare const LAST_TRANSFER_RESULT_FIELD: `${string}.${string}`;
+export declare const CASE_TRANSFER_ATTEMPT_COUNT: `${string}.${string}`;
+export declare const CASE_LAST_TRANSFER_RESULT: `${string}.${string}`;
+export declare const CASE_LAST_TRANSFER_AT: `${string}.${string}`;
 export declare function collectTransferBlocks(blocks: Record<string, AgendaBlock>, nodes?: AuthoringNode[]): TransferBlock[];
 /**
  * Register per-node `session.transfer_<id>_result` and `session.last_transfer_result`.
  * Existing session fields with the same name are left untouched.
  */
-export declare function registerTransferSessionFields(schema: CompiledSlotSchema, transferIds: Iterable<string>): CompiledSlotSchema;
+export declare function registerTransferSessionFields(schema: CompiledSlotSchema, transferIds: Iterable<string>, options?: {
+    lastResult?: boolean;
+}): CompiledSlotSchema;
 //# sourceMappingURL=transfer-fields.d.ts.map

package/dist/core/stage/transfer-fields.js

@@ -24,6 +24,9 @@ export function transferResultField(nodeId) {
     return formatFieldPath('session', `transfer_${transferFieldKey(nodeId)}_result`);
 }
 export const LAST_TRANSFER_RESULT_FIELD = formatFieldPath('session', 'last_transfer_result');
+export const CASE_TRANSFER_ATTEMPT_COUNT = formatFieldPath('case_file', 'transfer_attempt_count');
+export const CASE_LAST_TRANSFER_RESULT = formatFieldPath('case_file', 'last_transfer_result');
+export const CASE_LAST_TRANSFER_AT = formatFieldPath('case_file', 'last_transfer_at');
 export function collectTransferBlocks(blocks, nodes = []) {
     const out = [];
     const seen = new Set();
@@ -57,9 +60,9 @@ export function collectTransferBlocks(blocks, nodes = []) {
  * Register per-node `session.transfer_<id>_result` and `session.last_transfer_result`.
  * Existing session fields with the same name are left untouched.
  */
-export function registerTransferSessionFields(schema, transferIds) {
+export function registerTransferSessionFields(schema, transferIds, options) {
     const ids = [...new Set(transferIds)];
-    if (ids.length === 0)
+    if (ids.length === 0 && !options?.lastResult)
         return schema;
     const session = getCompiledTable(schema, 'session');
     if (!session)
@@ -73,16 +76,54 @@ export function registerTransferSessionFields(schema, transferIds) {
             fields[name] = transferFieldCore(`Transfer ${id} result`);
         }
     }
-    if (!fields.last_transfer_result) {
+    if ((ids.length > 0 || options?.lastResult) && !fields.last_transfer_result) {
         fields.last_transfer_result = transferFieldCore('Last transfer result');
     }
     const nextSession = {
         ...session,
         fields,
     };
+    const caseFile = getCompiledTable(schema, 'case_file');
+    let nextCase = caseFile;
+    if (caseFile && (ids.length > 0 || options?.lastResult)) {
+        const caseFields = { ...caseFile.fields };
+        if (!caseFields.id)
+            caseFields.id = { ...idField, ref: null };
+        if (!caseFields.transfer_attempt_count) {
+            caseFields.transfer_attempt_count = {
+                derived: false,
+                label: 'Transfer attempt count',
+                dataType: 'number',
+                source: 'system',
+                extraction: 'Platform transfer attempt count',
+                enum: null,
+                nullable: true,
+                identifier: null,
+                ref: null,
+            };
+        }
+        if (!caseFields.last_transfer_result) {
+            caseFields.last_transfer_result = transferFieldCore('Case last transfer result');
+        }
+        if (!caseFields.last_transfer_at) {
+            caseFields.last_transfer_at = {
+                derived: false,
+                label: 'Last transfer at',
+                dataType: 'datetime',
+                source: 'system',
+                extraction: 'Platform last transfer time',
+                enum: null,
+                nullable: true,
+                identifier: null,
+                ref: null,
+            };
+        }
+        nextCase = { ...caseFile, fields: caseFields };
+    }
     return {
         ...schema,
         session: nextSession,
+        ...(nextCase ? { case_file: nextCase } : {}),
     };
 }
 //# sourceMappingURL=transfer-fields.js.map

package/dist/core/stage/transfer-spec.d.ts

@@ -0,0 +1,48 @@
+import type { FieldPath } from '../slot/path.js';
+import type { RuntimeSlotsSnapshot, ValidationIssue } from '../slot/types.js';
+export type TransferMode = 'cold' | 'warm' | 'async-warm';
+export type TransferCallerIdShown = 'client' | 'service';
+export type TransferConfirmMethod = 'keypad' | 'llm';
+export type TransferConfirmKey = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '*' | '#';
+export type TransferSay = string | Record<string, string>;
+export type TransferFallbackAction = 'end-call' | 'restore-normal-call-state';
+/** mars-voice-service `TransferCallArgs`. String fields may contain `{{table.field}}`. */
+export type TransferArguments = {
+    sendDigits?: string;
+    sipUrl?: string;
+    sipUsername?: string;
+    sipPassword?: string;
+    transferCallerIdShown?: TransferCallerIdShown;
+};
+/** Shared dial config for agenda transfer nodes and interrupt transfer actions. */
+export type TransferDial = {
+    numbers: string[];
+    mode: TransferMode;
+    say?: TransferSay | null;
+    unsuccessfulSay?: TransferSay | null;
+    fallbackAction?: TransferFallbackAction | null;
+    arguments?: TransferArguments | null;
+    warmConfirmMode?: TransferConfirmMethod[] | null;
+    warmConfirmKeypad?: TransferConfirmKey | null;
+    warmConfirmTimeoutMs?: number | null;
+    warmLoopSay?: string | null;
+    warmBriefingPrompt?: string | null;
+    asyncWarmBridge?: {
+        targetSayTemplate?: string;
+        customerSayTemplate?: string;
+    } | null;
+};
+export declare const E164_NUMBER: RegExp;
+export declare const SIP_URI: RegExp;
+export declare function isTransferDestinationLiteral(value: string): boolean;
+export declare function interpolateTemplate(text: string, read: (path: FieldPath) => string | number | boolean | null | undefined): string;
+export declare function interpolateFromSnapshot(text: string, snapshot: RuntimeSlotsSnapshot): string;
+export declare function resolveTransferDestinations(numbers: string[], snapshot: RuntimeSlotsSnapshot): string[];
+export declare function resolveTransferSay(say: TransferSay | null | undefined, language: string | null | undefined, fallback: string): string;
+export declare function resolveTransferArguments(dial: TransferDial, snapshot: RuntimeSlotsSnapshot): TransferArguments;
+export declare function transferArgumentsJson(dial: TransferDial, snapshot: RuntimeSlotsSnapshot): string;
+export declare function validateTransferDestinations(numbers: string[], options: {
+    path: string;
+    code: string;
+}): ValidationIssue[];
+//# sourceMappingURL=transfer-spec.d.ts.map

package/dist/core/stage/transfer-spec.js

@@ -0,0 +1,113 @@
+import { parseFieldPath } from '../slot/path.js';
+import { getRowField } from '../slot/row.js';
+import { getSnapshotTable } from '../slot/snapshot.js';
+import { extractTemplateFields } from './condition.js';
+export const E164_NUMBER = /^\+[1-9]\d{7,14}$/;
+export const SIP_URI = /^sips?:[^@\s]+@[^@\s]+$/i;
+const TEMPLATE_RE = /\{\{\s*([A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
+export function isTransferDestinationLiteral(value) {
+    return E164_NUMBER.test(value) || SIP_URI.test(value);
+}
+export function interpolateTemplate(text, read) {
+    return text.replace(TEMPLATE_RE, (_all, path) => {
+        const value = read(path);
+        return value == null ? '' : String(value);
+    });
+}
+function boundRowId(tableName, current) {
+    if (!current)
+        return undefined;
+    if (tableName === 'contact')
+        return current.contactId;
+    if (tableName === 'case_contact')
+        return current.caseContactId;
+    if (tableName === 'case_file')
+        return current.caseFileId;
+    return undefined;
+}
+export function interpolateFromSnapshot(text, snapshot) {
+    return interpolateTemplate(text, (path) => {
+        const parsed = parseFieldPath(path);
+        if (!parsed)
+            return '';
+        const data = getSnapshotTable(snapshot, parsed.table);
+        if (!data)
+            return '';
+        if (!Array.isArray(data))
+            return getRowField(data, parsed.field)?.value ?? '';
+        const id = boundRowId(parsed.table, snapshot.current);
+        if (!id)
+            return '';
+        const row = data.find((entry) => entry.id === id);
+        return row ? (getRowField(row, parsed.field)?.value ?? '') : '';
+    });
+}
+export function resolveTransferDestinations(numbers, snapshot) {
+    const out = [];
+    for (const raw of numbers) {
+        const resolved = interpolateFromSnapshot(raw, snapshot).trim();
+        if (resolved)
+            out.push(resolved);
+    }
+    return out;
+}
+export function resolveTransferSay(say, language, fallback) {
+    if (say == null)
+        return fallback;
+    if (typeof say === 'string')
+        return say.trim() || fallback;
+    const key = language?.trim().toLowerCase() || 'english';
+    const picked = say[key] ?? say.english ?? Object.values(say).find((value) => value.trim().length > 0);
+    return picked?.trim() || fallback;
+}
+function interpolatedArg(value, snapshot) {
+    return value ? interpolateFromSnapshot(value, snapshot).trim() : '';
+}
+export function resolveTransferArguments(dial, snapshot) {
+    const src = dial.arguments;
+    if (!src)
+        return {};
+    const out = {};
+    const sendDigits = interpolatedArg(src.sendDigits, snapshot);
+    if (sendDigits)
+        out.sendDigits = sendDigits;
+    const sipUrl = interpolatedArg(src.sipUrl, snapshot);
+    if (sipUrl)
+        out.sipUrl = sipUrl;
+    const sipUsername = interpolatedArg(src.sipUsername, snapshot);
+    if (sipUsername)
+        out.sipUsername = sipUsername;
+    const sipPassword = interpolatedArg(src.sipPassword, snapshot);
+    if (sipPassword)
+        out.sipPassword = sipPassword;
+    if (src.transferCallerIdShown)
+        out.transferCallerIdShown = src.transferCallerIdShown;
+    return out;
+}
+export function transferArgumentsJson(dial, snapshot) {
+    return JSON.stringify(resolveTransferArguments(dial, snapshot));
+}
+export function validateTransferDestinations(numbers, options) {
+    const issues = [];
+    if (numbers.length === 0) {
+        issues.push({
+            code: options.code,
+            message: 'transfer numbers must not be empty',
+            path: options.path,
+        });
+        return issues;
+    }
+    for (const number of numbers) {
+        if (extractTemplateFields(number).length > 0)
+            continue;
+        if (!isTransferDestinationLiteral(number)) {
+            issues.push({
+                code: options.code,
+                message: `Transfer target must be E.164 or sip/sips URI: ${number}`,
+                path: options.path,
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=transfer-spec.js.map

package/dist/core/stage/types.d.ts

@@ -1,6 +1,7 @@
 import type { TopLevelCondition } from 'json-rules-engine';
 import type { FuncRef } from '../functions/func-ref.js';
 import type { FieldPath } from '../slot/path.js';
+import type { TransferDial, TransferFallbackAction } from './transfer-spec.js';
 export type Channel = 'call' | 'sms' | 'email' | 'webchat';
 /** Nested condition from the engine (`all` members): leaf or `TopLevelCondition`. */
 export type Condition = Extract<TopLevelCondition, {
@@ -40,6 +41,11 @@ export type FirstMessage = {
     kind: 'fn';
     fn: string;
 };
+export type TransferInterruptAction = {
+    type: 'transfer';
+    escalateCriteria?: string[];
+    noEscalationCriteria?: string[];
+} & TransferDial;
 export type Interrupt = {
     id: string;
     label: string;
@@ -47,11 +53,7 @@ export type Interrupt = {
         name: string;
         description: string;
     };
-    action: {
-        type: 'transfer';
-        numbers: string[];
-        mode: 'cold' | 'warm';
-    } | {
+    action: TransferInterruptAction | {
         type: 'switch-language';
         languages: string[];
     };
@@ -86,12 +88,32 @@ export type TransferBlock = {
     kind: 'transfer';
     id: string;
     label: string;
-    numbers: string[];
-    mode: 'cold' | 'warm';
-    say: string;
-    unsuccessfulSay: string | null;
-};
-export type AgendaBlock = TopicBlock | ActionBlock | TransferBlock;
+} & TransferDial;
+export type IvrDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '*' | '#';
+export type IvrFallbackAction = TransferFallbackAction;
+export type DtmfResult = {
+    result: IvrDigit[];
+    value: string;
+};
+export type IvrBlock = {
+    kind: 'ivr';
+    id: string;
+    label: string;
+    onDtmfResult: FuncRef;
+    finishWhen: FinishWhen;
+    fallbackAction: IvrFallbackAction;
+    confirmTimeoutMs: number;
+    pauseAfterSayMs: number;
+    loopSay: string;
+    enterSay: string | null;
+    succeedSay: string | null;
+    unsuccessSay: string | null;
+    finishOnKey?: IvrDigit | null;
+    minDigits?: number | null;
+    maxDigits?: number | null;
+    validateDigits?: IvrDigit[] | null;
+};
+export type AgendaBlock = TopicBlock | ActionBlock | TransferBlock | IvrBlock;
 export type CompiledTopicBlock = Omit<TopicBlock, 'fields' | 'finishWhen'> & {
     fields: FieldPath[];
     finishWhen: CompiledWhen;
@@ -104,7 +126,12 @@ export type CompiledTransferBlock = TransferBlock & {
     finishWhen: CompiledWhen;
     resultField: FieldPath;
 };
-export type CompiledAgendaBlock = CompiledTopicBlock | CompiledActionBlock | CompiledTransferBlock;
+export type CompiledIvrBlock = Omit<IvrBlock, 'onDtmfResult' | 'finishWhen'> & {
+    onDtmfResult: string;
+    finishWhen: CompiledWhen;
+    resultField: FieldPath;
+};
+export type CompiledAgendaBlock = CompiledTopicBlock | CompiledActionBlock | CompiledTransferBlock | CompiledIvrBlock;
 export type SectionPlacement = {
     kind: 'section';
     placementId: string;
@@ -136,7 +163,8 @@ export type FlatNodePlacement = {
 export type FlatTopicItem = CompiledTopicBlock & FlatNodePlacement;
 export type FlatActionItem = CompiledActionBlock & FlatNodePlacement;
 export type FlatTransferItem = CompiledTransferBlock & FlatNodePlacement;
-export type FlatAgendaItem = FlatTopicItem | FlatActionItem | FlatTransferItem;
+export type FlatIvrItem = CompiledIvrBlock & FlatNodePlacement;
+export type FlatAgendaItem = FlatTopicItem | FlatActionItem | FlatTransferItem | FlatIvrItem;
 export type CompiledAgenda = {
     header: AgendaHeader | null;
     flat: FlatAgendaItem[];
@@ -150,6 +178,9 @@ export type ActionNode = ActionBlock & {
 export type TransferNode = TransferBlock & {
     applyWhen: AuthoringWhen;
 };
+export type IvrNode = IvrBlock & {
+    applyWhen: AuthoringWhen;
+};
 export type SectionNode = {
     kind: 'section';
     id: string;
@@ -167,7 +198,7 @@ export type SwitchOnNode = {
     cases: Record<string, AuthoringNode[]>;
     otherwise?: AuthoringNode[];
 };
-export type AuthoringNode = TopicNode | ActionNode | TransferNode | SectionNode | BranchNode | SwitchOnNode;
+export type AuthoringNode = TopicNode | ActionNode | TransferNode | IvrNode | SectionNode | BranchNode | SwitchOnNode;
 export type AgendaTree = {
     kind: 'agenda';
     id: string;