@uipath/maestro-builder-sdk 5.2.0

package/dist/case/case-sdk.d.ts

@@ -0,0 +1,1282 @@
+/**
+ * case-sdk — a fluent builder for UiPath Case Management plans (`caseplan.json`,
+ * schema V30).
+ *
+ * Like the Flow builder, this constructs a plain description of a case — its
+ * stages, the tasks inside them, and the entry/exit *conditions* that drive
+ * transitions — which `serialize()` turns into a real `caseplan.json`. A case is
+ * a hierarchy (stages → tasks), not a graph: there are **no edges**; flow
+ * between stages is expressed entirely through conditions (see `rule()`).
+ *
+ * This first cut is **reference-mode**: a task points at an already-published
+ * process/agent/rpa/workflow by name + folder. (Embedding an inline flow/bpmn
+ * body in a task is a later phase.) The builder uses callback closures for
+ * nesting, matching the Flow SDK's `.branch(name, cond, b => …)` style — so a
+ * `casePlan()` only ever exposes case methods, and each nested builder only its
+ * own.
+ *
+ * `casePlan` (not `case`) is the entry point: `case` is a reserved word.
+ */
+import type { TypeDesc } from '../core/expr.js';
+import { type ActionSpec, type ConnectorOpts, type EventSubscription, type TriggerOptions } from '../core/actions.js';
+import { type ConnectorDescriptor, type TriggerDescriptor } from '../core/connectors.js';
+export { preserveCaseJson } from './preserve.js';
+export type { CaseJsonPreservation, PreservedCaseNode, PreservedTaskFields, PreservedVariableLane } from './preserve.js';
+export { CaseBuildError } from './case-expr-check.js';
+export type { CaseLocatedDiagnostic } from './case-expr-check.js';
+export type CaseRuleType = 'case-entered' | 'required-tasks-completed' | 'required-stages-completed' | 'selected-stage-completed' | 'selected-stage-exited' | 'selected-tasks-completed' | 'current-stage-entered' | 'adhoc' | 'runs-sequentially' | 'user-selected-stage' | 'wait-for-connector' | 'sla-status-change';
+export interface RuleOpts {
+    /**
+     * Symbolic stage label (for `selected-stage-completed` / `selected-stage-exited`).
+     *
+     * @remarks
+     * Both rules serialize identically — to the one-element `selectedStageIds` array — so this SDK draws no
+     * distinction between them; the difference is interpreted at runtime. Use
+     * `selected-stage-exited` for an interrupting exception-stage entry (what the
+     * shipped example does) and `selected-stage-completed` when you mean the stage
+     * finished normally.
+     */
+    stage?: string;
+    /**
+     * Task references for `selected-tasks-completed`. Resolved **case-wide, not
+     * per-stage** — a rule in one stage may reference a task in another.
+     *
+     * @remarks
+     * Two forms:
+     * - bare `'Task Name'` — the normal form.
+     * - qualified `'<Stage Label>/<Task Name>'` — also accepted, and clearer when a
+     *   name's stage is not obvious from context.
+     *
+     * Task names must be UNIQUE CASE-WIDE: `uip maestro case validate` rejects
+     * duplicates outright ("Task name 'X' is duplicate"), and `check` now flags them
+     * as DUP_TASK. Names that naturally recur across stages ("Withdraw Request",
+     * "Reject") must be qualified at the source, e.g. `'Withdraw Request (Counsel)'`.
+     */
+    tasks?: string[];
+    /**
+     * For a `wait-for-connector` rule — the connector event to suspend on. Omit for
+     * a placeholder (both fields default to `"placeholder"`). Emits the rule's
+     * `uipath` subscription bag (`serviceType: "Intsvc.WaitForEvent"` + a `context`
+     * naming the connector/operation).
+     */
+    connector?: WaitConnectorSpec;
+    /**
+     * For a `sla-status-change` rule — the **displayName of the SLA** whose status
+     * change fires this rule (react to a deadline breach / at-risk). Declare the SLA
+     * with that `displayName` via `.sla({ displayName, … })`; resolved to `slaId`.
+     */
+    sla?: string;
+    /**
+     * For an **at-risk** `sla-status-change` rule — the displayName of the escalation
+     * (declared on the referenced SLA, `trigger: 'at-risk'`) that fires it. Omit for
+     * a **breach** rule (`slaId` alone). Resolved to `escalationId`.
+     */
+    escalation?: string;
+    /** A `=js:` gate on case state (for `adhoc`, or as an extra guard on any rule). */
+    expression?: string;
+}
+/** A single DNF rule. Symbolic references (`stage`/`tasks`) are resolved to ids at serialize. */
+export interface CaseRule extends RuleOpts {
+    rule: CaseRuleType;
+}
+/**
+ * Declare a condition rule. Pass one rule, an array for an AND-group, or an
+ * array of arrays for the complete OR-of-AND grid to
+ * `entryWhen`/`exitWhen`/etc.
+ *
+ * @param type - Which condition, e.g. `'case-entered'` or `'selected-tasks-completed'`.
+ * @param opts - What the rule needs, e.g. the `tasks` a task-completion rule waits on.
+ * @returns A rule to pass to `entryWhen` / `exitWhen` / `completeWhen`.
+ */
+export declare function rule(type: CaseRuleType, opts?: RuleOpts): CaseRule;
+/**
+ * A pure expression gate. The receiving condition slot supplies its canonical
+ * event: `case-entered` for stage entry, `selected-tasks-completed` for stage
+ * exit, `current-stage-entered` for task entry, and
+ * `required-stages-completed` for case completion.
+ */
+export interface WhenExpression {
+    /** Identifies this value as an expression gate until a condition slot resolves it. */
+    readonly kind: 'case-when-expression';
+    /** The `=js:` expression evaluated against case `vars.*`. */
+    readonly expression: string;
+}
+/**
+ * Gate a condition slot only on case data without naming its default event.
+ *
+ * @param expression - A `=js:` expression over declared `vars.*` values.
+ * @returns A slot-agnostic marker resolved by `entryWhen`, `exitWhen`, or `completeWhen`.
+ */
+export declare function when(expression: string): WhenExpression;
+/** A concrete rule or a pure expression gate resolved by its receiving slot. */
+export type CaseRuleInput = CaseRule | WhenExpression;
+/** One rule, one AND-group, or a complete OR-of-AND condition grid. */
+export type CaseRuleGrid = CaseRuleInput | CaseRuleInput[] | CaseRuleInput[][];
+/** SLA deadline unit. `min` = minutes, `h` = hours, `d` = days, `w` = weeks, `m` = months. */
+export type SlaUnit = 'min' | 'h' | 'd' | 'w' | 'm';
+/** When an escalation fires: as the deadline approaches (`at-risk`) or once it passes (`sla-breached`). */
+export type EscalationTrigger = 'at-risk' | 'sla-breached';
+/** Who an escalation notifies. `scope` picks a single user or a whole group. */
+export interface EscalationRecipient {
+    scope: 'User' | 'UserGroup';
+    /** The user/group identifier (email, id, or name the tenant resolves). */
+    target: string;
+    /** Optional display value; defaults to `target` when omitted. */
+    value?: string;
+}
+export interface EscalationOpts {
+    /** Fire as the deadline nears (`at-risk`) or after it is missed (`sla-breached`). */
+    trigger: EscalationTrigger;
+    /** Who to notify (at least one). Build with {@link toUser}/{@link toGroup}. */
+    notify: EscalationRecipient[];
+    /**
+     * For an `at-risk` trigger, the percentage of the SLA elapsed when it fires
+     * (e.g. `80` = at 80% of the deadline). Defaults to `100` when omitted and
+     * is ignored for `sla-breached`.
+     */
+    atRiskPercentage?: number;
+    displayName?: string;
+}
+/** A built escalation (the notification an SLA fires). */
+export interface BuiltEscalation extends EscalationOpts {
+}
+/**
+ * Declare an escalation. `notify` recipients come from {@link toUser}/{@link toGroup}.
+ *
+ * @param opts - When it fires (`after`) and who it notifies (`notify`).
+ * @returns An escalation to attach to an SLA.
+ */
+export declare function escalation(opts: EscalationOpts): BuiltEscalation;
+/**
+ * An escalation recipient that is a single user.
+ *
+ * @param target - How the user is addressed, e.g. `'email'`.
+ * @param value - The address itself, when `target` names a lookup rather than a value.
+ * @returns A recipient for an escalation's `notify` list.
+ */
+export declare function toUser(target: string, value?: string): EscalationRecipient;
+/**
+ * An escalation recipient that is a user group.
+ *
+ * @param target - How the group is addressed, e.g. `'name'`.
+ * @param value - The value itself, when `target` names a lookup rather than a value.
+ * @returns A recipient for an escalation's `notify` list.
+ */
+export declare function toGroup(target: string, value?: string): EscalationRecipient;
+export interface SlaOpts {
+    /** Deadline magnitude (with {@link SlaUnit}). */
+    count: number;
+    unit: SlaUnit;
+    /**
+     * A human title, emitted as the SLA's `displayName`. Required to reference this
+     * SLA from a `sla-status-change` rule (`rule('sla-status-change', { sla })`).
+     * Must be unique across the case and contain no `:`.
+     */
+    displayName?: string;
+    /**
+     * A `=js:` gate deciding when this SLA applies — for conditional SLAs (e.g. a
+     * tighter deadline for high-priority cases). Omit for the default SLA (the one
+     * that always applies); the default must be the LAST `.sla(...)` declared and
+     * emits the always-true gate `=js:true`.
+     */
+    when?: string;
+    /** Escalations fired off this deadline. */
+    escalations?: BuiltEscalation[];
+}
+/** A built SLA rule (`slaRules[]` entry). */
+export interface BuiltSla {
+    count: number;
+    unit: SlaUnit;
+    displayName?: string;
+    /** The `=js:` gate; `=js:true` (always-true) for the default SLA. */
+    expression: string;
+    escalations: BuiltEscalation[];
+}
+export type CaseTriggerKind = 'manual' | 'timer' | 'event';
+export interface BuiltTrigger {
+    kind: CaseTriggerKind;
+    /** Node label (defaults to `Trigger <n>` at serialize when omitted). */
+    name?: string;
+    description?: string;
+    /** Timer only: an ISO-8601 repeating interval (see {@link TimerTriggerOpts.every}). */
+    timeCycle?: string;
+    /** Event only: payload-field extractions onto the trigger's `outputs[]` (see {@link EventTriggerOpts.outputs}). */
+    eventOutputs?: TaskOutputBinding[];
+    /** Event only: a library-resolved Integration Service subscription. */
+    eventSubscription?: EventSubscription;
+}
+export interface ManualTriggerOpts {
+    name?: string;
+    description?: string;
+}
+export interface TimerTriggerOpts {
+    /**
+     * The schedule, as an
+     * {@link https://docs.digi.com/resources/documentation/digidocs/90001488-13/reference/r_iso_8601_duration_format.htm | ISO-8601 repeating interval}
+     * (emitted verbatim as
+     * `timeCycle`): `R/PT1H` (every hour, unbounded), `R5/P1D` (5 times, daily), or
+     * bounded-with-start `R5/2026-04-26T09:00:00Z/P1D` (5 times, daily from that
+     * instant). `R` = repeat, `R<n>` = repeat n times.
+     */
+    every: string;
+    name?: string;
+    description?: string;
+}
+/**
+ * A manual (user-initiated) case trigger.
+ *
+ * @param opts - Display name and other trigger metadata.
+ * @returns A trigger to pass to `.trigger(...)`.
+ */
+export declare function manualTrigger(opts?: ManualTriggerOpts): BuiltTrigger;
+/**
+ * A timer (scheduled) case trigger. `every` is an ISO-8601 repeating interval.
+ *
+ * @param opts - The schedule — `every`, as an ISO-8601 repeating interval.
+ * @returns A trigger to pass to `.trigger(...)`.
+ */
+export declare function timerTrigger(opts: TimerTriggerOpts): BuiltTrigger;
+export interface EventTriggerOpts {
+    name?: string;
+    description?: string;
+    /**
+     * Stringly resolved subscription. Prefer the descriptor overload when a
+     * prepared connector module is available. Omit this for the legacy
+     * `serviceType`-only placeholder.
+     */
+    subscription?: EventSubscription;
+    /**
+     * Optional event-payload extractions. Each key is a case-variable name read
+     * downstream as `=vars.<name>`; each value is the payload field expression
+     * (`=response.<field>`). Pass `{ source, type }` for a non-`string` type. Each
+     * emits a trigger `outputs[]` row plus a readable root `inputOutputs` companion.
+     *
+     * @remarks
+     * With **no** outputs the event trigger is a **placeholder** (`data.inputs`
+     * carries only `serviceType`) — the offline shape for an event on a connector
+     * not yet registered; attach the real connection after registering it.
+     */
+    outputs?: Record<string, string | {
+        source: string;
+        type?: TypeDesc;
+    }>;
+}
+/** Options for the typed `eventTrigger(Descriptor, options)` form. */
+export interface ResolvedEventTriggerOpts<W extends Record<string, string> = Record<string, string>> extends TriggerOptions<W> {
+    /** Trigger node label. */
+    name?: string;
+    /** Trigger node description. */
+    description?: string;
+    /** Event-payload fields to extract into readable case variables. */
+    outputs?: Record<string, string | {
+        source: string;
+        type?: TypeDesc;
+    }>;
+}
+/**
+ * An Integration Service **event** trigger — an external event (a new row, an
+ * email, a webhook) starts the case. A generated descriptor supplies the
+ * connector and event identity; serialization resolves its context, inputs,
+ * outputs, and root bindings through the connector library.
+ *
+ * @param descriptor - A generated connector-event descriptor.
+ * @param opts - Subscription scope/bindings plus trigger display and output options.
+ * @returns A trigger to pass to `.trigger(...)`.
+ */
+export declare function eventTrigger<W extends Record<string, string>>(descriptor: TriggerDescriptor<W, unknown>, opts?: ResolvedEventTriggerOpts<W>): BuiltTrigger;
+/**
+ * An Integration Service event trigger in placeholder or stringly-resolved form.
+ *
+ * @param opts - Display/output options and an optional symbolic subscription.
+ * @returns A trigger to pass to `.trigger(...)`.
+ */
+export declare function eventTrigger(opts?: EventTriggerOpts): BuiltTrigger;
+export interface BuiltEntryCondition {
+    displayName?: string;
+    isInterrupting?: boolean;
+    rules: CaseRule[][];
+}
+export type StageExitType = 'exit-only' | 'wait-for-user' | 'return-to-origin';
+/** Data Fabric entity used by the Case runtime to deliver a person's next-stage selection. */
+export interface SelectNextStageSpec {
+    /** Data Fabric entity name. It must expose `instanceId` and `nextStage` string fields. */
+    objectName: string;
+    /**
+     * Optional Integration Service subscription identity. Use this when preserving
+     * a designer-authored full connector; the engine itself consumes `objectName`.
+    */
+    connector?: {
+        /** Integration Service connector key, for example `uipath-http-webhook`. */
+        connectorKey: string;
+        /** Connector event operation, for example `GENERIC`. */
+        operation: string;
+        /** Symbolic connection name declared in bindings.json. */
+        connection?: string;
+        /** Symbolic folder name declared in bindings.json. */
+        folder?: string;
+    };
+}
+export interface BuiltExitCondition {
+    displayName?: string;
+    marksStageComplete?: boolean;
+    /**
+     * How the stage leaves. `exit-only` just exits; `wait-for-user` holds the case
+     * until a person picks the onward path (pair with a `user-selected-stage` entry
+     * on the destinations) — use this when the process must NOT advance on its own;
+     * `return-to-origin` goes back where it came from.
+     */
+    type?: StageExitType;
+    /**
+     * Symbolic target stage label — the routed destination for THIS exit row.
+     * Serialized as `exitToStageId` after label resolution; an unknown label is a
+     * hard error at compile.
+     *
+     * @remarks
+     * Multi-way branching: give the stage one `.exitWhen(...)` per outcome, each
+     * with its own rules and its own `exitToStage`. The destination stage still
+     * needs its own `entryWhen(...)`; routing does not bypass it. Note that
+     * `selected-stage-completed`/`-exited` name only the SOURCE STAGE, so several
+     * branches out of one stage produce the same entry rule at each destination —
+     * gate the destinations on the distinguishing task instead
+     * (`selected-tasks-completed`), not on the source stage alone.
+     */
+    exitToStage?: string;
+    /** Configure the runtime select-next-stage bridge for this `wait-for-user` exit. */
+    selectNextStage?: SelectNextStageSpec;
+    rules: CaseRule[][];
+}
+export interface BuiltTaskEntryCondition {
+    displayName?: string;
+    rules: CaseRule[][];
+}
+export interface BuiltCaseExitCondition {
+    displayName?: string;
+    marksCaseComplete?: boolean;
+    rules: CaseRule[][];
+}
+export type TaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management' | 'flow-process' | 'external-agent' | 'external-workflow' | 'action' | 'connector' | 'wait-for-timer' | 'wait-for-connector';
+/** Published-resource task kinds that the Case schema permits as unresolved skeletons. */
+export type UnresolvedReferenceTaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management';
+/**
+ * A `wait-for-connector` subscription: suspend on an Integration Service event.
+ * Omit `connectorKey`/`operation` for a bare **placeholder** (for a connector not
+ * yet registered — `data.uipath` carries only `serviceType`).
+ */
+export interface WaitConnectorPlaceholderSpec {
+    /** Connector key, e.g. `uipath-microsoft-outlook365`. */
+    connectorKey?: string;
+    /** Event operation, e.g. `EMAIL_RECEIVED`. */
+    operation?: string;
+}
+/**
+ * A placeholder connector/operation pair, or a library-resolved event
+ * subscription using the same symbolic shape as Flow `waitForEvent()`.
+ */
+export type WaitConnectorSpec = WaitConnectorPlaceholderSpec | EventSubscription;
+/**
+ * An Integration Service connector task — the connector variant of the shared
+ * `ActionSpec`.
+ *
+ * @remarks
+ * `ActionSpec` is the Flow action union; only its `kind: 'connector'` arm is
+ * reachable here, so it is documented in the Flow reference (`api.md`) rather
+ * than repeated in this one. Author a connector task with
+ * {@link TaskBuilder.connector}, which takes the descriptor and inputs directly.
+ */
+export type ConnectorSpecData = Extract<ActionSpec, {
+    kind: 'connector';
+}>;
+/** Whether an external Integration Service task blocks for its result or waits for a callback. */
+export type ExternalExecutionMode = 'sync' | 'async';
+/** Required wiring and typed inputs for an external agent/workflow invocation. */
+export interface ExternalTaskOptions<I extends Record<string, unknown>> {
+    /** Symbolic Integration Service connection name declared in `bindings.json`. */
+    connection: string;
+    /** Symbolic Orchestrator folder binding name declared in `bindings.json`. */
+    folder: string;
+    /** Closed runtime mode; each family lowers this to its exact supported service type. */
+    mode: ExternalExecutionMode;
+    /** Inputs statically checked by the generated connector descriptor. */
+    inputs: I;
+}
+/** Normalized descriptor and execution mode stored on a built external task. */
+export interface ExternalTaskSpecData {
+    /** Requested blocking or callback execution mode. */
+    mode: ExternalExecutionMode;
+    /** Shared connector action identity, inputs, and symbolic bindings. */
+    connector: ConnectorSpecData;
+}
+export interface TaskRef {
+    name: string;
+    folderPath: string;
+}
+/**
+ * Action-task recipient type. `2` = a single user by email — the only value the
+ * platform corpus exercises for case action tasks; `0`/`1`/`3` are reserved for
+ * other assignee kinds. A bare email string on `.action({ recipient })` becomes
+ * `{ type: 2, value: email }`.
+ */
+export type RecipientType = 0 | 1 | 2 | 3;
+/**
+ * One field of an Action Center task's form. **Inputs** are read-only context the
+ * assignee sees; **outputs** are the values they fill in. Emitted as a schema
+ * `InputOutput` row under `data.inputs[]` / `data.outputs[]`.
+ *
+ * @remarks
+ * `required: true` means this serialized row must already hold a non-empty
+ * `value`; it does not mean that the reviewer must fill the field. The source
+ * checker and `uip maestro case validate` both reject an empty required row with
+ * `EMPTY_REQUIRED_FIELD`. Reviewer input is still modeled by placing the field
+ * in `outputs` rather than `inputs`.
+ */
+export interface ActionField {
+    /** Field key. */
+    name: string;
+    /** Field type (default `string`). */
+    type?: TypeDesc;
+    /** UI control subtype, for example `dropdown`. */
+    subType?: string;
+    /** Human-facing label (defaults to `name` in the UI when omitted). */
+    displayName?: string;
+    /** Input literal/expression, or the readable variable name for an output field. */
+    value?: string;
+    /** Require `value` to be non-empty at validation time. */
+    required?: boolean;
+    /** Dropdown choices, using the product's lower-case `{ value, label }` shape. */
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+export interface ActionSpecData {
+    title?: string;
+    priority?: 'Low' | 'Medium' | 'High' | 'Critical';
+    recipient?: {
+        type: RecipientType;
+        value: string;
+    };
+    /** Action Center labels (persisted as a single `data.labels` string). */
+    labels?: string;
+    /** The Action Center action-app / catalog this task instantiates. */
+    actionCatalogName?: string;
+    /** Read-only context fields the assignee sees (`data.inputs[]`). */
+    inputs?: ActionField[];
+    /** Fields the assignee fills in (`data.outputs[]`). */
+    outputs?: ActionField[];
+}
+/** Exactly one product-supported timer value. */
+export type TimerSpecData = {
+    duration: string;
+    date?: never;
+    cycle?: never;
+} | {
+    duration?: never;
+    date: string;
+    cycle?: never;
+} | {
+    duration?: never;
+    date?: never;
+    cycle: string;
+};
+/** A task input binding: a resource input parameter set to a literal or a `=`-expression. */
+export interface TaskInputBinding {
+    /** The resource's input parameter name. */
+    name: string;
+    /** The bound value — a literal, `=vars.<name>`, or a `=js:` expression. */
+    value: string;
+    type: TypeDesc;
+}
+/**
+ * A task output extraction: bind a field of the task's result (`source`) into a
+ * case variable (`var`) that later tasks/conditions read as `=vars.<var>`.
+ */
+export interface TaskOutputBinding {
+    /** The case-variable name the field feeds (read downstream as `=vars.<var>`). */
+    var: string;
+    /** The source field expression, e.g. `=response` or `=Error.Message`. */
+    source: string;
+    type: TypeDesc;
+}
+export interface BuiltTask {
+    /** Task key + display name (also the handle used by `selected-tasks-completed`). */
+    name: string;
+    kind: TaskKind;
+    ref?: TaskRef;
+    action?: ActionSpecData;
+    connector?: ConnectorSpecData;
+    /** Descriptor-resolved external agent/workflow configuration. */
+    external?: ExternalTaskSpecData;
+    timer?: TimerSpecData;
+    /** wait-for-connector task: the event subscription (placeholder when key/operation omitted). */
+    waitConnector?: WaitConnectorSpec;
+    required?: boolean;
+    runOnce?: boolean;
+    description?: string;
+    skip?: string;
+    /** Reference-mode task input bindings (`data.inputs[]`). */
+    inputs?: TaskInputBinding[];
+    /** Reference-mode task output extractions (`data.outputs[]` + a readable case-variable companion). */
+    outputs?: TaskOutputBinding[];
+    entry: BuiltTaskEntryCondition[];
+}
+export interface BuiltStage {
+    label: string;
+    exception: boolean;
+    description?: string;
+    required?: boolean;
+    lanes: BuiltTask[][];
+    entry: BuiltEntryCondition[];
+    exit: BuiltExitCondition[];
+    slaRules: BuiltSla[];
+}
+/**
+ * A structured (object/array) variable type + its JSON-schema `body`, as returned
+ * by {@link jsonSchema}. Persists as `type: 'jsonSchema'` with the object/array
+ * shape carried in `body.type`.
+ */
+export interface JsonSchemaType {
+    type: 'jsonSchema';
+    body: unknown;
+}
+/**
+ * Declare a structured (object/array) variable type. Pass the JSON schema — object
+ * vs array is `body.type`. Use in `.var()`/`.input()`/`.output()` where a
+ * {@link TypeDesc} is expected.
+ *
+ * @example
+ * **Declare an object variable and an array variable**
+ * ```ts
+ * .var('caseData', jsonSchema({ type: 'object', properties: { status: { type: 'string' } } }))
+ * .var('attachments', jsonSchema({ type: 'array', items: { type: 'string' } }))
+ * ```
+ *
+ * @param body - The JSON schema. Its `type` decides object vs array.
+ * @returns A type descriptor for `.var()` / `.input()` / `.output()`.
+ */
+export declare function jsonSchema(body: unknown): JsonSchemaType;
+export interface CaseVarDecl {
+    name: string;
+    type: TypeDesc;
+    direction: 'in' | 'out' | 'inout';
+    default?: unknown;
+    /** For `type: 'jsonSchema'` — the structured var's JSON-schema `body`. */
+    body?: unknown;
+    /**
+     * In-args only: the trigger this argument is bound to (its value arrives when
+     * that trigger fires). Set via `.input(shape, { from })`. When present, the arg
+     * emits the full three-entry binding (formal slot + companion + trigger-output
+     * bridge); when absent it stays a bare declaration.
+     */
+    sourceTrigger?: BuiltTrigger;
+}
+/** A value displayed in one Case App section. Nested objects and arrays are not supported by the Case App client. */
+export type CaseAppDetailValue = string | number | boolean | null;
+/** One summary section in the generated Case App. */
+export interface CaseAppSection {
+    /** Stable wire identity. Omit it to generate a deterministic id from the section's position and title. */
+    id?: string;
+    /** Heading shown above the section's details. */
+    title: string;
+    /** At most six primitive values. The serializer writes this map as the JSON-encoded wire string. */
+    details: Record<string, CaseAppDetailValue>;
+}
+/** Typed configuration for the generated Case App. */
+export interface CaseAppConfig {
+    /** Case summary expression or literal displayed by the Case App. */
+    summary: string;
+    /** Detail sections displayed by the Case App. */
+    sections: CaseAppSection[];
+}
+/** Designer-only fields the shipped Case transformer moves into `layout.nodes[id]`. */
+export interface CaseNodeLayout {
+    /** Absolute canvas position. */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Canvas style values retained by the Case designer. */
+    style?: Record<string, string | number>;
+    /** Size measured by the canvas renderer. */
+    measured?: {
+        width: number;
+        height: number;
+    };
+    /** Explicit canvas width. */
+    width?: number;
+    /** Explicit canvas height. */
+    height?: number;
+    /** Canvas stacking order. */
+    zIndex?: number;
+}
+/**
+ * Optional Case designer layout, keyed by author-level stage and trigger names.
+ * Serialization resolves those names to final node ids after preservation has
+ * restored foreign identities. Omitted entries retain their existing/default
+ * layout; authored fields override only the same fields on a preserved entry.
+ */
+export interface CaseLayout {
+    /** Stage node layout keyed by the exact stage label passed to `.stage()`. */
+    stages?: Record<string, CaseNodeLayout>;
+    /** Trigger node layout keyed by its display name (`Trigger 1` for the default). */
+    triggers?: Record<string, CaseNodeLayout>;
+}
+export interface BuiltCase {
+    id: string;
+    name: string;
+    /**
+     * The Case JSON format version the document declares — the serializer's write
+     * version unless `.schemaVersion()` declared one of the (currently one) other
+     * writable versions. `readonly` because it is a grammar claim about the
+     * emitted document, not an author release value.
+     */
+    readonly version: string;
+    description?: string;
+    identifier: string;
+    identifierType: 'constant' | 'external';
+    caseAppEnabled: boolean;
+    caseAppConfig?: CaseAppConfig;
+    /** Whether optional tasks with an `adhoc` entry rule may be started on demand. */
+    allowAdhocOptionalStageTasks?: boolean;
+    vars: CaseVarDecl[];
+    stages: BuiltStage[];
+    caseExit: BuiltCaseExitCondition[];
+    slaRules: BuiltSla[];
+    /** Empty = the default single manual trigger. */
+    triggers: BuiltTrigger[];
+    /** Optional designer layout, resolved to final node ids by the serializer. */
+    layout?: CaseLayout;
+}
+/** Options common to a stage/task entry condition. */
+export interface EntryOpts {
+    /**
+     * Names the condition. Omit it and the name is derived from the owner —
+     * `"<stage> entry"` / `"<task> entry"` — because `uip maestro case validate`
+     * requires condition names to be unique across the whole case and rejects a
+     * repeat as `CASE_MGMT_RULE_NAME_DUPLICATE`, at error severity. A name given
+     * here is emitted verbatim; duplicating one is reported by `case check` as
+     * `DUP_RULE_NAME`.
+     */
+    displayName?: string;
+    isInterrupting?: boolean;
+}
+/** Options for `stage.exitWhen(rules, opts)` — one call per outcome. */
+export interface ExitOpts {
+    /**
+     * Names the condition. Omit it and the name is derived from the owner —
+     * `"<stage> complete"`, or `"<stage> exit"` when this exit does not mark the
+     * stage complete. See {@link EntryOpts.displayName} for why the default is
+     * derived rather than constant.
+     */
+    displayName?: string;
+    /** Mark the stage complete on this exit. Every stage needs at least one. */
+    marksStageComplete?: boolean;
+    /**
+     * `wait-for-user` holds the case until a person chooses the onward path — use it
+     * when the process must not advance by itself. See {@link StageExitType}.
+     */
+    type?: StageExitType;
+    /**
+     * Route this exit to a named stage (a stage LABEL). For multi-way branching give
+     * the stage one `.exitWhen(...)` per outcome, each with its own rules and
+     * `exitToStage` — including backward edges (returning to an earlier stage is just
+     * an exit that routes there).
+     *
+     * @remarks
+     * The destination still evaluates its own `entryWhen(...)`. At the product pin,
+     * `selected-tasks-completed` is valid at stage entry when its `{ tasks: [...] }`
+     * payload resolves; use it when a source-stage task identifies the branch. The
+     * checker validates those task references separately from placement legality.
+     * For a human-chosen path use `type: 'wait-for-user'` here plus a
+     * `user-selected-stage` entry on each destination.
+     */
+    exitToStage?: string;
+    /**
+     * Enable the runtime select-next-stage API for this `wait-for-user` exit.
+     * `objectName` is the Data Fabric entity that receives `{ instanceId, nextStage }`.
+     */
+    selectNextStage?: SelectNextStageSpec;
+}
+declare class TaskBuilder {
+    private readonly _name;
+    private _kind?;
+    private _ref?;
+    private _action?;
+    private _connector?;
+    private _external?;
+    private _timer?;
+    private _waitConnector?;
+    private _required?;
+    private _runOnce?;
+    private _description?;
+    private _skip?;
+    private _inputs?;
+    private _outputs?;
+    private readonly _entry;
+    constructor(_name: string);
+    private setKind;
+    private reference;
+    /**
+     * Reference a published Maestro process.
+     *
+     * @param name - The published process's name.
+     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @returns This builder, so calls chain.
+     */
+    process(name: string, opts?: {
+        folder?: string;
+    }): this;
+    /**
+     * Preserve an explicitly unresolved published-resource task as a typed
+     * skeleton whose serialized `data` is `{}`.
+     *
+     * @remarks
+     * Use this only when the requested resource identity cannot be resolved.
+     * Do not invent a name or folder. An unresolved task cannot declare input or
+     * output bindings because there is no referenced contract to bind against.
+     *
+     * @param kind - The published-resource family to preserve.
+     * @returns This builder, so calls chain.
+     */
+    unresolved(kind: UnresolvedReferenceTaskKind): this;
+    /**
+     * Reference a published agent.
+     *
+     * @param name - The published agent's name.
+     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @returns This builder, so calls chain.
+     */
+    agent(name: string, opts?: {
+        folder?: string;
+    }): this;
+    /**
+     * Reference a published RPA process.
+     *
+     * @param name - The published RPA process's name.
+     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @returns This builder, so calls chain.
+     */
+    rpa(name: string, opts?: {
+        folder?: string;
+    }): this;
+    /**
+     * Reference a published API workflow.
+     *
+     * @param name - The published API workflow's name.
+     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @returns This builder, so calls chain.
+     */
+    apiWorkflow(name: string, opts?: {
+        folder?: string;
+    }): this;
+    /**
+     * Reference another published case (a **sub-case**). Pass data into the child
+     * with `.inputs({...})` and read results back with `.outputs({...})` — the same
+     * io-binding as reference-mode tasks.
+     *
+     * @param name - The published child case's name.
+     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @returns This builder, so calls chain.
+     */
+    caseManagement(name: string, opts?: {
+        folder?: string;
+    }): this;
+    /**
+     * Reference a published Maestro Flow.
+     *
+     * @param name - The published Flow's name.
+     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @returns This builder, so calls chain.
+     */
+    flowProcess(name: string, opts?: {
+        folder?: string;
+    }): this;
+    private external;
+    /**
+     * Invoke an external agent through its generated Integration Service descriptor.
+     *
+     * @param descriptor - An `AgentExecution` operation from a generated connector module.
+     * @param opts - Required connection/folder bindings, sync/async mode, and descriptor-typed inputs.
+     * @returns This builder, so calls chain.
+     */
+    externalAgent<I extends Record<string, unknown>, O>(descriptor: ConnectorDescriptor<I, O>, opts: ExternalTaskOptions<I>): this;
+    /**
+     * Invoke an external workflow through its generated Integration Service descriptor.
+     *
+     * @param descriptor - A `ProcessExecution` operation from a generated connector module.
+     * @param opts - Required connection/folder bindings, sync/async mode, and descriptor-typed inputs.
+     * @returns This builder, so calls chain.
+     */
+    externalWorkflow<I extends Record<string, unknown>, O>(descriptor: ConnectorDescriptor<I, O>, opts: ExternalTaskOptions<I>): this;
+    /**
+     * An Action Center human task. `recipient` may be an email (→ Type 2) or
+     * `{ type, value }`. `inputs`/`outputs` declare the task's form fields — inputs
+     * are read-only context the assignee sees, outputs are what they fill in.
+     * `labels` and `actionCatalogName` tag the task and name its action app.
+     *
+     * @param spec - The human task: its `title`, `priority`, `recipient`, and the `inputs` / `outputs` its form shows and collects.
+     * @returns This builder, so calls chain.
+     */
+    action(spec?: {
+        title?: string;
+        priority?: 'Low' | 'Medium' | 'High' | 'Critical';
+        recipient?: string | {
+            type: RecipientType;
+            value: string;
+        };
+        labels?: string;
+        actionCatalogName?: string;
+        inputs?: ActionField[];
+        outputs?: ActionField[];
+    }): this;
+    /**
+     * An Integration Service connector task — runs a connector activity (e.g. Slack
+     * `send-message-to-channel`) — the typed form, where a generated descriptor
+     * supplies the operation and its input types.
+     *
+     * @remarks
+     * Same surface as the Flow `connector()` action: pass a generated descriptor
+     * (typed inputs) or `key`/`action` strings, plus the connector inputs and
+     * `{ connection, folder }` bindings.
+     *
+     * @param descriptor - The generated operation, from a prepared connector module.
+     * @param inputs - The activity's inputs, typed by the descriptor.
+     * @param opts - Symbolic `connection` / `folder`, an action `version`, and the
+     * `object` a generic operation addresses.
+     * @returns This builder, so calls chain.
+     */
+    connector<I extends Record<string, unknown>, O>(descriptor: ConnectorDescriptor<I, O>, inputs: I, opts?: ConnectorOpts): this;
+    /**
+     * Stringly form, for a connector with no prepared module.
+     *
+     * @param key - The connector library key, e.g. `'uipath-salesforce-slack'`.
+     * @param action - The operation id, e.g. `'send-message-to-channel'`.
+     * @param inputs - The activity's inputs.
+     * @param opts - Symbolic `connection` / `folder`, an action `version`, and the
+     * `object` a generic operation addresses.
+     * @returns This builder, so calls chain.
+     */
+    connector(key: string, action: string, inputs?: Record<string, unknown>, opts?: ConnectorOpts): this;
+    /**
+     * A wait-for-connector task — suspend the stage until an Integration Service
+     * **event** fires. A generated descriptor supplies the connector/event identity;
+     * serialization resolves its full subscription through the connector library.
+     *
+     * @param descriptor - A generated connector-event descriptor.
+     * @param opts - Subscription scope plus symbolic connection/folder bindings.
+     * @returns This builder, so calls chain.
+     */
+    waitForConnector<W extends Record<string, string>>(descriptor: TriggerDescriptor<W, unknown>, opts?: TriggerOptions<W>): this;
+    /**
+     * A wait-for-connector task in placeholder or stringly-resolved form.
+     *
+     * @param spec - Omit for a placeholder, pass `connectorKey`/`operation` for the legacy named placeholder,
+     * or pass a symbolic `{ connector, event, ... }` subscription for library resolution.
+     * @returns This builder, so calls chain.
+     */
+    waitForConnector(spec?: WaitConnectorSpec): this;
+    /**
+     * A wait-for-timer task (ISO-8601 `duration`, ISO `date`, or repeating `cycle`).
+     *
+     * @param spec - How long to wait: an ISO-8601 `duration`, a `date`, or a repeating `cycle`.
+     * @returns This builder, so calls chain.
+     */
+    waitForTimer(spec: TimerSpecData): this;
+    /**
+     * Mark this task required, so its stage cannot complete without it.
+     *
+     * @param value - Whether the task is required.
+     * @returns This builder, so calls chain.
+     */
+    required(value?: boolean): this;
+    /**
+     * Run this task at most once, even if its entry condition is met again.
+     *
+     * @param value - Whether the task runs only once.
+     * @returns This builder, so calls chain.
+     */
+    runOnce(value?: boolean): this;
+    /**
+     * Run this task again whenever its entry condition is met after stage re-entry.
+     * This is the semantic inverse of {@link TaskBuilder.runOnce} and emits an explicit
+     * `shouldRunOnlyOnce: false`.
+     *
+     * @returns This builder, so calls chain.
+     */
+    runOnReEntry(): this;
+    /**
+     * Describe this task.
+     *
+     * @param text - Prose the designer shows on the task.
+     * @returns This builder, so calls chain.
+     */
+    description(text: string): this;
+    /**
+     * Skip this task when the `=js:` expression is truthy.
+     *
+     * @param expression - An `=js:` expression; the task is skipped when it is truthy.
+     * @returns This builder, so calls chain.
+     */
+    skipWhen(expression: string): this;
+    /**
+     * Bind resource **input** parameters (reference-mode tasks). Each key is a
+     * declared input parameter name; each value is a literal, a case-variable read
+     * `=vars.<name>`, or a `=js:` expression. Pass `{ value, type }` to set a
+     * non-string type (default `string`).
+     *
+     * @param shape - Input parameter names to literals, case-variable references, or `{ value, type }`.
+     * @returns This builder, so calls chain.
+     */
+    inputs(shape: Record<string, string | {
+        value: string;
+        type?: TypeDesc;
+    }>): this;
+    /**
+     * Extract fields of the task's **result** into case variables (reference-mode
+     * tasks). Each key is the case-variable name a later task/condition reads as
+     * `=vars.<name>`; each value is the source field expression (e.g. `=response`,
+     * `=Error.Message`). Pass `{ source, type }` to set a non-string type. Emits a
+     * `data.outputs[]` row plus a root `inputOutputs` companion so the name resolves.
+     *
+     * @param shape - Case-variable names to the result field they take, or `{ source, type }`.
+     * @returns This builder, so calls chain.
+     */
+    outputs(shape: Record<string, string | {
+        source: string;
+        type?: TypeDesc;
+    }>): this;
+    /**
+     * Add a task-entry condition. Pass a nested array for the complete OR-of-AND grid.
+     *
+     * @param rules - One rule, an AND-group, or the complete OR-of-AND grid.
+     * @param opts - `displayName` for the condition.
+     * @returns This builder, so calls chain.
+     */
+    entryWhen(rules: CaseRuleGrid, opts?: {
+        displayName?: string;
+    }): this;
+    /** @internal */
+    _build(): BuiltTask;
+}
+declare class StageBuilder {
+    private readonly _label;
+    private readonly _exception;
+    private _description?;
+    private _required?;
+    private readonly _lanes;
+    private readonly _entry;
+    private readonly _exit;
+    private readonly _sla;
+    constructor(_label: string, _exception: boolean);
+    /**
+     * Describe this stage.
+     *
+     * @param text - Prose the designer shows on the stage.
+     * @returns This builder, so calls chain.
+     */
+    description(text: string): this;
+    /**
+     * Mark this stage required, so the case cannot complete without it.
+     *
+     * @param value - Whether the stage is required.
+     * @returns This builder, so calls chain.
+     */
+    required(value?: boolean): this;
+    /**
+     * Add a task. `fn` receives a task sub-builder. `lane` is the index of the
+     * task's SET in `data.tasks[][]` (default 0) and orders SEQUENTIAL sets — a
+     * task whose entry conditions are all `runs-sequentially` waits for the
+     * previous set. It does NOT make tasks parallel: every other task runs when
+     * its own entry condition fires, whatever set it sits in.
+     *
+     * Two tasks on `current-stage-entered` therefore convert to byte-identical
+     * scheduler rules whether they share a set or not, and the designer writes
+     * one task per set even for a stage its own SDD calls parallel.
+     *
+     * @param displayName - The task's display name.
+     * @param fn - Receives a sub-builder for what the task does.
+     * @param opts - `lane` is the task's set index in `data.tasks[][]` (default 0);
+     *   it orders `runs-sequentially` sets and is inert for every other task.
+     * @returns This builder, so calls chain.
+     */
+    task(displayName: string, fn: (t: TaskBuilder) => void, opts?: {
+        lane?: number;
+    }): this;
+    /**
+     * Add a stage-entry condition. Pass a nested array for the complete OR-of-AND grid.
+     *
+     * @param rules - One rule, an AND-group, or the complete OR-of-AND grid.
+     * @param opts - `displayName`, and the entry behaviour flags.
+     * @returns This builder, so calls chain.
+     */
+    entryWhen(rules: CaseRuleGrid, opts?: EntryOpts): this;
+    /**
+     * Add a stage-exit condition. Pass a nested array for the complete OR-of-AND grid.
+     *
+     * @param rules - One rule, an AND-group, or the complete OR-of-AND grid.
+     * @param opts - `displayName`, and whether meeting it completes the stage.
+     * @returns This builder, so calls chain.
+     */
+    exitWhen(rules: CaseRuleGrid, opts?: ExitOpts): this;
+    /**
+     * Set an SLA (deadline + escalations) on this stage. Call more than once for
+     * conditional SLAs (each with a `when` gate); the default SLA (no `when`) must
+     * be last.
+     *
+     * @param opts - The deadline, its escalations, and an optional `when` gate.
+     * @returns This builder, so calls chain.
+     */
+    sla(opts: SlaOpts): this;
+    /** @internal */
+    _build(): BuiltStage;
+}
+declare class CaseBuilder {
+    private readonly _id;
+    private _name;
+    private _authoredVersion?;
+    private _schemaVersion?;
+    private _description?;
+    private _identifier?;
+    private _identifierType;
+    private _caseApp;
+    private _caseAppConfig?;
+    private _allowAdhocTasks?;
+    private _layout?;
+    private readonly _vars;
+    private readonly _stages;
+    private readonly _caseExit;
+    private readonly _sla;
+    private readonly _triggers;
+    constructor(_id: string);
+    /**
+     * Set the case plan's display name.
+     *
+     * @param n - The name the designer shows.
+     * @returns This builder, so calls chain.
+     */
+    name(n: string): this;
+    /**
+     * Set the case plan's schema version during the compatibility window.
+     *
+     * @deprecated Use {@link CaseBuilder.schemaVersion}, which declares the same
+     * concept and accepts only versions this build can actually write. This call
+     * was never a switch: it recorded a requested version that `check()` then
+     * compared against the serializer's profile.
+     * @param v - The legacy requested schema version.
+     * @returns This builder, so calls chain.
+     */
+    version(v: string): this;
+    /**
+     * Declare the Case JSON SCHEMA version this plan targets.
+     *
+     * @remarks
+     * The top-level `version` of a `caseplan.json` is a claim that the whole
+     * document matches that grammar — `@uipath/case-schema` ships one closed
+     * schema per version — so this accepts only what the serializer can emit,
+     * currently `30.0.0` alone. Omit it and the plan declares the same thing;
+     * declaring it explicitly is what lets `case-decompile` PRESERVE the version
+     * it read rather than re-stamping the SDK's own default, so a later write-floor
+     * bump cannot silently upgrade a document a decompile already captured.
+     *
+     * Case has no `migrate` command: documents move forward on read, through the
+     * platform's feature-flag-gated chain. An older version is therefore refused
+     * with the reason rather than written onto V30 bytes.
+     *
+     * @example
+     * ```ts
+     * casePlan('claims').schemaVersion('30.0.0')
+     * ```
+     *
+     * @param version - A writable Case JSON schema version, e.g. `'30.0.0'`.
+     * @returns This builder, so calls chain.
+     * @throws Error when this SDK build cannot write `version`.
+     * @defaultValue `'30.0.0'` — `CASE_FORMAT_PROFILE.writeVersion`.
+     */
+    schemaVersion(version: string): this;
+    /**
+     * Describe the case plan.
+     *
+     * @param text - Prose the designer shows alongside the plan.
+     * @returns This builder, so calls chain.
+     */
+    description(text: string): this;
+    /**
+     * Set the runtime case identifier (constant prefix, or an `=`-expression when type is `external`).
+     *
+     * @param id - The prefix, or an `=`-expression when `type` is `'external'`.
+     * @param type - `'constant'` for a fixed prefix, `'external'` to compute it.
+     * @returns This builder, so calls chain.
+     */
+    identifier(id: string, type?: 'constant' | 'external'): this;
+    /**
+     * Turn the generated Case App on or off, or configure its summary and sections.
+     *
+     * Section `details` are authored as a map of at most six primitive values; the
+     * serializer JSON-encodes that map into the shipped wire string. Configuring a
+     * Case App enables it. The platform-owned Case App version markers are never
+     * inferred by this method.
+     *
+     * @example
+     * **Configure a summary and one detail section**
+     * ```ts
+     * .caseApp({
+     *   summary: '=js:vars.summary',
+     *   sections: [{ title: 'Amounts', details: { total: '=js:vars.total', urgent: true } }],
+     * })
+     * ```
+     *
+     * @param enabledOrConfig - A boolean toggle, or the typed Case App configuration.
+     * @returns This builder, so calls chain.
+     */
+    caseApp(enabledOrConfig?: boolean | CaseAppConfig): this;
+    /**
+     * Enable optional tasks whose entry rule is `adhoc`, allowing them to be
+     * started through the Case ad-hoc message contract.
+     *
+     * @param enabled - Whether ad-hoc optional-stage tasks are enabled.
+     * @returns This builder, so calls chain.
+     */
+    allowAdhocTasks(enabled?: boolean): this;
+    /**
+     * Set optional designer layout for stages and triggers by their author-level
+     * names. This metadata does not affect Case behavior. Unknown or ambiguous
+     * names fail serialization rather than being silently dropped.
+     *
+     * When editing a decompiled foreign Case, an authored field wins only for the
+     * named node and field; all other preserved layout bytes remain untouched.
+     *
+     * @example
+     * **Move a stage and a named trigger**
+     * ```ts
+     * .layout({
+     *   stages: { Intake: { position: { x: 160, y: 120 } } },
+     *   triggers: { 'Order received': { position: { x: 40, y: 120 } } },
+     * })
+     * ```
+     *
+     * @param layout - Stage and trigger layout keyed by their exact display names.
+     * @returns This builder, so calls chain.
+     */
+    layout(layout: CaseLayout): this;
+    /**
+     * Declare case In-args. Each value is a {@link TypeDesc}, or `{ type, default }`
+     * to set a default. Pass `{ from: <trigger> }` to bind the args to a trigger —
+     * their value arrives when it fires, readable as `=vars.<name>` — and they are
+     * projected into that trigger's `entry-points.json` input schema. A declared
+     * In-arg is readable as `=vars.<name>` (its `inputOutputs` companion resolves it).
+     *
+     * @example
+     * **Bind case In-args to a trigger's payload**
+     * ```ts
+     * const t = manualTrigger();
+     * casePlan('x').trigger(t)
+     *   .input({ claimId: 'string', riskScore: { type: 'float', default: '1.5' } }, { from: t })
+     * ```
+     *
+     * @param shape - In-arg names to types, or `{ type, default }`.
+     * @param opts - `{ from: <trigger> }` binds the args to a trigger's payload.
+     * @returns This builder, so calls chain.
+     */
+    input(shape: Record<string, TypeDesc | JsonSchemaType | {
+        type: TypeDesc;
+        default?: unknown;
+        body?: unknown;
+    }>, opts?: {
+        from?: BuiltTrigger;
+    }): this;
+    /**
+     * Declare case Out-args. Each value is a {@link TypeDesc}, or `{ type, default }`
+     * to set a default. Out-args are readable as `=vars.<name>` and projected into
+     * every trigger's `entry-points.json` output schema (with their default).
+     *
+     * @param shape - Out-arg names to types, or `{ type, default }`.
+     * @returns This builder, so calls chain.
+     */
+    output(shape: Record<string, TypeDesc | JsonSchemaType | {
+        type: TypeDesc;
+        default?: unknown;
+        body?: unknown;
+    }>): this;
+    /**
+     * Declare a read/write case variable.
+     *
+     * @remarks
+     * Readable from a `=js:vars.<name>` expression, like a trigger-bound In-arg.
+     *
+     * This comment used to say the opposite — that only `.input(shape, { from })`
+     * could be read, and that a bare `.var()` failed `uip maestro case validate`
+     * with "Variable 'vars.<name>' does not exist". That was true when written and
+     * stopped being true at #257, which made the serializer emit the `inputOutputs`
+     * companion (`id: <name>`, `elementId: "root"`) the platform resolves
+     * `vars.<name>` against. `check` carried a matching `VAR_NOT_REFERENCEABLE`
+     * error and dropped it for the same reason.
+     *
+     * Binding is about WHEN a value arrives, not whether it can be read. An
+     * UNDECLARED `vars.<x>` is still a hard error, thrown by `.build()`.
+     *
+     * @param name - The variable's name; read it as `=vars.<name>`.
+     * @param type - A `types.*` descriptor, or {@link jsonSchema} for a structured one.
+     * @param defaultValue - Its initial value. Non-string values are JSON-encoded
+     * before emission because the Case artifact contract stores every default as
+     * a string. Omit it to start unset.
+     * @returns This builder, so calls chain.
+     */
+    var(name: string, type: TypeDesc | JsonSchemaType, defaultValue?: unknown): this;
+    /**
+     * Add a case trigger (what starts the case). Call more than once for
+     * multiple triggers; the first is the primary. Omit entirely for the default
+     * single manual trigger. Build specs with {@link manualTrigger}/{@link timerTrigger}.
+     *
+     * @param t - A trigger from `manualTrigger` / `timerTrigger` / `eventTrigger`.
+     * @returns This builder, so calls chain.
+     */
+    trigger(t: BuiltTrigger): this;
+    /**
+     * Add a primary stage. `fn` receives a stage sub-builder.
+     *
+     * @param label - The stage's display name.
+     * @param fn - Receives a sub-builder for the stage's tasks and conditions.
+     * @returns This builder, so calls chain.
+     */
+    stage(label: string, fn: (s: StageBuilder) => void): this;
+    /**
+     * Add a secondary/exception stage (`case-management:Stage` with `data.stageType: "secondary"`).
+     *
+     * @param label - The stage's display name.
+     * @param fn - Receives a sub-builder for the stage's tasks and conditions.
+     * @returns This builder, so calls chain.
+     */
+    exceptionStage(label: string, fn: (s: StageBuilder) => void): this;
+    /**
+     * Add a case-completion rule (`metadata.caseExitRules`, `marksCaseComplete: true` by default).
+     *
+     * @param rules - One rule, an AND-group, or the complete OR-of-AND grid.
+     * @param opts - `displayName`, and whether meeting it completes the case.
+     * @returns This builder, so calls chain.
+     */
+    completeWhen(rules: CaseRuleGrid, opts?: {
+        displayName?: string;
+        marksCaseComplete?: boolean;
+    }): this;
+    /**
+     * Set a case-level SLA (deadline + escalations for the whole case), emitted to
+     * `metadata.slaRules`. Call more than once for conditional SLAs; the default
+     * (no `when`) must be last.
+     *
+     * @param opts - The deadline, its escalations, and an optional `when` gate.
+     * @returns This builder, so calls chain.
+     */
+    sla(opts: SlaOpts): this;
+    /**
+     * Finish the plan and return the description the serializer writes.
+     *
+     * @returns The built case — its stages, tasks, triggers and variables.
+     */
+    build(): BuiltCase;
+}
+/**
+ * Start building a case plan with the given id. (`casePlan`, not `case` — reserved word.)
+ *
+ * @param id - The plan's stable identifier.
+ * @returns A {@link CaseBuilder} to declare stages and tasks on.
+ */
+export declare function casePlan(id: string): CaseBuilder;