@superpanel-sdk/runtime 0.2.3 → 0.5.0

package/dist/core/slot/snapshot.js

@@ -1,138 +0,0 @@
-import { compiledTableEntries, getCompiledTable, isSnapshotSingleRow } from './compile-schema.js';
-import { emptyFieldValue, makeFieldValue } from './field.js';
-import { parseFieldPath } from './path.js';
-import { emptySlotRow, getRowField, isReservedTableName, isRowIdField, slotFieldNames } from './row.js';
-import { validateBareValue } from './value.js';
-function seedToFieldValue(seed, now) {
-    if (seed && typeof seed === 'object' && !Array.isArray(seed) && 'state' in seed) {
-        const s = seed;
-        return makeFieldValue({
-            value: (s.value ?? null),
-            state: s.state,
-            reason: s.reason ?? null,
-            updatedBy: s.updatedBy ?? 'import',
-            updatedAt: s.updatedAt ?? now,
-            history: s.history ?? [],
-        });
-    }
-    if (seed === undefined) {
-        return emptyFieldValue(now);
-    }
-    return makeFieldValue({
-        value: seed,
-        state: 'filled',
-        reason: null,
-        updatedBy: 'import',
-        updatedAt: now,
-    });
-}
-/**
- * Build a runtime snapshot for local tests.
- *
- * - `table.field` keys seed single-row (or current-party) fields
- * - bare multi-table name keys seed row arrays:
- *   `children: [{ id?: string, name: 'Lily', age: 8 }]`
- */
-export function snapshotFrom(schema, seed = {}, options = {}) {
-    const now = options.now ?? 0;
-    const snapshot = {};
-    for (const [tableName, table] of compiledTableEntries(schema)) {
-        if (isSnapshotSingleRow(table)) {
-            snapshot[tableName] = emptySlotRow(table.fields, { now });
-        }
-        else {
-            snapshot[tableName] = [];
-        }
-    }
-    for (const [key, value] of Object.entries(seed)) {
-        const parsed = parseFieldPath(key);
-        if (parsed) {
-            const table = getCompiledTable(schema, parsed.table);
-            if (!table) {
-                throw new Error(`Unknown table in seed: ${parsed.table}`);
-            }
-            if (!isSnapshotSingleRow(table)) {
-                throw new Error(`Field path seed ${key} is only for single-row tables; seed multi rows by table name`);
-            }
-            if (isRowIdField(parsed.field)) {
-                snapshot[parsed.table].id = value == null ? '' : String(value);
-                continue;
-            }
-            const field = table.fields[parsed.field];
-            if (!field) {
-                throw new Error(`Unknown field in seed: ${key}`);
-            }
-            const fv = seedToFieldValue(value, now);
-            if (fv.state === 'filled' || fv.state === 'asked_unknown') {
-                const issues = validateBareValue(field, fv.value, key, {
-                    allowNull: field.derived || (field.derived === false && field.nullable),
-                });
-                if (issues.length > 0) {
-                    throw new Error(issues.map((i) => i.message).join('; '));
-                }
-            }
-            snapshot[parsed.table][parsed.field] = fv;
-            continue;
-        }
-        const table = getCompiledTable(schema, key);
-        if (!table) {
-            throw new Error(`Unknown seed key: ${key}`);
-        }
-        if (isSnapshotSingleRow(table)) {
-            throw new Error(`Seed key ${key} is not a multi-row table`);
-        }
-        if (!Array.isArray(value)) {
-            throw new Error(`Multi-row seed ${key} must be an array`);
-        }
-        const rows = [];
-        let i = 0;
-        for (const rowSeed of value) {
-            if (!rowSeed || typeof rowSeed !== 'object') {
-                throw new Error(`Invalid row seed in ${key}`);
-            }
-            const rowObj = rowSeed;
-            const seededId = rowObj.id ?? rowObj.rowId;
-            const id = typeof seededId === 'string' && seededId.length > 0 ? seededId : `r${++i}`;
-            const row = { id };
-            for (const fieldName of slotFieldNames(table.fields)) {
-                if (fieldName in rowObj) {
-                    row[fieldName] = seedToFieldValue(rowObj[fieldName], now);
-                }
-                else {
-                    row[fieldName] = emptyFieldValue(now);
-                }
-            }
-            rows.push(row);
-        }
-        snapshot[key] = rows;
-    }
-    return snapshot;
-}
-/** Deep-clone a snapshot (structuredClone when available). */
-export function cloneSnapshot(snapshot) {
-    return typeof structuredClone === 'function'
-        ? structuredClone(snapshot)
-        : JSON.parse(JSON.stringify(snapshot));
-}
-export function getSnapshotTable(snapshot, tableName) {
-    if (isReservedTableName(tableName))
-        return undefined;
-    const value = snapshot[tableName];
-    if (value == null)
-        return undefined;
-    if (Array.isArray(value))
-        return value;
-    if (typeof value === 'object' && 'id' in value)
-        return value;
-    return undefined;
-}
-export function getSingleField(snapshot, path) {
-    const parsed = parseFieldPath(path);
-    if (!parsed)
-        return undefined;
-    const table = getSnapshotTable(snapshot, parsed.table);
-    if (!table || Array.isArray(table))
-        return undefined;
-    return getRowField(table, parsed.field);
-}
-//# sourceMappingURL=snapshot.js.map

package/dist/core/slot/write.d.ts

@@ -1,48 +0,0 @@
-import type { FieldState, FieldWrites, RowWrite, StructuredWrites, Writes } from '../context/types.js';
-import type { FieldPath } from './path.js';
-import type { ApplyWritesOptions, ApplyWritesResult, CompiledSlotSchema, RuntimeSlotsSnapshot, SlotFillingOutput, UpdatedBy } from './types.js';
-export declare function isRowWrite(value: unknown): value is RowWrite;
-export declare function isStructuredWrites(value: unknown): value is StructuredWrites;
-export declare function normalizeWrites(writes: Writes | null | undefined): {
-    fields: FieldWrites;
-    rows: RowWrite[];
-} | null;
-/**
- * Apply bare Writes (function / human / import / platform) onto a snapshot.
- * Validates type/enum and write permissions. Detects C5 changes and appends history.
- * Multi-row tables: pass `{ table, rowId, values }` (or `rows` on StructuredWrites).
- */
-export declare function applyWrites(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, writes: Writes | null | undefined, options: ApplyWritesOptions): ApplyWritesResult;
-export type FieldPatchInput = {
-    path: FieldPath;
-    rowId?: string;
-    value: string | number | boolean | null;
-    state: FieldState;
-    reason?: string | null;
-};
-/**
- * Apply one human/admin field edit, including explicit slot state.
- * Unlike bare writes, this supports a selected row in a multi-row entity table.
- */
-export declare function applyFieldPatch(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, patch: FieldPatchInput, options: {
-    source: UpdatedBy;
-    now?: number;
-}): ApplyWritesResult;
-export type ApplySlotFillingOptions = {
-    now?: number;
-    /** Map SF placeholder row keys (`new-1`) → allocated row ids (mutated in place). */
-    rowKeyMap?: Map<string, string>;
-};
-/**
- * C4: apply accepted Slot Filling projection (full replace for present fields/rows).
- * Multi-row: projection is the full set of rows; omitted existing rows are deleted.
- */
-export declare function applySlotFilling(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, output: SlotFillingOutput, options?: ApplySlotFillingOptions): ApplyWritesResult;
-/**
- * Mark remaining conversation fields as asked_unknown (Topic move-on).
- */
-export declare function markAskedUnknown(schema: CompiledSlotSchema, snapshot: RuntimeSlotsSnapshot, fields: Iterable<FieldPath>, options?: {
-    now?: number;
-    reason?: string;
-}): ApplyWritesResult;
-//# sourceMappingURL=write.d.ts.map

package/dist/core/slot/write.js

@@ -1,426 +0,0 @@
-import { getCompiledTable, isSnapshotSingleRow } from './compile-schema.js';
-import { commitFieldWrite, makeFieldValue } from './field.js';
-import { formatFieldPath, parseFieldPath, requireFieldPath } from './path.js';
-import { getRowField, isReservedTableName, isRowIdField, mintRowId, slotFieldNames } from './row.js';
-import { cloneSnapshot, getSnapshotTable } from './snapshot.js';
-import { validateBareValue, validateExtractedField } from './value.js';
-export function isRowWrite(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const o = value;
-    return (typeof o.table === 'string' &&
-        typeof o.rowId === 'string' &&
-        o.values !== null &&
-        typeof o.values === 'object' &&
-        !Array.isArray(o.values));
-}
-export function isStructuredWrites(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value) || isRowWrite(value))
-        return false;
-    const keys = Object.keys(value);
-    return keys.length > 0 && keys.every((key) => key === 'fields' || key === 'rows');
-}
-export function normalizeWrites(writes) {
-    if (writes == null)
-        return null;
-    if (isRowWrite(writes)) {
-        return { fields: {}, rows: [writes] };
-    }
-    if (isStructuredWrites(writes)) {
-        const fields = writes.fields && typeof writes.fields === 'object' && !Array.isArray(writes.fields) ? writes.fields : {};
-        const rows = Array.isArray(writes.rows) ? writes.rows.filter(isRowWrite) : [];
-        if (Object.keys(fields).length === 0 && rows.length === 0)
-            return null;
-        return { fields, rows };
-    }
-    if (Object.keys(writes).length === 0)
-        return null;
-    return { fields: writes, rows: [] };
-}
-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;
-}
-function writeTargetRow(schema, snapshot, tableName, rowId) {
-    const table = getCompiledTable(schema, tableName);
-    if (!table)
-        return null;
-    const data = getSnapshotTable(snapshot, tableName);
-    if (!data)
-        return null;
-    if (isSnapshotSingleRow(table) && !Array.isArray(data)) {
-        if (rowId && data.id && data.id !== rowId)
-            return null;
-        return data;
-    }
-    if (Array.isArray(data)) {
-        const id = rowId ?? boundRowId(tableName, snapshot.current);
-        if (!id)
-            return null;
-        return data.find((row) => row.id === id) ?? null;
-    }
-    return null;
-}
-function extractedToFieldValue(extracted, updatedBy, now) {
-    return makeFieldValue({
-        reason: extracted.reason,
-        value: extracted.value,
-        state: extracted.state,
-        updatedBy,
-        updatedAt: now,
-    });
-}
-function assertWritableNormal(schema, snapshot, path, options, rowId) {
-    const { table, field: fieldName } = requireFieldPath(path);
-    const tableDef = getCompiledTable(schema, table);
-    const field = tableDef?.fields[fieldName];
-    if (!tableDef || !field) {
-        return [{ code: 'unknown-field', message: `Unknown field: ${path}`, path }];
-    }
-    if (isRowIdField(fieldName)) {
-        return [
-            {
-                code: 'id-readonly',
-                message: `Cannot write row id: ${path}`,
-                path,
-            },
-        ];
-    }
-    if (field.derived) {
-        return [
-            {
-                code: 'derived-readonly',
-                message: `Cannot write derived field: ${path}`,
-                path,
-            },
-        ];
-    }
-    const systemOnly = options.systemOnly ??
-        (options.source === 'function' || options.source === 'platform' || options.source === 'import');
-    if (systemOnly && field.source !== 'system') {
-        return [
-            {
-                code: 'write-forbidden',
-                message: `Source ${options.source} cannot write conversation field ${path}`,
-                path,
-            },
-        ];
-    }
-    if (!isSnapshotSingleRow(tableDef) && !writeTargetRow(schema, snapshot, table, rowId)) {
-        return [
-            {
-                code: rowId ? 'row-not-found' : 'multi-path-write',
-                message: rowId
-                    ? `Row ${rowId} not found in ${table}`
-                    : `Use Slot Filling or { table, rowId, values } to write multi-row field ${path}`,
-                path,
-            },
-        ];
-    }
-    return [];
-}
-function applyBareFieldWrite(schema, original, next, path, value, rowId, options, now, errors, changed, history) {
-    const writeIssues = assertWritableNormal(schema, original, path, options, rowId);
-    if (writeIssues.length > 0) {
-        errors.push(...writeIssues);
-        return;
-    }
-    const parsed = parseFieldPath(path);
-    if (!parsed) {
-        errors.push({ code: 'unknown-field', message: `Invalid field path: ${path}`, path });
-        return;
-    }
-    const field = getCompiledTable(schema, parsed.table)?.fields[parsed.field];
-    if (!field) {
-        errors.push({ code: 'unknown-field', message: `Unknown field: ${path}`, path });
-        return;
-    }
-    const valueIssues = validateBareValue(field, value, path, {
-        allowNull: !field.derived && field.nullable,
-    });
-    if (valueIssues.length > 0) {
-        errors.push(...valueIssues);
-        return;
-    }
-    const tableData = writeTargetRow(schema, next, parsed.table, rowId);
-    if (!tableData)
-        return;
-    const prev = getRowField(tableData, parsed.field);
-    if (!prev)
-        return;
-    const committed = commitFieldWrite(prev, makeFieldValue({
-        value: (value ?? null),
-        state: 'filled',
-        reason: null,
-        updatedBy: options.source,
-        updatedAt: now,
-    }));
-    tableData[parsed.field] = committed.field;
-    if (committed.changed) {
-        changed.push(parsed.path);
-        if (committed.historyEntry) {
-            history.push({
-                path: parsed.path,
-                entry: committed.historyEntry,
-                rowId: typeof tableData.id === 'string' && tableData.id ? tableData.id : undefined,
-            });
-        }
-    }
-}
-/**
- * Apply bare Writes (function / human / import / platform) onto a snapshot.
- * Validates type/enum and write permissions. Detects C5 changes and appends history.
- * Multi-row tables: pass `{ table, rowId, values }` (or `rows` on StructuredWrites).
- */
-export function applyWrites(schema, snapshot, writes, options) {
-    const normalized = normalizeWrites(writes);
-    if (!normalized) {
-        return { snapshot, changed: [], history: [] };
-    }
-    const now = options.now ?? Date.now();
-    const next = cloneSnapshot(snapshot);
-    const changed = [];
-    const history = [];
-    const errors = [];
-    for (const [path, value] of Object.entries(normalized.fields)) {
-        applyBareFieldWrite(schema, snapshot, next, path, value, undefined, options, now, errors, changed, history);
-    }
-    for (const row of normalized.rows) {
-        if (!row.table || !row.rowId) {
-            errors.push({
-                code: 'row-not-found',
-                message: 'Row write requires table and rowId',
-                path: row.table || undefined,
-            });
-            continue;
-        }
-        for (const [fieldName, value] of Object.entries(row.values)) {
-            const path = formatFieldPath(row.table, fieldName);
-            applyBareFieldWrite(schema, snapshot, next, path, value, row.rowId, options, now, errors, changed, history);
-        }
-    }
-    if (errors.length > 0) {
-        throw new Error(`applyWrites failed:\n${errors.map((e) => `- ${e.path ?? ''}: ${e.message}`).join('\n')}`);
-    }
-    return { snapshot: next, changed, history };
-}
-/**
- * Apply one human/admin field edit, including explicit slot state.
- * Unlike bare writes, this supports a selected row in a multi-row entity table.
- */
-export function applyFieldPatch(schema, snapshot, patch, options) {
-    const parsed = requireFieldPath(patch.path);
-    const table = getCompiledTable(schema, parsed.table);
-    const field = table?.fields[parsed.field];
-    if (!table || !field)
-        throw new Error(`Unknown field: ${patch.path}`);
-    if (isRowIdField(parsed.field))
-        throw new Error(`Cannot write row id: ${patch.path}`);
-    if (field.derived)
-        throw new Error(`Cannot write derived field: ${patch.path}`);
-    const value = patch.state === 'filled' ? patch.value : null;
-    if (patch.state !== 'empty') {
-        const issues = validateExtractedField(field, {
-            value,
-            state: patch.state,
-            reason: patch.reason ?? 'Human edit',
-        }, patch.path);
-        if (issues.length > 0) {
-            throw new Error(`applyFieldPatch failed:\n${issues.map((issue) => `- ${issue.path ?? ''}: ${issue.message}`).join('\n')}`);
-        }
-    }
-    const now = options.now ?? Date.now();
-    const next = cloneSnapshot(snapshot);
-    const data = getSnapshotTable(next, parsed.table);
-    const row = isSnapshotSingleRow(table)
-        ? data
-        : data?.find((candidate) => candidate.id === patch.rowId);
-    if (!row)
-        throw new Error(`Slot row not found: ${parsed.table}:${patch.rowId ?? 'single'}`);
-    const previous = getRowField(row, parsed.field);
-    if (!previous)
-        throw new Error(`Slot field not initialized: ${patch.path}`);
-    const committed = commitFieldWrite(previous, makeFieldValue({
-        value,
-        state: patch.state,
-        reason: patch.reason ?? 'Human edit',
-        updatedBy: options.source,
-        updatedAt: now,
-    }));
-    row[parsed.field] = committed.field;
-    if (!committed.changed)
-        return { snapshot: next, changed: [], history: [] };
-    return {
-        snapshot: next,
-        changed: [parsed.path],
-        history: committed.historyEntry ? [{ path: parsed.path, entry: committed.historyEntry }] : [],
-    };
-}
-/**
- * C4: apply accepted Slot Filling projection (full replace for present fields/rows).
- * Multi-row: projection is the full set of rows; omitted existing rows are deleted.
- */
-export function applySlotFilling(schema, snapshot, output, options = {}) {
-    const now = options.now ?? Date.now();
-    const next = cloneSnapshot(snapshot);
-    const changed = new Set();
-    const history = [];
-    const rowKeyMap = options.rowKeyMap ?? new Map();
-    for (const [tableName, projection] of Object.entries(output)) {
-        if (isReservedTableName(tableName))
-            continue;
-        const table = getCompiledTable(schema, tableName);
-        if (!table)
-            continue;
-        if (isSnapshotSingleRow(table)) {
-            const tableData = getSnapshotTable(next, tableName);
-            for (const [fieldName, extracted] of Object.entries(projection)) {
-                const field = table.fields[fieldName];
-                if (!field || field.derived || field.source !== 'conversation')
-                    continue;
-                const path = formatFieldPath(tableName, fieldName);
-                const issues = validateExtractedField(field, extracted, path);
-                if (issues.length > 0) {
-                    throw new Error(issues.map((i) => i.message).join('; '));
-                }
-                if (isRowIdField(fieldName))
-                    continue;
-                const prev = getRowField(tableData, fieldName);
-                if (!prev)
-                    continue;
-                const committed = commitFieldWrite(prev, extractedToFieldValue(extracted, 'slot-filling', now));
-                tableData[fieldName] = committed.field;
-                if (committed.changed) {
-                    changed.add(path);
-                    if (committed.historyEntry) {
-                        history.push({
-                            path,
-                            entry: committed.historyEntry,
-                            rowId: typeof tableData.id === 'string' && tableData.id ? tableData.id : undefined,
-                        });
-                    }
-                }
-            }
-        }
-        else {
-            const prevRows = getSnapshotTable(snapshot, tableName) ?? [];
-            const prevById = new Map(prevRows.map((r) => [r.id, r]));
-            const projectionRows = projection;
-            const nextRows = [];
-            let structuralChange = false;
-            for (const row of projectionRows) {
-                let id = row.rowKey;
-                if (row.rowKey.startsWith('new-')) {
-                    id = rowKeyMap.get(row.rowKey) ?? mintRowId();
-                    rowKeyMap.set(row.rowKey, id);
-                    structuralChange = true;
-                }
-                else if (!prevById.has(row.rowKey)) {
-                    structuralChange = true;
-                }
-                const prevRow = prevById.get(id);
-                const nextRow = { id };
-                for (const fieldName of slotFieldNames(table.fields)) {
-                    const field = table.fields[fieldName];
-                    if (field.derived)
-                        continue;
-                    const extracted = row.fields[fieldName];
-                    const prevFv = prevRow ? getRowField(prevRow, fieldName) : undefined;
-                    if (extracted) {
-                        const path = formatFieldPath(tableName, fieldName);
-                        const issues = validateExtractedField(field, extracted, path);
-                        if (issues.length > 0) {
-                            throw new Error(issues.map((i) => i.message).join('; '));
-                        }
-                        const committed = commitFieldWrite(prevFv, extractedToFieldValue(extracted, 'slot-filling', now));
-                        nextRow[fieldName] = committed.field;
-                        if (committed.changed) {
-                            changed.add(path);
-                            if (committed.historyEntry) {
-                                history.push({ path, entry: committed.historyEntry, rowId: id });
-                            }
-                        }
-                    }
-                    else if (prevFv) {
-                        nextRow[fieldName] = prevFv;
-                    }
-                    else {
-                        nextRow[fieldName] = makeFieldValue({
-                            value: null,
-                            state: 'empty',
-                            updatedBy: 'slot-filling',
-                            updatedAt: now,
-                        });
-                    }
-                }
-                nextRows.push(nextRow);
-            }
-            const prevIds = new Set(prevRows.map((r) => r.id));
-            const nextIds = new Set(nextRows.map((r) => r.id));
-            for (const id of prevIds) {
-                if (!nextIds.has(id))
-                    structuralChange = true;
-            }
-            if (prevRows.length !== nextRows.length)
-                structuralChange = true;
-            next[tableName] = nextRows;
-            if (structuralChange) {
-                for (const fieldName of slotFieldNames(table.fields)) {
-                    changed.add(formatFieldPath(tableName, fieldName));
-                }
-            }
-        }
-    }
-    return { snapshot: next, changed: [...changed], history };
-}
-/**
- * Mark remaining conversation fields as asked_unknown (Topic move-on).
- */
-export function markAskedUnknown(schema, snapshot, fields, options = {}) {
-    const now = options.now ?? Date.now();
-    const next = cloneSnapshot(snapshot);
-    const changed = [];
-    const history = [];
-    for (const path of fields) {
-        const parsed = requireFieldPath(path);
-        const table = getCompiledTable(schema, parsed.table);
-        const field = table?.fields[parsed.field];
-        if (!table || !field || field.derived)
-            continue;
-        if (field.source !== 'conversation')
-            continue;
-        if (!isSnapshotSingleRow(table))
-            continue;
-        const tableData = getSnapshotTable(next, parsed.table);
-        const prev = getRowField(tableData, parsed.field);
-        if (!prev || prev.state !== 'empty')
-            continue;
-        const committed = commitFieldWrite(prev, makeFieldValue({
-            value: null,
-            state: 'asked_unknown',
-            reason: options.reason ?? 'move-on',
-            updatedBy: 'platform',
-            updatedAt: now,
-        }));
-        tableData[parsed.field] = committed.field;
-        if (committed.changed) {
-            changed.push(parsed.path);
-            if (committed.historyEntry) {
-                history.push({
-                    path: parsed.path,
-                    entry: committed.historyEntry,
-                    rowId: typeof tableData.id === 'string' && tableData.id ? tableData.id : undefined,
-                });
-            }
-        }
-    }
-    return { snapshot: next, changed, history };
-}
-//# sourceMappingURL=write.js.map

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

@@ -1,54 +0,0 @@
-import type { FuncRef } from '../functions/func-ref.js';
-import type { FieldPath } from '../slot/path.js';
-import type { ActionNode, AgendaHeader, AgendaTree, AuthoringNode, AuthoringWhen, BranchNode, FinishWhen, IvrDigit, IvrFallbackAction, IvrNode, OnNoProgress, SectionNode, SwitchOnNode, TopicNode, TransferNode } from './types.js';
-import type { TransferDial, TransferMode, TransferSay } from './transfer-spec.js';
-export declare function topic(id: string, config: {
-    label: string;
-    applyWhen: AuthoringWhen;
-    instructions: string;
-    fields: FieldPath[] | null;
-    finishWhen: FinishWhen;
-    onNoProgress: OnNoProgress | null;
-}): TopicNode;
-export declare function action(id: string, config: {
-    label: string;
-    applyWhen: AuthoringWhen;
-    finishWhen: FinishWhen;
-    run: FuncRef;
-    say: string | null;
-}): ActionNode;
-export declare function transfer(id: string, config: {
-    label: string;
-    applyWhen: AuthoringWhen;
-    numbers: string[];
-    mode: TransferMode;
-    say: TransferSay;
-    unsuccessfulSay: TransferSay | null;
-} & Omit<TransferDial, 'numbers' | 'mode' | 'say' | 'unsuccessfulSay'>): TransferNode;
-export declare function ivr(id: string, config: {
-    label: string;
-    applyWhen: AuthoringWhen;
-    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;
-}): IvrNode;
-export declare function section(id: string, config: {
-    label: string;
-    applyWhen: AuthoringWhen;
-}, children: AuthoringNode[]): SectionNode;
-export declare function branch(children: AuthoringNode[]): BranchNode;
-export declare function switchOn(field: FieldPath, cases: Record<string, AuthoringNode[]> & {
-    otherwise?: AuthoringNode[];
-}): SwitchOnNode;
-export declare function agenda(id: string, header: AgendaHeader | null, tree: AuthoringNode[]): AgendaTree;
-//# sourceMappingURL=builders.d.ts.map