@appsolutely-io/waypoint 0.0.0-stage → 0.1.1-next.0

package/dist/generated-C9tbjwK0.d.cts

@@ -0,0 +1,797 @@
+type WaypointProtocol = Problem | Negotiation | NegotiationOfferWire | Negotiated | CanonicalRequest | ReadTemplate | Step | ImmediateDraft | ImmediatePlan | TimedPlan | Plan | PlanState | Outcome | ConfirmationItem | ConfirmationSchedule | ConfirmationRecord | PlanRecord | RecoveryPhase | IntentKind | WinnerKind | IntentCause | IntentWinner | RecoveryView | IntentTarget | IntentRequest | PlanIntentReply | ExecutionAcceptance | ReplyDecline | CardAnswer | BlockMarkdown | BlockCard | BlockDetails | BlockList | BlockTable | BlockForm | BlockChoice | BlockButtons | BlockDiff | BlockPlan | BlockRouteLink | BlockNotice | ExtensionBlock | Block | Message | Source | Conversation | ReplyMessage | ReplyConfirm | ReplyForm | ReplyAction | ReplyToolResult | ReplyPlanValues | Reply | ReplyStop | ManifestEntry | ToolCall | FrameMessageStart | FrameTextDelta | FrameBlock | FramePlanDraft | FramePlanFinal | FramePlanStep | FrameToolCall | FramePlanningRead | FrameMessageEnd | FrameStale | FrameProblem | Frame | FlowParameter | Flow | CreateConversation | PlanCommand | RunFlow | PatchFlow | FormSubject | FormValidation | FormFillValue | FormFillField | FormFillRequest | BlockFormFill | ReplyFormFill | LeaveAcknowledgment | DecisionVersions | KeptFact | FinalHistory;
+type Plan = ImmediateDraft | ImmediatePlan | TimedPlan;
+type PlanState = 'proposed' | 'awaiting-confirmation' | 'running' | 'undoing' | 'completed' | 'submitted' | 'undone' | 'needs-attention' | 'cancelled';
+type WinnerKind = 'stop' | 'cancel-initial' | 'cancel-review' | 'leave' | 'keep';
+type IntentCause = 'user' | 'connection-lost' | 'renewal-refused' | 'step-failed' | 'step-up-failed' | 'identity-lost' | 'attribution-missing' | 'plan-changed' | 'adapter-configuration';
+type RecoveryPhase = 'proposal' | 'initial-review' | 'forward-active' | 'readback' | 'completed' | 'cancelled' | 'left-known' | 'left-unconfirmed' | 'left-reopened';
+type IntentKind = 'stop' | 'cancel-initial' | 'cancel-review' | 'leave' | 'keep';
+/**
+ * The answer the host applied to a card, as it was sent without its protocol; only with answered. A host may leave out a form's values.
+ */
+type CardAnswer = {
+    kind: 'action';
+    clientReplyId: string;
+    blockId: string;
+    actionId: string;
+} | {
+    kind: 'form';
+    clientReplyId: string;
+    blockId: string;
+    values?: {};
+};
+type Block = BlockMarkdown | BlockCard | BlockDetails | BlockList | BlockTable | BlockForm | BlockChoice | BlockButtons | BlockDiff | BlockPlan | BlockRouteLink | BlockNotice | BlockFormFill | ExtensionBlock;
+type Conversation = {
+    [k: string]: unknown;
+} & {
+    protocol: string;
+    id: string;
+    title: string;
+    messages: Message[];
+    replyOverdueAt?: number | null;
+    replyStatus?: 'expected' | 'unavailable' | 'failed' | 'complete';
+    mode?: 'form-fill';
+    subject?: FormSubject;
+    parentConversationId?: string;
+    field?: string;
+};
+type FormSubject = {
+    [k: string]: unknown;
+} & {
+    key: string;
+    resource: string;
+    label: string;
+    route: string;
+    state: 'pending' | 'bound' | 'unlinked';
+    record?: string;
+};
+type Reply = ReplyMessage | ReplyConfirm | ReplyForm | ReplyAction | ReplyToolResult | ReplyPlanValues | ReplyFormFill | ReplyStop;
+type Frame = FrameMessageStart | FrameTextDelta | FrameBlock | FramePlanDraft | FramePlanFinal | FramePlanStep | FrameToolCall | FramePlanningRead | FrameMessageEnd | FrameStale | FrameProblem;
+type Flow = {
+    [k: string]: unknown;
+} & {
+    format: '1.0';
+    id: string;
+    title: string;
+    kind: 'structured' | 'prompt';
+    parameters: FlowParameter[];
+    steps?: {
+        operation: string;
+        arguments: {};
+    }[];
+    tags: string[];
+    body: string;
+};
+type CreateConversation = {
+    [k: string]: unknown;
+} & {
+    protocol: string;
+    title: string;
+    mode?: 'form-fill';
+    subject?: FormSubject;
+    parentConversationId?: string;
+    field?: string;
+    clientCreationId?: string;
+};
+interface Problem {
+    code: 'update-required' | 'in-doubt' | 'replaced' | 'retryable' | 'refused' | 'closed' | 'full' | 'declined' | 'unavailable' | 'sign-in' | 'rate-limited' | 'step-up-cancelled' | 'mismatch' | 'invalid-read' | 'invalid-plan' | 'needs-attention' | 'stopped' | 'plan-changed' | 'agreement-expired';
+    id: string;
+    retryAfter?: number;
+    /**
+     * Why a confirmation was refused; only with code refused.
+     */
+    confirmation?: {
+        reason: 'expired' | 'used' | 'stale' | 'mismatch' | 'missing';
+    };
+}
+interface Negotiation {
+    protocol: string;
+    supported: string[];
+    offer?: NegotiationOfferWire;
+}
+interface NegotiationOfferWire {
+    capabilities: string[];
+}
+interface Negotiated {
+    protocol: string;
+    capabilities: string[];
+    agreementId?: string;
+}
+interface CanonicalRequest {
+    method: 'POST' | 'PUT' | 'PATCH' | 'GET';
+    path: string;
+    body: string;
+    headers: {
+        [k: string]: string;
+    };
+    digest: string;
+}
+interface ReadTemplate {
+    method: 'GET';
+    path: string;
+    rows: string[];
+    fields: string[];
+}
+interface Step {
+    id: string;
+    operation: string;
+    resource: string;
+    rows: string[];
+    fields: string[];
+    view: string;
+    tier: 'low' | 'sensitive';
+    undo: string;
+    stepUp: boolean;
+    request?: CanonicalRequest;
+    before?: {};
+    after?: {};
+    planningRead?: ReadTemplate;
+}
+interface ImmediateDraft {
+    kind: 'immediate';
+    stage: 'draft';
+    id: string;
+    steps: (Step & {
+        [k: string]: unknown;
+    })[];
+}
+interface ImmediatePlan {
+    kind: 'immediate';
+    stage: 'final';
+    id: string;
+    digest: string;
+    steps: (Step & {
+        [k: string]: unknown;
+    })[];
+    stepUpCount: number;
+}
+interface TimedPlan {
+    kind: 'timed';
+    id: string;
+    values: {
+        [k: string]: {
+            [k: string]: unknown;
+        };
+    };
+    start: string | null;
+    end: string | null;
+}
+interface Outcome {
+    stepId: string;
+    status: number;
+    attributed: boolean;
+    version?: string;
+    /**
+     * The host's plain words for why the step failed, shown to the user; only for a failed step. Optional.
+     */
+    reason?: string;
+    /**
+     * Whether the failed step can be tried again. Optional.
+     */
+    retryable?: boolean;
+}
+interface ConfirmationItem {
+    label: string;
+    before?: string;
+    after?: string;
+    note?: string;
+}
+interface ConfirmationSchedule {
+    start: string | null;
+    end: string | null;
+    startText: string;
+    endText: string;
+}
+/**
+ * What the host will apply, issued and worded by the host; confirmed only by sending its single-use token.
+ */
+interface ConfirmationRecord {
+    token: string;
+    expiresAt: string;
+    planId: string;
+    conversationId: string;
+    revision: number;
+    heading: string;
+    /**
+     * @maxItems 1000
+     */
+    items: ConfirmationItem[];
+    schedule?: ConfirmationSchedule;
+    irreversible: boolean;
+    undo: string;
+    verificationCount: number;
+    actionLabel?: string;
+}
+interface PlanRecord {
+    protocol: string;
+    id: string;
+    state: PlanState;
+    plan: Plan;
+    outcomes: Outcome[];
+    undoPlanId?: string;
+    reason?: string;
+    recovery?: RecoveryView;
+    confirmation?: ConfirmationRecord;
+}
+interface RecoveryView {
+    profile: 'plan-recovery-v1' | (string & {});
+    phase: RecoveryPhase | (string & {});
+    generation: string;
+    round: number;
+    revision: number;
+    conversationId: string;
+    reviewId?: string;
+    executionId?: string;
+    slots: {
+        stop: number;
+        'cancel-initial': number;
+        'cancel-review': number;
+        leave: number;
+        keep: number;
+    };
+    winner?: IntentWinner;
+    steps?: {
+        stepId: string;
+        truth: 'done' | 'not-done' | 'unknown';
+    }[];
+    versions: DecisionVersions;
+    decisionKey?: string;
+    evidenceDigest?: string;
+    unknownCount?: number;
+    remaining?: number;
+    sealed?: boolean;
+    /**
+     * @maxItems 256
+     */
+    contradictedAfterSeal?: string[];
+}
+interface IntentWinner {
+    kind: WinnerKind;
+    cause: IntentCause;
+}
+interface DecisionVersions {
+    evidence: number;
+    winner: number;
+    decisionResolution: number;
+}
+interface IntentTarget {
+    type: 'generation' | 'review' | 'execution';
+    id: string;
+}
+interface IntentRequest {
+    kind: IntentKind;
+    planId: string;
+    target: IntentTarget;
+    capturedRound: number;
+    expectedSlotVersion: number;
+    correlation: string;
+    cause: IntentCause;
+    payload?: string;
+    acknowledgment?: LeaveAcknowledgment;
+    review?: 'forward-only' | 'end-retention';
+}
+interface LeaveAcknowledgment {
+    sourceDecisionKey: string;
+    evidenceVersion: number;
+    winnerVersion: number;
+    decisionResolutionVersion: number;
+    evidenceDigest: string;
+    unknownCount: number;
+}
+interface PlanIntentReply {
+    planId: string;
+    kind: IntentKind;
+    capturedRound: number;
+    correlation: string;
+    effectiveRound: number;
+    slotVersion: number;
+    resolvedTarget?: string;
+    requestedTargetApplied?: boolean;
+    replacement?: IntentTarget;
+    result: 'applied' | 'replaced' | 'already-closed' | 'already-stopped' | 'defeated' | 'superseded' | 'needs-review' | 'conflict' | 'unavailable' | 'invalid-target' | 'refused' | 'kept' | 'already-kept' | 'sealed';
+    keys: string[];
+    winner?: IntentWinner;
+    phase: RecoveryPhase;
+    safetyApplied?: boolean;
+    dispositionApplied?: boolean;
+    forwardClosed?: boolean;
+    count?: number;
+    requestKey?: 'requestAlreadyStopped' | 'requestTargetStopped';
+    savedDisposition?: {
+        phase: 'left-known' | 'left-unconfirmed';
+        count: number;
+    };
+    finalHistory?: FinalHistory;
+}
+interface FinalHistory {
+    winner: IntentWinner;
+    keptFact: KeptFact;
+    relation?: 'keptElsewhere' | 'leaveCompletedByKeep' | 'leaveCoveredByKeep';
+    requestedTargetApplied?: boolean;
+    /**
+     * @maxItems 256
+     */
+    contradictedAfterSeal?: string[];
+}
+interface KeptFact {
+    keepEffect: 'forward-closed' | 'decision-closed' | 'retention-ended' | 'leave-completed';
+    actorCause: IntentCause;
+    round: number;
+}
+interface ExecutionAcceptance {
+    planId: string;
+    executionId: string;
+    fence: number;
+}
+interface ReplyDecline {
+    kind: 'decline';
+    planId: string;
+    clientReplyId: string;
+}
+interface BlockMarkdown {
+    type: 'markdown';
+    id: string;
+    fallback: string;
+    body: {
+        text: string;
+    };
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface BlockCard {
+    type: 'card';
+    id: string;
+    fallback: string;
+    body: {
+        title: string;
+        blocks: Block[];
+    };
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+/**
+ * Supporting detail behind a disclosure: closed until the user opens it, so the answer comes first.
+ */
+interface BlockDetails {
+    /**
+     * The block's type: `details`.
+     */
+    type: 'details';
+    /**
+     * The block's id, unique in its message.
+     */
+    id: string;
+    /**
+     * Plain text shown by a client that does not know the type.
+     */
+    fallback: string;
+    /**
+     * The disclosure's words and what it holds.
+     */
+    body: {
+        /**
+         * The words on the closed disclosure.
+         */
+        summary: string;
+        /**
+         * The supporting detail, shown when the disclosure is open.
+         */
+        blocks: Block[];
+    };
+    /**
+     * Whether the host holds an answer to a card nested in this block, named in `answer`. An answer marks the message's own block, so a details block that holds a form or buttons is the one marked (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface BlockList {
+    type: 'list';
+    id: string;
+    fallback: string;
+    body: {
+        items: string[];
+    };
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface BlockTable {
+    type: 'table';
+    id: string;
+    fallback: string;
+    body: {
+        columns: string[];
+        rows: unknown[][];
+    };
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface BlockForm {
+    type: 'form';
+    id: string;
+    fallback: string;
+    body: {
+        fields: {
+            name: string;
+            label: string;
+            required?: boolean;
+            /**
+             * What the host already knows for the field: the form starts with it, and the user may change it. Optional.
+             */
+            value?: string;
+        }[];
+    };
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface BlockChoice {
+    type: 'choice';
+    id: string;
+    fallback: string;
+    body: {
+        mode: 'single' | 'multi' | 'text';
+        options: string[];
+    };
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface BlockButtons {
+    type: 'buttons';
+    id: string;
+    fallback: string;
+    body: {
+        actions: {
+            id: string;
+            label: string;
+        }[];
+    };
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface BlockDiff {
+    type: 'diff';
+    id: string;
+    fallback: string;
+    body: {
+        before: unknown;
+        after: unknown;
+    };
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface BlockPlan {
+    type: 'plan';
+    id: string;
+    fallback: string;
+    body: {
+        planId: string;
+    };
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface BlockRouteLink {
+    type: 'route-link';
+    id: string;
+    fallback: string;
+    body: {
+        label: string;
+        route: string;
+    };
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface BlockNotice {
+    type: 'notice';
+    id: string;
+    fallback: string;
+    body: {
+        text: string;
+        tone?: 'info' | 'warning' | 'error';
+    };
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface BlockFormFill {
+    type: 'form.fill';
+    id: string;
+    fallback: string;
+    body: {
+        requestId: string;
+        values: {
+            [k: string]: FormFillValue;
+        };
+    };
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface FormFillValue {
+    label?: string;
+    value: unknown;
+    validation: FormValidation;
+}
+interface FormValidation {
+    status: 'valid' | 'invalid';
+    messages: string[];
+    guidance?: string;
+}
+interface ExtensionBlock {
+    type: string;
+    id: string;
+    fallback: string;
+    body: unknown;
+    /**
+     * Whether the host holds an answer to this card; it holds one at most (see the README's Card answers).
+     */
+    answered?: boolean;
+    answer?: CardAnswer;
+}
+interface Message {
+    id: string;
+    clientMessageId?: string;
+    role: 'user' | 'assistant';
+    content: string;
+    blocks: Block[];
+    createdAt: number;
+    status?: 'writing' | 'completed' | 'failed' | 'unavailable' | 'stopped';
+    versionIndex?: number;
+    versionCount?: number;
+    /**
+     * What the reply drew on. `[n]` in its content cites the n-th source. Optional.
+     *
+     * @maxItems 50
+     */
+    sources?: Source[];
+}
+interface Source {
+    id: string;
+    title: string;
+    url: string;
+}
+interface ReplyMessage {
+    kind: 'message';
+    protocol: string;
+    clientReplyId: string;
+    content: string;
+    clientMessageId: string;
+}
+interface ReplyConfirm {
+    kind: 'confirm';
+    protocol: string;
+    clientReplyId: string;
+    planId: string;
+    digest?: string;
+    confirmationToken: string;
+}
+interface ReplyForm {
+    kind: 'form';
+    protocol: string;
+    clientReplyId: string;
+    blockId: string;
+    values: {};
+}
+interface ReplyAction {
+    kind: 'action';
+    protocol: string;
+    clientReplyId: string;
+    blockId: string;
+    actionId: string;
+}
+interface ReplyToolResult {
+    kind: 'tool-result';
+    protocol: string;
+    clientReplyId: string;
+    callId: string;
+    result: unknown;
+    problem?: Problem;
+}
+interface ReplyPlanValues {
+    kind: 'plan.values';
+    protocol: string;
+    clientReplyId: string;
+    planId: string;
+    steps: {
+        stepId: string;
+        rows: {};
+        versions: {
+            [k: string]: string;
+        };
+    }[];
+}
+interface ReplyFormFill {
+    kind: 'form-fill';
+    protocol: string;
+    clientReplyId: string;
+    request: FormFillRequest;
+}
+interface FormFillRequest {
+    requestId: string;
+    text: string;
+    references: string[];
+    attachments: string[];
+    field?: string;
+    /**
+     * @minItems 1
+     */
+    fields: [FormFillField, ...FormFillField[]];
+}
+interface FormFillField {
+    name: string;
+    label: string;
+    tier: 'low';
+    value: unknown;
+}
+/**
+ * Asks the host to stop writing a reply. Sent only under the negotiated `reply-stop` capability.
+ */
+interface ReplyStop {
+    kind: 'stop';
+    protocol: string;
+    clientReplyId: string;
+    messageId: string;
+    /**
+     * The version of the message the stop is for, numbered as the message's `versionIndex` (1 for a message with one version). A host ignores a stop for a version it is not writing. Optional: without it, the stop is for the version being written when it arrives.
+     */
+    versionIndex?: number;
+}
+interface ManifestEntry {
+    id: string;
+    kind: 'read' | 'planning-read' | 'update' | 'create' | 'action' | 'bulk';
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH';
+    path: string;
+    resource: string;
+    fields: {
+        [k: string]: 'low' | 'sensitive' | 'human-only';
+    };
+    returns: string[];
+    filterable: string[];
+    permission: string;
+    view: string;
+    undo: string;
+}
+interface ToolCall {
+    id: string;
+    operation: string;
+    method: string;
+    path: string;
+    query?: {
+        [k: string]: string;
+    };
+    /**
+     * The host's plain words for the read, shown to the user while it runs, for example "Reading 3 orders…". Optional.
+     */
+    label?: string;
+}
+interface FrameMessageStart {
+    type: 'message.start';
+    protocol: string;
+    sequence: number;
+    messageId: string;
+    role: 'user' | 'assistant';
+}
+interface FrameTextDelta {
+    type: 'text.delta';
+    protocol: string;
+    sequence: number;
+    messageId: string;
+    text: string;
+}
+interface FrameBlock {
+    type: 'block';
+    protocol: string;
+    sequence: number;
+    messageId: string;
+    block: Block;
+}
+interface FramePlanDraft {
+    type: 'plan.draft';
+    protocol: string;
+    sequence: number;
+    messageId: string;
+    plan: ImmediateDraft;
+}
+interface FramePlanFinal {
+    type: 'plan.final';
+    protocol: string;
+    sequence: number;
+    messageId: string;
+    plan: ImmediatePlan | TimedPlan;
+}
+interface FramePlanStep {
+    type: 'plan.step';
+    protocol: string;
+    sequence: number;
+    planId: string;
+    outcome: Outcome;
+}
+interface FrameToolCall {
+    type: 'tool.call';
+    protocol: string;
+    sequence: number;
+    call: ToolCall;
+}
+interface FramePlanningRead {
+    type: 'planning-read';
+    protocol: string;
+    sequence: number;
+    planId: string;
+    stepId: string;
+    template: ReadTemplate;
+}
+interface FrameMessageEnd {
+    type: 'message.end';
+    protocol: string;
+    sequence: number;
+    messageId: string;
+    status: 'completed' | 'failed' | 'unavailable' | 'stopped';
+}
+interface FrameStale {
+    type: 'stale';
+    protocol: string;
+    sequence: number;
+    reads: ('conversation' | 'conversations' | 'plans' | 'flows')[];
+}
+interface FrameProblem {
+    type: 'problem';
+    protocol: string;
+    sequence: number;
+    problem: Problem;
+}
+interface FlowParameter {
+    name: string;
+    type: 'string' | 'number' | 'boolean';
+    label: string;
+    required: boolean;
+    default?: unknown;
+}
+interface PlanCommand {
+    protocol: string;
+    action: 'stop' | 'heartbeat' | 'resume' | 'retry-undo';
+    planId: string;
+}
+interface RunFlow {
+    protocol: string;
+    flowId: string;
+    values: {};
+}
+interface PatchFlow {
+    protocol: string;
+    flowId: string;
+    favourite: boolean;
+    title: string;
+}
+
+export type { IntentTarget as $, FormSubject as A, Block as B, CanonicalRequest as C, DecisionVersions as D, ExecutionAcceptance as E, Frame as F, FormValidation as G, FrameBlock as H, FrameMessageEnd as I, FrameMessageStart as J, FramePlanDraft as K, FramePlanFinal as L, ManifestEntry as M, FramePlanStep as N, FramePlanningRead as O, Problem as P, FrameProblem as Q, ReadTemplate as R, FrameStale as S, ToolCall as T, FrameTextDelta as U, FrameToolCall as V, ImmediateDraft as W, ImmediatePlan as X, IntentCause as Y, IntentKind as Z, IntentRequest as _, Flow as a, IntentWinner as a0, KeptFact as a1, LeaveAcknowledgment as a2, Message as a3, Negotiated as a4, Negotiation as a5, NegotiationOfferWire as a6, Outcome as a7, PatchFlow as a8, Plan as a9, PlanCommand as aa, PlanIntentReply as ab, PlanRecord as ac, PlanState as ad, RecoveryPhase as ae, RecoveryView as af, Reply as ag, ReplyAction as ah, ReplyConfirm as ai, ReplyDecline as aj, ReplyForm as ak, ReplyFormFill as al, ReplyMessage as am, ReplyPlanValues as an, ReplyStop as ao, ReplyToolResult as ap, RunFlow as aq, Source as ar, Step as as, TimedPlan as at, WaypointProtocol as au, WinnerKind as av, BlockButtons as b, BlockCard as c, BlockChoice as d, BlockDetails as e, BlockDiff as f, BlockForm as g, BlockFormFill as h, BlockList as i, BlockMarkdown as j, BlockNotice as k, BlockPlan as l, BlockRouteLink as m, BlockTable as n, CardAnswer as o, ConfirmationItem as p, ConfirmationRecord as q, ConfirmationSchedule as r, Conversation as s, CreateConversation as t, ExtensionBlock as u, FinalHistory as v, FlowParameter as w, FormFillField as x, FormFillRequest as y, FormFillValue as z };