@superpanel-sdk/runtime 0.2.3 → 0.7.0

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

@@ -1,75 +0,0 @@
-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/simulate.d.ts

@@ -1,24 +0,0 @@
-import type { ComputeHost } from '../../compute-host/compute-host.js';
-import type { RuntimeSlotsSnapshot } from '../slot/types.js';
-import { type WalkResult } from './walk.js';
-import type { FlatAgendaItem } from './types.js';
-export type SimulatedItemStatus = 'folded' | 'done' | 'selected' | 'open';
-export type SimulatedItem = {
-    placementId: string;
-    blockId: string;
-    kind: FlatAgendaItem['kind'];
-    groupPath: string[];
-    status: SimulatedItemStatus;
-    applyWhen: boolean;
-    finishWhen: boolean | null;
-};
-export type SimulateResult = {
-    selected: FlatAgendaItem | null;
-    walk: WalkResult;
-    items: SimulatedItem[];
-};
-export declare function simulateAgenda(items: FlatAgendaItem[], snapshot: RuntimeSlotsSnapshot, options?: {
-    currentPlacementId?: string | null;
-    compute?: ComputeHost;
-}): Promise<SimulateResult>;
-//# sourceMappingURL=simulate.d.ts.map

package/dist/core/stage/simulate.js

@@ -1,33 +0,0 @@
-import { evaluateWhen } from './finish-when.js';
-import { walkAgenda } from './walk.js';
-export async function simulateAgenda(items, snapshot, options = {}) {
-    const walk = await walkAgenda(items, snapshot, {
-        currentPlacementId: options.currentPlacementId,
-        compute: options.compute,
-    });
-    const simulated = [];
-    for (const item of items) {
-        const applies = (await evaluateWhen(item.applyWhen, snapshot, options.compute)).pass;
-        const finished = applies ? (await evaluateWhen(item.finishWhen, snapshot, options.compute)).done : null;
-        let status;
-        if (!applies)
-            status = 'folded';
-        else if (finished)
-            status = 'done';
-        else if (walk.hit?.placementId === item.placementId)
-            status = 'selected';
-        else
-            status = 'open';
-        simulated.push({
-            placementId: item.placementId,
-            blockId: item.id,
-            kind: item.kind,
-            groupPath: item.groupPath,
-            status,
-            applyWhen: applies,
-            finishWhen: finished,
-        });
-    }
-    return { selected: walk.hit, walk, items: simulated };
-}
-//# sourceMappingURL=simulate.js.map

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

@@ -1,19 +0,0 @@
-import type { FieldPath } from '../slot/path.js';
-import type { CompiledSlotSchema } from '../slot/types.js';
-import type { AgendaBlock, AuthoringNode, TransferBlock } from './types.js';
-/** Sanitize a transfer node id into a session field fragment. */
-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>, options?: {
-    lastResult?: boolean;
-}): CompiledSlotSchema;
-//# sourceMappingURL=transfer-fields.d.ts.map

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

@@ -1,129 +0,0 @@
-import { idField } from '../slot/schema.js';
-import { getCompiledTable } from '../slot/compile-schema.js';
-import { formatFieldPath } from '../slot/path.js';
-const RESULT_ENUM = ['connected', 'failed'];
-function transferFieldCore(label) {
-    return {
-        derived: false,
-        label,
-        dataType: 'string',
-        source: 'system',
-        extraction: 'Platform transfer result',
-        enum: [...RESULT_ENUM],
-        nullable: true,
-        identifier: null,
-        ref: null,
-    };
-}
-/** Sanitize a transfer node id into a session field fragment. */
-export function transferFieldKey(nodeId) {
-    const cleaned = nodeId.replace(/[^A-Za-z0-9_]/g, '_');
-    return cleaned.length > 0 ? cleaned : 'node';
-}
-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();
-    for (const block of Object.values(blocks)) {
-        if (block.kind === 'transfer' && !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 === 'transfer' && !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);
-            }
-        }
-    }
-}
-/**
- * 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, options) {
-    const ids = [...new Set(transferIds)];
-    if (ids.length === 0 && !options?.lastResult)
-        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 = `transfer_${transferFieldKey(id)}_result`;
-        if (!fields[name]) {
-            fields[name] = transferFieldCore(`Transfer ${id} 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

@@ -1,48 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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,208 +0,0 @@
-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, {
-    all: unknown;
-}>['all'][number];
-export type JsonRulesCondition = Condition;
-/**
- * Shared by applyWhen and finishWhen:
- * json-rules object, JSON string, boolFunction, or null (always).
- */
-export type When = FuncRef | Condition | Condition[] | null;
-export type ApplyWhen = When;
-export type FinishWhen = When;
-/** Compile-time sentinel for branch()/switchOn(); expanded before flatten. */
-export type OtherwiseSentinel = {
-    op: 'otherwise';
-    notAny?: When[];
-};
-export type AuthoringWhen = When | OtherwiseSentinel;
-export type CompiledWhen = {
-    kind: 'always';
-} | {
-    kind: 'fn';
-    fn: string;
-} | {
-    kind: 'rules';
-    condition: JsonRulesCondition;
-};
-export type OnNoProgress = {
-    maxTurns: number;
-    action: 'move-on' | 'handoff' | 'schedule-callback';
-};
-export type FirstMessage = {
-    kind: 'template';
-    text: string;
-} | {
-    kind: 'fn';
-    fn: string;
-};
-export type TransferInterruptAction = {
-    type: 'transfer';
-    escalateCriteria?: string[];
-    noEscalationCriteria?: string[];
-} & TransferDial;
-export type Interrupt = {
-    id: string;
-    label: string;
-    tool: {
-        name: string;
-        description: string;
-    };
-    action: TransferInterruptAction | {
-        type: 'switch-language';
-        languages: string[];
-    };
-    priority: number;
-};
-export type AgendaHeader = {
-    channel: Channel;
-    systemPrompt: string | null;
-    firstMessage: FirstMessage | null;
-    firstMessageMode: 'assistant-speaks-first' | 'user-speaks-first' | null;
-    voicemailPrompt: string | null;
-    interrupts: Interrupt[];
-};
-export type TopicBlock = {
-    kind: 'topic';
-    id: string;
-    label: string;
-    instructions: string;
-    fields: FieldPath[] | null;
-    finishWhen: FinishWhen;
-    onNoProgress: OnNoProgress | null;
-};
-export type ActionBlock = {
-    kind: 'action';
-    id: string;
-    label: string;
-    run: FuncRef;
-    finishWhen: FinishWhen;
-    say: string | null;
-};
-export type TransferBlock = {
-    kind: 'transfer';
-    id: string;
-    label: string;
-} & 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;
-};
-export type CompiledActionBlock = Omit<ActionBlock, 'run' | 'finishWhen'> & {
-    run: string;
-    finishWhen: CompiledWhen;
-};
-export type CompiledTransferBlock = TransferBlock & {
-    finishWhen: CompiledWhen;
-    resultField: FieldPath;
-};
-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;
-    label: string;
-    applyWhen: AuthoringWhen;
-    children: Placement[];
-};
-export type NodePlacement = {
-    kind: 'node';
-    placementId: string;
-    blockId: string;
-    applyWhen: AuthoringWhen;
-};
-export type Placement = SectionPlacement | NodePlacement;
-export type AgendaConfig = {
-    id: string;
-    header: AgendaHeader | null;
-    placements: Placement[];
-};
-export type SequenceAgendas = {
-    blocks: Record<string, AgendaBlock>;
-    agendas: Record<string, AgendaConfig>;
-};
-export type FlatNodePlacement = {
-    placementId: string;
-    applyWhen: CompiledWhen;
-    groupPath: string[];
-};
-export type FlatTopicItem = CompiledTopicBlock & FlatNodePlacement;
-export type FlatActionItem = CompiledActionBlock & FlatNodePlacement;
-export type FlatTransferItem = CompiledTransferBlock & FlatNodePlacement;
-export type FlatIvrItem = CompiledIvrBlock & FlatNodePlacement;
-export type FlatAgendaItem = FlatTopicItem | FlatActionItem | FlatTransferItem | FlatIvrItem;
-export type CompiledAgenda = {
-    header: AgendaHeader | null;
-    flat: FlatAgendaItem[];
-};
-export type TopicNode = TopicBlock & {
-    applyWhen: AuthoringWhen;
-};
-export type ActionNode = ActionBlock & {
-    applyWhen: AuthoringWhen;
-};
-export type TransferNode = TransferBlock & {
-    applyWhen: AuthoringWhen;
-};
-export type IvrNode = IvrBlock & {
-    applyWhen: AuthoringWhen;
-};
-export type SectionNode = {
-    kind: 'section';
-    id: string;
-    label: string;
-    applyWhen: AuthoringWhen;
-    children: AuthoringNode[];
-};
-export type BranchNode = {
-    kind: 'branch';
-    children: AuthoringNode[];
-};
-export type SwitchOnNode = {
-    kind: 'switchOn';
-    field: FieldPath;
-    cases: Record<string, AuthoringNode[]>;
-    otherwise?: AuthoringNode[];
-};
-export type AuthoringNode = TopicNode | ActionNode | TransferNode | IvrNode | SectionNode | BranchNode | SwitchOnNode;
-export type AgendaTree = {
-    kind: 'agenda';
-    id: string;
-    header: AgendaHeader | null;
-    tree: AuthoringNode[];
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/core/stage/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

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

@@ -1,11 +0,0 @@
-import type { FuncMap } from '../functions/types.js';
-import type { CompiledSlotSchema, ValidationIssue, ValidationResult } from '../slot/types.js';
-import type { CompiledAgenda } from './types.js';
-export type ValidateAgendaOptions = {
-    schema: CompiledSlotSchema;
-    functions?: FuncMap;
-    agendaId?: string;
-};
-export declare function validateCompiledAgenda(compiled: CompiledAgenda, options: ValidateAgendaOptions): ValidationResult;
-export declare function fatalAgendaIssues(issues: ValidationIssue[]): ValidationIssue[];
-//# sourceMappingURL=validate.d.ts.map