@superpanel-sdk/runtime 0.2.3 → 0.7.0

package/dist/core/page/workspace.d.ts

@@ -0,0 +1,57 @@
+/**
+ * What the AI reads of a page (24 §3, 26 §15.5): one layer, the whole page, like a rep's screen. The
+ * page decides what is on it; the platform works out nothing from it. Everything is an element; every
+ * attribute value is JSON (strings "…" with \" and \n, numbers, true/false, null, lists); free text is
+ * always a `value` attribute; flush left.
+ *
+ *   <notes><note id about value/></notes>   the model's own reminders (17b §8), first, all of them
+ *   <next-step channel id name to at reason customer-quote booked-in/>   the platform's, before the page
+ *                                           (40 §2.2, 51 §2): the case's pending contacts, whatever the page
+ *                                           shows; `value` "none" when nothing is booked
+ *   <guide value/>                         the page's `$guide`: what to do now and how
+ *   <page title description fallback>       the page:
+ *     <definitions>                         once for the page, a definition per `table.field` some field
+ *       <definition for label type …/>      on it shows expanded (`field(slot, { expand: true })`)
+ *     <block key title description>         a part of the page; inside a list, without `key`
+ *     <list key title description>          several things of one kind (an array on the page)
+ *     <field id key readonly more type value value-label one-of state reason/>   one value; `more`: its
+ *                                           definition is not shown (its type is); a ref's one-of: its rows
+ *     <text key value/>                     read-only text
+ *     <button id title does><arg …/></button>
+ *   Now: 2026-11-11T20:05Z                 the platform's, the last line (76 §2.19): the time now, in UTC,
+ *                                           to the minute; the only time the AI is given as "now"
+ */
+import type { PageNextStep } from './define.js';
+import type { BlockNode, RenderedPage } from './render.js';
+export type WorkspaceNote = {
+    id: string;
+    text: string;
+    about?: string;
+};
+export type WorkspaceTextOptions = {
+    notes?: readonly WorkspaceNote[];
+    /**
+     * The case's next step (40 §2.2), shown before the page whatever the page shows: the AI knows what is
+     * booked before it reads the page. Times in `timeZone` (the contact's). Left out: no conversation (nothing is shown).
+     */
+    nextSteps?: {
+        steps: readonly PageNextStep[];
+        timeZone: string;
+    };
+    /**
+     * The time now (76 §2.19): the page's last line, `Now: 2026-11-11T20:05Z`, in UTC, never the contact's
+     * zone. Every engine that shows the AI a page gives it; left out: no such line.
+     */
+    now?: Date;
+};
+export declare function workspaceText(page: RenderedPage, options?: WorkspaceTextOptions): string;
+/** The last line of every page the AI reads (76 §2.19): the time now in UTC, to the minute (`Now: 2026-11-11T20:05Z`). */
+export declare function nowLine(now: Date): string;
+/** Stable, short appointment handle; the service resolves it within the authorized case, rejecting ambiguity. */
+export declare function nextStepReference(id: string): string;
+export declare function nextStepLines(steps: readonly PageNextStep[], timeZone: string): string[];
+/** The block at `path` (`''`: the root). */
+export declare function blockAt(page: RenderedPage, path: string): BlockNode | null;
+/** What `view` shows of one thing on the page (24 §3.2): a field with its definition, a button with its arguments. */
+export declare function viewText(page: RenderedPage, id: string): string | null;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/core/page/workspace.js

@@ -0,0 +1,266 @@
+import { formatTime } from './time-format.js';
+export function workspaceText(page, options = {}) {
+    const out = [];
+    const notes = options.notes ?? [];
+    if (notes.length) {
+        out.push('<notes>');
+        for (const n of notes)
+            out.push(element('note', { id: n.id, about: n.about, value: n.text }));
+        out.push('</notes>');
+    }
+    if (options.nextSteps)
+        out.push(...nextStepLines(options.nextSteps.steps, options.nextSteps.timeZone));
+    const root = page.root;
+    if (root.guide)
+        out.push(element('guide', { value: root.guide }));
+    out.push(open('page', { title: root.title, description: root.description, fallback: page.fallback ? (page.fallback.stale ? 'stale' : 'empty') : undefined }));
+    if (page.fallback) {
+        out.push(element('text', {
+            key: 'fallback',
+            value: page.fallback.stale
+                ? 'This page could not be refreshed: its values may be out of date, and nothing on it can be changed now.'
+                : 'The case page could not be loaded: nothing is known about the case here, and nothing can be changed now.',
+        }));
+    }
+    const defined = definedCells(page);
+    if (defined.size) {
+        out.push('<definitions>');
+        for (const [kind, cell] of defined)
+            out.push(element('definition', { for: kind, ...definitionAttrs(page, cell) }));
+        out.push('</definitions>');
+    }
+    for (const child of root.children)
+        walk(page, child, defined, false, out);
+    out.push('</page>');
+    if (options.now)
+        out.push(nowLine(options.now));
+    return out.join('\n');
+}
+/** The last line of every page the AI reads (76 §2.19): the time now in UTC, to the minute (`Now: 2026-11-11T20:05Z`). */
+export function nowLine(now) {
+    return `Now: ${now.toISOString().slice(0, 16)}Z`;
+}
+/** Stable, short appointment handle; the service resolves it within the authorized case, rejecting ambiguity. */
+export function nextStepReference(id) {
+    return `step-${id.replaceAll('-', '').slice(0, 12)}`;
+}
+export function nextStepLines(steps, timeZone) {
+    if (!steps.length)
+        return [element('next-step', { value: 'none: nothing is booked to contact anyone on this case' })];
+    const when = (at) => {
+        try {
+            return formatTime(at, { timeZone });
+        }
+        catch {
+            return at;
+        }
+    };
+    return steps.map((step) => element('next-step', {
+        channel: step.channel,
+        id: nextStepReference(step.id),
+        name: step.name ?? undefined,
+        to: step.contact.name ?? step.contact.id,
+        at: when(step.at),
+        reason: step.reason ?? undefined,
+        'customer-quote': step.customerQuote ?? undefined,
+        'booked-in': step.bookedIn ? `the ${step.bookedIn.channel === 'call' ? 'call' : step.bookedIn.channel === 'sms' ? 'texts' : 'email'} of ${when(step.bookedIn.at)}` : 'by the case\'s follow-up rules',
+    }));
+}
+const kindOf = (cell) => `${cell.ref.table}.${cell.ref.field}`;
+/** Each `table.field` some field on the page shows expanded, in page order: the page gives its definition once. */
+function definedCells(page) {
+    const out = new Map();
+    const visit = (node) => {
+        if (node.kind === 'cell' && node.expand) {
+            const cell = page.cells[node.slotId];
+            if (!out.has(kindOf(cell)))
+                out.set(kindOf(cell), cell);
+        }
+        if (node.kind === 'block')
+            node.children.forEach(visit);
+    };
+    page.root.children.forEach(visit);
+    return out;
+}
+function walk(page, node, defined, inList, out) {
+    switch (node.kind) {
+        case 'block': {
+            const tag = node.list ? 'list' : 'block';
+            out.push(open(tag, { key: inList ? undefined : node.key || undefined, title: node.title, description: node.description }));
+            for (const child of node.children)
+                walk(page, child, defined, node.list, out);
+            out.push(`</${tag}>`);
+            return;
+        }
+        case 'cell': {
+            const cell = page.cells[node.slotId];
+            // A field the AI cannot change needs no definition: no `more` on it (26 §16.2 #5b).
+            out.push(element('field', fieldAttrs(page, node, cell, editable(node, cell) && !defined.has(kindOf(cell)), inList)));
+            return;
+        }
+        case 'text':
+            // null: the page put nothing here now (a region that does not apply yet, a value it has not got).
+            // In a list it has no key of its own, only its place, as a block there (26 §16.2 #10).
+            out.push(element('text', { key: inList ? undefined : node.key || undefined, value: node.value }));
+            return;
+        case 'action':
+            out.push(...buttonLines(page.actions[node.actionId]));
+    }
+}
+/**
+ * Whether the AI may change a field (30 §3): the field's final permission, the same wherever it is on the
+ * page. A place marked read-only cannot stop the AI writing a field writable elsewhere (it writes by id),
+ * so marking it there would only contradict the other place.
+ */
+const editable = (_node, cell) => cell.writable;
+/**
+ * A field's value (26 §16.2): `key` always (#10; in a list, where it has only its place, none); `readonly`
+ * only on one the AI cannot change (#6a); `more` when its definition is not shown, with its type (#6);
+ * `state` only when it holds no value (#6a: a value is filled; `[]` too). A ref field (#7) writes the rows
+ * it may be set to as `one-of` {name: label}; read-only, who its value is as `value-label`, when the page
+ * labelled it.
+ */
+function fieldAttrs(page, node, cell, more, inList = false) {
+    const value = valueOf(cell);
+    const open = editable(node, cell);
+    const labels = cell.optionLabels ?? {};
+    return {
+        id: cell.slotId,
+        key: inList ? undefined : node.key || undefined,
+        readonly: !open,
+        more,
+        type: more ? cell.type : undefined,
+        value,
+        'value-label': !open && typeof value === 'string' && value in labels ? labels[value] : undefined,
+        'one-of': open && cell.options ? Object.fromEntries(cell.options.map((name) => [name, labels[name] ?? name])) : undefined,
+        state: cell.state === 'filled' ? undefined : cell.state,
+        reason: (cell.state === 'asked_unknown' || cell.state === 'declined') && cell.reason ? cell.reason : undefined,
+    };
+}
+/** The value as JSON holds it; a ref's is its row's name (33); null when not filled. */
+function valueOf(cell) {
+    if (cell.state !== 'filled')
+        return null;
+    return cell.valueRow ?? cell.value ?? null;
+}
+/**
+ * What a field means and takes (26 §15.3): label, type, allowed values (`one-of`; a ref field's rows are
+ * on the field itself, 26 §16.2 #7), and `help` — the schema's description and how to fill it, the
+ * page's `$extraction` for its `table.field` replacing the schema's (a ref field's too, #5). How each type
+ * is written is the system message's (`PAGE_FORMAT`), once for every field.
+ */
+function definitionAttrs(page, cell) {
+    const help = [];
+    if (cell.description)
+        help.push(cell.description);
+    const own = page.extractions?.[kindOf(cell)];
+    if (own !== undefined) {
+        if (own)
+            help.push(own);
+    }
+    else if (cell.extraction)
+        help.push(cell.extraction);
+    return {
+        label: cell.label,
+        type: cell.type,
+        'one-of': cell.choices ?? undefined,
+        help: help.length ? help.join(' · ') : undefined,
+    };
+}
+function buttonLines(action) {
+    const attrs = { id: action.id, title: action.name, does: action.description };
+    const props = action.input?.properties ?? {};
+    if (!Object.keys(props).length)
+        return [element('button', attrs)];
+    const out = [open('button', attrs)];
+    for (const [name, prop] of Object.entries(props))
+        argLines(name, prop, action.input.required.includes(name), out);
+    out.push('</button>');
+    return out;
+}
+/**
+ * An argument, its type named as a field's (26 §15.8); a list's items are an `<item>`, an object's
+ * properties (a `contact_schedule`'s parts too) `<arg>`s inside it.
+ */
+function argLines(name, prop, required, out) {
+    const tag = name === null ? 'item' : 'arg';
+    const base = { name: name ?? undefined, required };
+    if (prop.type === 'array') {
+        out.push(open(tag, { ...base, type: 'list', help: prop.description }));
+        argLines(null, prop.items, false, out);
+        out.push(`</${tag}>`);
+        return;
+    }
+    if (prop.type === 'object') {
+        out.push(open(tag, { ...base, type: prop['x-type'] ?? 'object', nullable: Boolean(prop.nullable), help: prop.description }));
+        for (const [key, inner] of Object.entries(prop.properties))
+            argLines(key, inner, (prop.required ?? []).includes(key), out);
+        out.push(`</${tag}>`);
+        return;
+    }
+    // A row choice: each row with its label (26 §16.2 #7), as a ref field's candidates.
+    const oneOf = prop.type === 'ref' && prop.labels ? Object.fromEntries(prop.enum.map((name) => [name, prop.labels[name] ?? name])) : prop.enum;
+    out.push(element(tag, { ...base, type: prop.type, 'one-of': oneOf, help: prop.description }));
+}
+/** The block at `path` (`''`: the root). */
+export function blockAt(page, path) {
+    if (path === '')
+        return page.root;
+    let found = null;
+    const visit = (node) => {
+        if (found || node.kind !== 'block')
+            return;
+        if (node.path === path)
+            found = node;
+        else if (path.startsWith(`${node.path}.`) || node.path === '')
+            node.children.forEach(visit);
+    };
+    page.root.children.forEach(visit);
+    return found;
+}
+/** What `view` shows of one thing on the page (24 §3.2): a field with its definition, a button with its arguments. */
+export function viewText(page, id) {
+    const cell = page.cells[id];
+    if (cell) {
+        const node = findCellNode(page, id);
+        if (!node)
+            return null;
+        const { type: _type, 'one-of': rows, ...own } = fieldAttrs(page, node, cell, false);
+        const definition = definitionAttrs(page, cell);
+        // The field, then its definition; a ref field's rows are its own (`one-of` on the field).
+        return element('field', { ...own, ...definition, 'one-of': rows ?? definition['one-of'] });
+    }
+    const action = page.actions[id];
+    return action ? buttonLines(action).join('\n') : null;
+}
+function findCellNode(page, slotId) {
+    let found = null;
+    const visit = (node) => {
+        if (found)
+            return;
+        if (node.kind === 'cell' && node.slotId === slotId)
+            found = node;
+        if (node.kind === 'block')
+            node.children.forEach(visit);
+    };
+    visit(page.root);
+    return found;
+}
+// ---------------------------------------------------------------------------------------------
+// Writing elements
+/** `true`: a bare flag; `false` / `undefined`: left out; anything else `name=<JSON>`. `value` always prints, null included. */
+function attrText(attrs) {
+    const parts = [];
+    for (const [k, v] of Object.entries(attrs)) {
+        if (k === 'value')
+            parts.push(`value=${JSON.stringify(v ?? null)}`);
+        else if (v === true)
+            parts.push(k);
+        else if (v !== undefined && v !== false)
+            parts.push(`${k}=${JSON.stringify(v)}`);
+    }
+    return parts.length ? ` ${parts.join(' ')}` : '';
+}
+const open = (tag, attrs) => `<${tag}${attrText(attrs)}>`;
+const element = (tag, attrs) => `<${tag}${attrText(attrs)}/>`;
+//# sourceMappingURL=workspace.js.map

package/dist/core/party/index.d.ts

@@ -0,0 +1,3 @@
+export * from './schema.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/party/index.js

@@ -0,0 +1,3 @@
+export * from './schema.js';
+export * from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/core/party/schema.d.ts

@@ -0,0 +1,208 @@
+import { z } from 'zod';
+/** How a contact is reached: a phone number or an email address. */
+export declare const partyAddress: z.ZodObject<{
+    kind: z.ZodEnum<{
+        email: "email";
+        phone: "phone";
+    }>;
+    value: z.ZodString;
+}, z.core.$strip>;
+export type PartyAddress = z.infer<typeof partyAddress>;
+/**
+ * The other side as a conversation arrives: a phone number or an email address, or the SIP URI of a
+ * SIP caller whose URI is not a phone number (`sip:alice@pbx.example.com`): no contact field holds it,
+ * so `resolve` finds the contact by what the call carries (`sip.headers`).
+ */
+export declare const arrivalAddress: z.ZodObject<{
+    kind: z.ZodEnum<{
+        email: "email";
+        phone: "phone";
+        sip: "sip";
+    }>;
+    value: z.ZodString;
+}, z.core.$strip>;
+export type ArrivalAddress = z.infer<typeof arrivalAddress>;
+/**
+ * A call that came through our SIP Domain: its URIs as they came, the domain, and the headers the far
+ * end sent (`X-…` ones and `User-to-User`, by name: `X-Case-Id`). A system that puts the call through
+ * to us says in them what it is about.
+ */
+export declare const sipArrival: z.ZodObject<{
+    fromUri: z.ZodNullable<z.ZodString>;
+    toUri: z.ZodNullable<z.ZodString>;
+    domain: z.ZodNullable<z.ZodString>;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export type SipArrival = z.infer<typeof sipArrival>;
+/**
+ * What both resolves get (14-sequence-instance §18): the conversation as it arrives, no facts looked
+ * up. They look up what they need (`ctx.api.contact.find`, `ctx.api.instances.findForContact`,
+ * `ctx.api.exchanges`).
+ */
+/** A text of the batch the resolve decides for (64 §9), as the page gets it (`ctx.sms.inbound`), with the provider's id. */
+export declare const arrivalSmsMessage: z.ZodObject<{
+    id: z.ZodString;
+    body: z.ZodString;
+    at: z.ZodString;
+    externalId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ArrivalSmsMessage = z.infer<typeof arrivalSmsMessage>;
+/** An email of the batch the resolve decides for (64 §9), as the page gets it (`ctx.email.inbound`), with the provider's id. */
+export declare const arrivalEmailMessage: z.ZodObject<{
+    id: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodArray<z.ZodString>;
+    cc: z.ZodArray<z.ZodString>;
+    subject: z.ZodNullable<z.ZodString>;
+    body: z.ZodString;
+    at: z.ZodString;
+    attachments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        contentType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    externalId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ArrivalEmailMessage = z.infer<typeof arrivalEmailMessage>;
+/**
+ * What the company `resolve` is called with (§18.2, its `args`): an inbound conversation, before its sequence is known.
+ * `to.name` is our number's, SIP address's or mailbox's name in the environment (22 §7), the same in test and prod.
+ */
+export declare const companyResolveInput: z.ZodObject<{
+    channel: z.ZodEnum<{
+        call: "call";
+        email: "email";
+        sms: "sms";
+    }>;
+    from: z.ZodObject<{
+        kind: z.ZodEnum<{
+            email: "email";
+            phone: "phone";
+            sip: "sip";
+        }>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    threadId: z.ZodNullable<z.ZodString>;
+    sip: z.ZodOptional<z.ZodObject<{
+        fromUri: z.ZodNullable<z.ZodString>;
+        toUri: z.ZodNullable<z.ZodString>;
+        domain: z.ZodNullable<z.ZodString>;
+        headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>;
+    externalId: z.ZodNullable<z.ZodString>;
+    messages: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        body: z.ZodString;
+        at: z.ZodString;
+        externalId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodArray<z.ZodString>;
+        cc: z.ZodArray<z.ZodString>;
+        subject: z.ZodNullable<z.ZodString>;
+        body: z.ZodString;
+        at: z.ZodString;
+        attachments: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            contentType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        externalId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>]>>;
+    to: z.ZodObject<{
+        kind: z.ZodEnum<{
+            email: "email";
+            phone: "phone";
+            sip: "sip";
+        }>;
+        value: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CompanyResolveInput = z.infer<typeof companyResolveInput>;
+/**
+ * What the company `resolve` returns: the sequence (its name) the conversation goes to, or `decline`
+ * (we do not take it; §18.5): a call is transferred to the environment's fallback number, a text or
+ * an email gets `reply` when given.
+ */
+export declare const companyResolveResult: z.ZodUnion<readonly [z.ZodObject<{
+    sequence: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    decline: z.ZodObject<{
+        reply: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type CompanyResolveResult = z.infer<typeof companyResolveResult>;
+/** What a sequence's `resolve` is called with (§18.3, its `args`): the conversation, on this sequence. */
+export declare const resolveInput: z.ZodObject<{
+    channel: z.ZodEnum<{
+        call: "call";
+        email: "email";
+        sms: "sms";
+    }>;
+    from: z.ZodObject<{
+        kind: z.ZodEnum<{
+            email: "email";
+            phone: "phone";
+            sip: "sip";
+        }>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    to: z.ZodObject<{
+        kind: z.ZodEnum<{
+            email: "email";
+            phone: "phone";
+            sip: "sip";
+        }>;
+        value: z.ZodString;
+    }, z.core.$strip>;
+    threadId: z.ZodNullable<z.ZodString>;
+    sip: z.ZodOptional<z.ZodObject<{
+        fromUri: z.ZodNullable<z.ZodString>;
+        toUri: z.ZodNullable<z.ZodString>;
+        domain: z.ZodNullable<z.ZodString>;
+        headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>;
+    externalId: z.ZodNullable<z.ZodString>;
+    messages: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        body: z.ZodString;
+        at: z.ZodString;
+        externalId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodArray<z.ZodString>;
+        cc: z.ZodArray<z.ZodString>;
+        subject: z.ZodNullable<z.ZodString>;
+        body: z.ZodString;
+        at: z.ZodString;
+        attachments: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            contentType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        externalId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>]>>;
+    direction: z.ZodEnum<{
+        inbound: "inbound";
+        outbound: "outbound";
+    }>;
+    sequence: z.ZodString;
+}, z.core.$strip>;
+export type ResolveInput = z.infer<typeof resolveInput>;
+/**
+ * What a sequence's `resolve` returns: the contact the conversation is with, and either an active
+ * instance of this sequence to join or a new one of this sequence to start (on a row of its subject
+ * table; when another start won the race for the same row, the conversation joins that one).
+ */
+export declare const resolveResult: z.ZodUnion<readonly [z.ZodObject<{
+    contactId: z.ZodString;
+    instanceId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    contactId: z.ZodString;
+    start: z.ZodObject<{
+        subjectRecordId: z.ZodString;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type ResolveResult = z.infer<typeof resolveResult>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/core/party/schema.js

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+/** How a contact is reached: a phone number or an email address. */
+export const partyAddress = z.object({
+    kind: z.enum(['phone', 'email']),
+    value: z.string().min(1),
+});
+/**
+ * The other side as a conversation arrives: a phone number or an email address, or the SIP URI of a
+ * SIP caller whose URI is not a phone number (`sip:alice@pbx.example.com`): no contact field holds it,
+ * so `resolve` finds the contact by what the call carries (`sip.headers`).
+ */
+export const arrivalAddress = z.object({
+    kind: z.enum(['phone', 'email', 'sip']),
+    value: z.string().min(1),
+});
+/**
+ * A call that came through our SIP Domain: its URIs as they came, the domain, and the headers the far
+ * end sent (`X-…` ones and `User-to-User`, by name: `X-Case-Id`). A system that puts the call through
+ * to us says in them what it is about.
+ */
+export const sipArrival = z.object({
+    fromUri: z.string().nullable(),
+    toUri: z.string().nullable(),
+    domain: z.string().nullable(),
+    headers: z.record(z.string(), z.string()),
+});
+/**
+ * What both resolves get (14-sequence-instance §18): the conversation as it arrives, no facts looked
+ * up. They look up what they need (`ctx.api.contact.find`, `ctx.api.instances.findForContact`,
+ * `ctx.api.exchanges`).
+ */
+/** A text of the batch the resolve decides for (64 §9), as the page gets it (`ctx.sms.inbound`), with the provider's id. */
+export const arrivalSmsMessage = z.object({
+    id: z.string(),
+    body: z.string(),
+    at: z.string(),
+    /** The provider's id of the text (Twilio's MessageSid). */
+    externalId: z.string().nullable(),
+});
+/** An email of the batch the resolve decides for (64 §9), as the page gets it (`ctx.email.inbound`), with the provider's id. */
+export const arrivalEmailMessage = z.object({
+    id: z.string(),
+    from: z.string(),
+    to: z.array(z.string()),
+    cc: z.array(z.string()),
+    subject: z.string().nullable(),
+    /** Quoted history and signature taken out. */
+    body: z.string(),
+    at: z.string(),
+    /** Listed only: their contents are not read here. */
+    attachments: z.array(z.object({ name: z.string(), contentType: z.string().optional() })),
+    /** The provider's id of the email. */
+    externalId: z.string().nullable(),
+});
+const conversationArrival = z.object({
+    channel: z.enum(['call', 'sms', 'email']),
+    /** The other side: the caller or sender on inbound, the one called on outbound. Normalized. */
+    from: arrivalAddress,
+    /**
+     * Our side: the number or mailbox the conversation came in on (inbound) or goes out from; on a call
+     * through our SIP Domain to one of our SIP addresses, the SIP URI it dialed (`sip:sales@acme.sip.twilio.com`).
+     */
+    to: arrivalAddress,
+    /** Email: the provider thread id, when the message belongs to one. */
+    threadId: z.string().nullable(),
+    /** A call through our SIP Domain; absent on any other conversation. */
+    sip: sipArrival.optional(),
+    /** A call: the provider's id of the call (Twilio's CallSid, 62), what a record written here can name it by. Null on a text or an email. */
+    externalId: z.string().nullable(),
+    /**
+     * Texts and emails: the batch this resolve decides for (64 §9), oldest first; each carries its own
+     * `externalId`. Absent on a call, which has said nothing yet, and on an outbound conversation.
+     */
+    messages: z.union([z.array(arrivalSmsMessage), z.array(arrivalEmailMessage)]).optional(),
+});
+/**
+ * What the company `resolve` is called with (§18.2, its `args`): an inbound conversation, before its sequence is known.
+ * `to.name` is our number's, SIP address's or mailbox's name in the environment (22 §7), the same in test and prod.
+ */
+export const companyResolveInput = conversationArrival.extend({
+    to: arrivalAddress.extend({ name: z.string().nullable() }),
+});
+/**
+ * What the company `resolve` returns: the sequence (its name) the conversation goes to, or `decline`
+ * (we do not take it; §18.5): a call is transferred to the environment's fallback number, a text or
+ * an email gets `reply` when given.
+ */
+export const companyResolveResult = z.union([
+    z.strictObject({ sequence: z.string().min(1) }),
+    z.strictObject({ decline: z.strictObject({ reply: z.string().min(1).optional() }) }),
+]);
+/** What a sequence's `resolve` is called with (§18.3, its `args`): the conversation, on this sequence. */
+export const resolveInput = conversationArrival.extend({
+    direction: z.enum(['inbound', 'outbound']),
+    /** This sequence (its name): the only one whose instances `resolve` may return or start. */
+    sequence: z.string(),
+});
+/**
+ * What a sequence's `resolve` returns: the contact the conversation is with, and either an active
+ * instance of this sequence to join or a new one of this sequence to start (on a row of its subject
+ * table; when another start won the race for the same row, the conversation joins that one).
+ */
+export const resolveResult = z.union([
+    z.strictObject({ contactId: z.string().min(1), instanceId: z.string().min(1) }),
+    z.strictObject({
+        contactId: z.string().min(1),
+        start: z.strictObject({
+            subjectRecordId: z.string().min(1),
+            variables: z.record(z.string(), z.unknown()).optional(),
+        }),
+    }),
+]);
+//# sourceMappingURL=schema.js.map