aspnetzero-workflow-designer 0.0.0-stage → 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1806 @@
+export declare const assigneePickerEditor: WorkflowInputEditor;
+
+export declare const ASSIGNMENT_TARGET_TYPE: {
+    readonly requesterManager: WorkflowAssignmentTargetType.RequesterManager;
+    readonly user: WorkflowAssignmentTargetType.User;
+    readonly role: WorkflowAssignmentTargetType.Role;
+    readonly organizationUnit: WorkflowAssignmentTargetType.OrganizationUnit;
+    readonly fallbackRole: WorkflowAssignmentTargetType.FallbackRole;
+};
+
+export declare function availablePalette(capabilities: WorkflowPaletteCapabilities): WorkflowNodePaletteItem[];
+
+/**
+ * The action parameter binding predates the syntax vocabulary and stores which of three fields is set
+ * rather than a syntax name. These two functions are the only place that mapping lives.
+ */
+export declare const BINDING_SOURCE_BY_SYNTAX: Record<string, string>;
+
+export declare function bindingSourceForSyntax(syntax: string): string;
+
+export declare function bindingSourceOf(binding: WorkflowActionInputBinding | undefined): WorkflowActionBindingSource;
+
+export declare function buildAssignmentTarget(type: number, selectedId: string): WorkflowAssignmentTargetValue;
+
+/**
+ * Authoring defaults a brand new node is seeded with. These mirror the `defaultValue`s the server
+ * declares on `WorkflowBuiltInActivityDescriptorProvider`, and the server's own
+ * `WorkflowActivityDefaultsContract_Tests` reads this file and fails when the two drift — it is the
+ * only place the two copies are compared, so a node type added on one side alone is caught there.
+ * The designer keeps a copy so it still authors correctly before the descriptor endpoint has
+ * answered, and so the demo works with no server at all.
+ */
+export declare const BUILT_IN_INPUT_DEFAULTS: Partial<Record<number, Record<string, unknown>>>;
+
+/**
+ * Full input sets for the node types whose property panel is already descriptor driven. Without these
+ * the panel would be empty until the descriptor endpoint answers. `WorkflowActivityDefaultsContract_Tests`
+ * keeps them in step with `WorkflowBuiltInActivityDescriptorProvider`.
+ */
+export declare const BUILT_IN_INPUTS: Partial<Record<number, WorkflowInputDescriptor[]>>;
+
+export declare function builtInActivityDescriptors(): WorkflowActivityDescriptor[];
+
+export declare function builtInDescriptorFor(type: number): WorkflowActivityDescriptor;
+
+export declare function builtInFormFieldDescriptors(): WorkflowFormFieldDescriptor[];
+
+export declare const channelEditor: WorkflowInputEditor;
+
+export declare const checkListEditor: WorkflowInputEditor;
+
+export declare function cloneDefaultValue(value: unknown): unknown;
+
+export declare function conditionOperatorsFor(valueType: WorkflowConditionValueType): WorkflowConditionOperator[];
+
+export declare const connectionDropDownEditor: WorkflowInputEditor;
+
+export declare function createEmptyForm(): WorkflowFormDocument;
+
+export declare function createEmptyGraph(): WorkflowGraphDocument;
+
+export declare function createLookupDropDownEditor(hint: string): WorkflowInputEditor;
+
+export declare const DEFAULT_THEME: Required<WorkflowThemeTokens>;
+
+export declare function defineWorkflowDesignerElements(): void;
+
+export declare function describeAssignmentTarget(target: WorkflowAssignmentTargetValue, localize: (key: string, fallback?: string) => string, nameOf?: (providerName: string, id: string) => string | undefined): string;
+
+export declare function descriptionKeyForNodeType(type: number): string;
+
+/**
+ * The empty entry lets an author clear an optional choice, or shows that a required one has not been
+ * made yet. A select that must hold a value (required, or with a declared default) and already holds one
+ * of its options has nothing to clear, so offering a blank row there only invites an invalid value.
+ */
+export declare function dropDownNeedsEmptyOption(context: WorkflowInputEditorContext): boolean;
+
+export declare function edgeKindPresentation(kind: WorkflowEdgeKind | number | undefined): {
+    key: string;
+    fallback: string;
+    color: string;
+};
+
+/**
+ * The key a form field gets from its label: camelCase, ASCII letters and digits only, starting with a
+ * letter, and unique among `existingKeys` (compared ignoring case) by appending 2, 3, ... An empty or
+ * symbol-only label yields `field`.
+ */
+export declare function fieldKeyFromLabel(label: string | undefined, existingKeys?: Iterable<string>): string;
+
+export declare const fieldMappingTableEditor: WorkflowInputEditor;
+
+export declare function findGraphOptionsResolver(providerName: string | undefined): GraphOptionsResolver | undefined;
+
+export declare function findInputEditor(hint: string | undefined): WorkflowInputEditor | undefined;
+
+/**
+ * Form fields come from the form document rather than the graph, so the designer element resolves
+ * this one itself; it is named here so both halves agree on the string the server sends.
+ */
+export declare const FORM_FIELD_OPTIONS_PROVIDER = "workflow.formFields";
+
+export declare function formFieldTypeNames(): {
+    type: WorkflowFormFieldType;
+    name: string;
+}[];
+
+export declare function fromLocalDateTimeInputValue(value: string): string | undefined;
+
+export declare const GRAPH_OPTIONS_PROVIDERS: {
+    readonly parallelNodes: "workflow.graph.parallelNodes";
+    readonly joinNodes: "workflow.graph.joinNodes";
+};
+
+export declare type GraphOptionsResolver = (graph: WorkflowGraphDocument, currentNodeId: string) => WorkflowInputOption[];
+
+export declare function inputCategoriesOf(inputs: WorkflowInputDescriptor[]): string[];
+
+export declare function isEdgeKindAllowed(type: number, kind: WorkflowEdgeKind): boolean;
+
+export declare function isGraphOptionsProvider(providerName: string | undefined): boolean;
+
+export declare function isInputVisible(descriptor: WorkflowInputDescriptor, owner: unknown): boolean;
+
+export declare function isListConditionOperator(value: WorkflowConditionOperator): boolean;
+
+export declare function isMultiValuedConditionValueType(value: WorkflowConditionValueType): boolean;
+
+export declare function isOrderConditionOperator(value: WorkflowConditionOperator): boolean;
+
+/** The code without its `WorkflowValidation_` prefix, so the families above read naturally. */
+export declare function issueCodeFamily(issue: WorkflowValidationIssue): string;
+
+/**
+ * Resolves what an issue points at. A field wins over a step (an issue raised on both is about the
+ * field), a start-trigger issue goes to the trigger tab, and a transition issue selects the transition
+ * on the canvas. Ids that neither document knows yield `undefined`, so a stale issue focuses nothing.
+ */
+export declare function issueFocusTargetOf(issue: WorkflowValidationIssue | undefined, graph: WorkflowGraphDocument | undefined, form: WorkflowFormDocument | undefined): WorkflowIssueFocusTarget | undefined;
+
+/** The step input a validation issue is about, when its code identifies one. */
+export declare function issueInputName(issue: WorkflowValidationIssue): string | undefined;
+
+export declare function issuesFor(issues: WorkflowValidationIssue[] | undefined, predicate: (issue: WorkflowValidationIssue) => boolean): WorkflowValidationIssue[];
+
+export declare function isTriggerIssue(issue: WorkflowValidationIssue): boolean;
+
+export declare function isUnaryConditionOperator(value: WorkflowConditionOperator): boolean;
+
+export declare function isUnknownDescriptor(descriptor: WorkflowActivityDescriptor | undefined): boolean;
+
+export declare function knownInputEditorHints(): string[];
+
+export declare const LOCALIZABLE_TEXT_TYPE_NAME = "WorkflowLocalizableText";
+
+export declare function localizableText(value: string): WorkflowLocalizableText;
+
+export declare function localizationKeyForFieldType(type: WorkflowFormFieldType): string;
+
+export declare function localizationKeyForNodeType(type: number): string;
+
+export declare function localize(dictionary: WorkflowLocalizationDictionary | undefined, key: string, fallback?: string): string;
+
+export declare function needsSyntaxPicker(descriptor: WorkflowInputDescriptor): boolean;
+
+export declare const NODE_CATEGORY_DEFINITIONS: WorkflowNodeCategoryDefinition[];
+
+export declare const NODE_PALETTE: WorkflowNodePaletteItem[];
+
+export declare function nodeTypeNames(): {
+    type: WorkflowNodeType;
+    name: string;
+}[];
+
+export declare function optionsProviderForTarget(type: number): string | undefined;
+
+export declare function orderedInputs(inputs: WorkflowInputDescriptor[]): WorkflowInputDescriptor[];
+
+export declare function outcomeOf(type: number, kind: WorkflowEdgeKind): WorkflowNodeOutcome | undefined;
+
+export declare function outcomesFromPorts(ports: WorkflowPortDescriptor[] | undefined): WorkflowNodeOutcome[];
+
+export declare function outcomesOf(type: number): WorkflowNodeOutcome[];
+
+export declare function paletteItemFor(type: number): WorkflowNodePaletteItem;
+
+export declare function paletteItemOf(descriptor: WorkflowActivityDescriptor): WorkflowNodePaletteItem;
+
+export declare function presentationFor(descriptor: WorkflowActivityDescriptor | undefined): WorkflowActivityPresentation;
+
+export declare function readInputValue(source: unknown, path: string): unknown;
+
+export declare function registerActivityPresentation(type: number, presentation: WorkflowActivityPresentation): void;
+
+export declare function registerGraphOptionsResolver(providerName: string, resolver: GraphOptionsResolver): void;
+
+export declare function registerInputEditor(editor: WorkflowInputEditor): void;
+
+export declare function renderSyntaxPicker(options: SyntaxPickerRenderOptions): string;
+
+export declare function resolveInputEditor(descriptor: WorkflowInputDescriptor): WorkflowInputEditor;
+
+export declare function resolveTheme(tokens: WorkflowThemeTokens | undefined): Required<WorkflowThemeTokens>;
+
+export declare const RICH_INPUT_EDITORS: WorkflowInputEditor[];
+
+export declare function schemaVersionMismatchOf(serverVersion: number | undefined, designerVersion: number): WorkflowSchemaVersionMismatch | undefined;
+
+export declare function storedInputValue(input: WorkflowInputDescriptor, value: unknown, current: unknown): unknown;
+
+export declare function syntaxForBindingSource(source: string): string;
+
+export declare function syntaxOptionsOf(descriptor: WorkflowInputDescriptor): WorkflowSyntaxOption[];
+
+export declare interface SyntaxPickerRenderOptions {
+    options: WorkflowSyntaxOption[];
+    selected: string;
+    disabled: boolean;
+    className: string;
+    localize: (key: string, fallback?: string) => string;
+    escape: (value: string) => string;
+}
+
+/** Only users are looked up by name as the author types; every other lookup is a short, complete list. */
+export declare function targetHasSearch(type: number): boolean;
+
+export declare function targetNeedsLookup(type: number): boolean;
+
+export declare function textOf(value: WorkflowLocalizableText | undefined, fallback?: string): string;
+
+export declare function themeToCssVariables(theme: Required<WorkflowThemeTokens>): string;
+
+export declare function toLocalDateTimeInputValue(value: unknown): string;
+
+export declare const UNKNOWN_PRESENTATION: WorkflowActivityPresentation;
+
+export declare function unknownActivityDescriptor(type: number, observedPorts?: WorkflowPortDescriptor[]): WorkflowActivityDescriptor;
+
+export declare function valueTypeOfFieldType(fieldType: WorkflowFormFieldType): WorkflowConditionValueType;
+
+export declare function visibleInputs(inputs: WorkflowInputDescriptor[], owner: unknown): WorkflowInputDescriptor[];
+
+/**
+ * Reads Elsa-style `UISpecifications`. The server serializes this dictionary with the keys exactly as
+ * they were registered (`VisibleWhen`, `Input`, `EqualsAnyOf`, ...) rather than camel-casing them, so
+ * they are matched case-insensitively here instead of assuming either casing.
+ */
+export declare function visibleWhenRuleOf(descriptor: WorkflowInputDescriptor): WorkflowVisibleWhenRule | undefined;
+
+/** Mirrors WorkflowChannel in the C# contract. */
+export declare const WORKFLOW_CHANNEL: {
+    readonly inApp: 1;
+    readonly email: 2;
+    readonly teams: 3;
+    readonly slack: 4;
+};
+
+export declare const WORKFLOW_DESIGNER_EVENTS: {
+    readonly documentChange: "document-change";
+    readonly selectionChange: "selection-change";
+    readonly command: "command";
+    /** `focusValidationIssue` resolved an issue; the detail says which host tab shows it. */
+    readonly issueFocus: "issue-focus";
+};
+
+export declare const WORKFLOW_DESIGNER_TAG = "workflow-designer";
+
+export declare const WORKFLOW_EXPRESSION_SYNTAX: {
+    readonly literal: "Literal";
+    readonly formField: "FormField";
+    readonly context: "Context";
+    readonly variable: "Variable";
+    readonly output: "Output";
+    readonly condition: "Condition";
+    readonly template: "Template";
+    readonly secret: "Secret";
+};
+
+export declare const WORKFLOW_FORM_BUILDER_TAG = "workflow-form-builder";
+
+export declare const WORKFLOW_FORM_SCHEMA_VERSION = 1;
+
+export declare const WORKFLOW_GRAPH_SCHEMA_VERSION = 3;
+
+export declare const WORKFLOW_UI_HINTS: {
+    readonly singleLine: "singleline";
+    readonly multiLine: "multiline";
+    readonly checkbox: "checkbox";
+    readonly checkList: "checklist";
+    readonly radioList: "radiolist";
+    readonly dropDown: "dropdown";
+    readonly multiText: "multitext";
+    readonly dictionary: "dictionary";
+    readonly jsonEditor: "json-editor";
+    readonly dateTimePicker: "datetime-picker";
+    readonly variablePicker: "variable-picker";
+    readonly outputPicker: "output-picker";
+    readonly outcomePicker: "outcome-picker";
+    readonly dynamicOutcomes: "dynamic-outcomes";
+    readonly workflowDefinitionPicker: "workflow-definition-picker";
+    readonly expressionEditor: "expression-editor";
+    readonly secretPicker: "secret-picker";
+    readonly connectionDropDown: "connection-dropdown";
+    readonly httpStatusCodes: "http-status-codes";
+    readonly assigneePicker: "assignee-picker";
+    readonly rolePicker: "role-picker";
+    readonly organizationUnitPicker: "organization-unit-picker";
+    readonly formFieldPicker: "form-field-picker";
+    readonly conditionBuilder: "condition-builder";
+    readonly fieldMappingTable: "field-mapping-table";
+    readonly slaEditor: "sla-editor";
+    readonly channelEditor: "channel-editor";
+    readonly adaptiveCardEditor: "adaptive-card-editor";
+    readonly eventPayloadMappingTable: "event-payload-mapping-table";
+    readonly actionParameterTable: "action-parameter-table";
+    readonly conditionBranchTable: "condition-branch-table";
+    readonly parallelBranchTable: "parallel-branch-table";
+    readonly startTriggerEditor: "start-trigger-editor";
+    readonly notificationRecipients: "notification-recipients";
+};
+
+export declare const WORKFLOW_VARIABLE_SCOPE: {
+    readonly instance: 1;
+    readonly branch: 2;
+};
+
+export declare type WorkflowActionBindingSource = 'constant' | 'formField' | 'context';
+
+export declare interface WorkflowActionDescriptor {
+    name?: string;
+    displayName?: string;
+    inputParameters?: WorkflowActionParameter[];
+    outputParameters?: WorkflowActionParameter[];
+}
+
+export declare interface WorkflowActionInputBinding {
+    inputName?: string;
+    formFieldId?: string;
+    contextKey?: string;
+    constantValue?: string;
+}
+
+export declare interface WorkflowActionNodeSettings {
+    kind?: number;
+    actionName?: string;
+    webhookName?: string;
+    connectionProfileName?: string;
+    relativePath?: string;
+    httpMethod?: string;
+    timeoutInSeconds?: number;
+    maxAttempts?: number;
+    continueOnFailure?: boolean;
+    inputBindings?: WorkflowActionInputBinding[];
+}
+
+export declare interface WorkflowActionParameter {
+    name?: string;
+    displayName?: string;
+    description?: string;
+    type: WorkflowActionParameterType;
+    isRequired?: boolean;
+    isSensitive?: boolean;
+    defaultValue?: string;
+    allowedValues?: WorkflowActionParameterOption[];
+    optionsProviderName?: string;
+    minValue?: number;
+    maxValue?: number;
+    maxLength?: number;
+    regexPattern?: string;
+    allowFormFieldBinding?: boolean;
+    allowInstanceBinding?: boolean;
+    group?: string;
+    displayOrder?: number;
+}
+
+export declare interface WorkflowActionParameterOption {
+    value?: string;
+    displayName?: string;
+    displayOrder?: number;
+}
+
+export declare enum WorkflowActionParameterType {
+    Text = 1,
+    Number = 2,
+    Boolean = 3,
+    Date = 4,
+    DateTime = 5,
+    UserId = 6,
+    Json = 7,
+    Secret = 8,
+    RoleId = 9,
+    OrganizationUnitId = 10,
+    ConnectionProfileId = 11,
+    Enum = 12
+}
+
+export declare interface WorkflowActivityDescriptor {
+    typeName: string;
+    namespace?: string;
+    name?: string;
+    version?: number;
+    category?: string;
+    displayName?: string;
+    description?: string;
+    inputs: WorkflowInputDescriptor[];
+    outputs?: WorkflowOutputDescriptor[];
+    ports: WorkflowPortDescriptor[];
+    kind?: number;
+    isBrowsable?: boolean;
+    isStart?: boolean;
+    isTerminal?: boolean;
+    isSingleton?: boolean;
+    isFanOut?: boolean;
+    isWaiting?: boolean;
+    runsInline?: boolean;
+    requiredPermission?: string;
+    requiredCapability?: string;
+    riskLevel?: number;
+    idempotencyPolicy?: number;
+    bpmnElementName?: string;
+    bpmnEventDefinition?: string;
+    legacyNodeType?: number;
+    customProperties?: Record<string, unknown>;
+}
+
+export declare interface WorkflowActivityPresentation {
+    category: WorkflowNodeCategory;
+    icon: string;
+    iconName?: string;
+    color: string;
+}
+
+export declare interface WorkflowApprovalNodeSettings {
+    targets?: WorkflowAssignmentTarget[];
+    fallbackTarget?: WorkflowAssignmentTarget;
+    approvalPolicy?: WorkflowApprovalPolicy;
+    rejectionPolicy?: WorkflowRejectionPolicy;
+    quorumCount?: number;
+    selfApprovalPolicy?: WorkflowSelfApprovalPolicy;
+    allowDelegation?: boolean;
+    allowRequestChanges?: boolean;
+    requireReasonOnApprove?: boolean;
+    requireReasonOnReject?: boolean;
+    requireReasonOnRequestChanges?: boolean;
+    readOnlyFieldIds?: string[];
+    hiddenFieldIds?: string[];
+}
+
+export declare enum WorkflowApprovalPolicy {
+    Anyone = 1,
+    Everyone = 2,
+    Quorum = 3
+}
+
+export declare interface WorkflowAssignmentTarget {
+    type: WorkflowAssignmentTargetType;
+    userId?: number;
+    roleId?: number;
+    organizationUnitId?: number;
+    includeChildOrganizationUnits?: boolean;
+    previousNodeId?: string;
+}
+
+export declare enum WorkflowAssignmentTargetType {
+    User = 1,
+    Role = 2,
+    OrganizationUnit = 3,
+    RequesterManager = 4,
+    RoleInRequesterOrganizationUnit = 5,
+    PreviousStepApprover = 6,
+    FallbackRole = 7
+}
+
+export declare interface WorkflowAssignmentTargetValue {
+    type: number;
+    userId?: number;
+    roleId?: number;
+    organizationUnitId?: number;
+    includeChildOrganizationUnits?: boolean;
+}
+
+export declare interface WorkflowAssistantContext {
+    graph: WorkflowGraphDocument;
+    form?: WorkflowFormDocument;
+}
+
+export declare enum WorkflowAuthoringOrigin {
+    Manual = 1,
+    Template = 2,
+    Bpmn = 3,
+    Ai = 4
+}
+
+export declare enum WorkflowChannel {
+    InApp = 1,
+    Email = 2,
+    Teams = 3,
+    Slack = 4
+}
+
+export declare interface WorkflowChannelSettings {
+    channels?: WorkflowChannel[];
+    connectionProfileName?: string;
+    allowDecisionFromChannel?: boolean;
+}
+
+export declare interface WorkflowConditionBranch {
+    id?: string;
+    name?: WorkflowLocalizableText;
+    order: number;
+    expression?: WorkflowConditionExpression;
+}
+
+export declare interface WorkflowConditionExpression {
+    kind: WorkflowConditionExpressionKind;
+    logicalOperator?: WorkflowConditionLogicalOperator;
+    children?: WorkflowConditionExpression[];
+    left?: WorkflowConditionOperand;
+    operator?: WorkflowConditionOperator;
+    right?: WorkflowConditionOperand;
+}
+
+export declare enum WorkflowConditionExpressionKind {
+    Group = 1,
+    Comparison = 2
+}
+
+export declare enum WorkflowConditionLogicalOperator {
+    And = 1,
+    Or = 2,
+    Not = 3
+}
+
+export declare interface WorkflowConditionNodeSettings {
+    branches?: WorkflowConditionBranch[];
+}
+
+export declare interface WorkflowConditionOperand {
+    type: WorkflowConditionOperandType;
+    valueType: WorkflowConditionValueType;
+    fieldId?: string;
+    contextKey?: string;
+    variableName?: string;
+    value?: string;
+    values?: string[];
+}
+
+export declare enum WorkflowConditionOperandType {
+    FormField = 1,
+    Constant = 2,
+    RequesterContext = 3,
+    TenantContext = 4,
+    SystemContext = 5,
+    /** A value a step wrote earlier in the run. */
+    Variable = 6
+}
+
+export declare enum WorkflowConditionOperator {
+    Equals = 1,
+    NotEquals = 2,
+    GreaterThan = 3,
+    GreaterOrEqual = 4,
+    LessThan = 5,
+    LessOrEqual = 6,
+    Contains = 7,
+    NotContains = 8,
+    In = 9,
+    NotIn = 10,
+    IsEmpty = 11,
+    IsNotEmpty = 12
+}
+
+export declare interface WorkflowConditionSuggestion {
+    succeeded: boolean;
+    expression?: WorkflowConditionExpression;
+    failureReason?: string;
+}
+
+export declare type WorkflowConditionSuggestionCallback = (ruleText: string, context: WorkflowAssistantContext) => Promise<WorkflowConditionSuggestion>;
+
+export declare enum WorkflowConditionValueType {
+    String = 1,
+    Number = 2,
+    Boolean = 3,
+    Date = 4,
+    Time = 5,
+    DateTime = 6,
+    Money = 7,
+    Duration = 8,
+    StringList = 9,
+    NumberList = 10
+}
+
+export declare const workflowDefinitionPickerEditor: WorkflowInputEditor;
+
+export declare interface WorkflowDesignerChangeDetail<TDocument> {
+    document: TDocument;
+    isDirty: boolean;
+}
+
+export declare interface WorkflowDesignerCommandDetail {
+    command: 'save' | 'validate' | 'simulate' | 'publish';
+}
+
+export declare class WorkflowDesignerElement extends WorkflowHostElement {
+    static get observedAttributes(): string[];
+    private _document;
+    private _form;
+    private _graph;
+    private _canvas;
+    private _selectedNodeId;
+    private _selectedNodeIds;
+    private _selectedEdgeId;
+    private _selectedBranchId;
+    private _isApplyingDocument;
+    private _past;
+    private _future;
+    private _fingerprint;
+    private _clipboard;
+    private _draggedType;
+    private readonly _paletteDrag;
+    private _paletteFilter;
+    private _inspectorTab;
+    private _outlineVisible;
+    private _executionStates;
+    private _secrets;
+    private _heatMap;
+    private _conditionSuggestionText;
+    private _assistantSummary?;
+    private _assistantSummaryBusy;
+    private _assistantSummaryError?;
+    private _conditionSuggestionBusy;
+    private _conditionSuggestionError?;
+    private _summaryCollapsed;
+    private _paletteCollapsed;
+    private _viewportPending;
+    private _pendingFit;
+    private _themeObserver;
+    private readonly _lookupNames;
+    private readonly _requestedNameLookups;
+    private _draggedActivity;
+    private readonly _serverOptions;
+    private readonly _serverOptionsPending;
+    private readonly _inflightLookups;
+    private _pendingFocus;
+    private _formBuilder;
+    /**
+     * The form builder editing this workflow's form, when the host has one. With it set,
+     * `focusValidationIssue` hands field issues straight to that element; without it the host does so
+     * itself from the `issue-focus` event.
+     */
+    get formBuilder(): WorkflowFormBuilderElement | undefined;
+    set formBuilder(value: WorkflowFormBuilderElement | undefined);
+    /**
+     * Shows what a validation issue is about. A step, transition or branch issue selects it on the
+     * canvas, opens the inspector tab holding the setting the issue names (for example Service level
+     * for an SLA issue) and pans the canvas until the step is visible. A field issue is handed to
+     * `formBuilder` when one is set, and a start-trigger issue is left to the host's trigger tab. In
+     * every case an `issue-focus` event tells the host which of its tabs (flow, form, trigger) to show.
+     * Returns `false` when neither document knows the ids the issue carries, so nothing was focused.
+     * Safe to call before the first render: the focus is applied as soon as the canvas exists.
+     */
+    focusValidationIssue(issue: WorkflowValidationIssue): boolean;
+    private applyIssueFocus;
+    /** The inspector tab that shows a step input, or General when the step has no tab for it. */
+    private inspectorTabForInput;
+    /**
+     * Pans the canvas until the step is inside the visible area. A canvas the host currently hides has
+     * no size, so the pan waits until it has one (the host is switching to the flow tab at this moment).
+     */
+    private revealNode;
+    get document(): WorkflowGraphDocument;
+    set document(value: WorkflowGraphDocument | undefined);
+    get executionStates(): WorkflowNodeExecutionState[];
+    /**
+     * The secrets this user may refer to, by name only. The host loads them; nothing here can ask for a
+     * value, which is what keeps a secret out of the designer altogether.
+     */
+    get secrets(): WorkflowSecretOption[];
+    set secrets(value: WorkflowSecretOption[] | undefined);
+    get heatMap(): WorkflowNodeHeat[];
+    set heatMap(value: WorkflowNodeHeat[] | undefined);
+    get isHeatMapView(): boolean;
+    get graphSchemaVersion(): number;
+    get activityDescriptors(): WorkflowActivityDescriptor[];
+    get availableActivityDescriptors(): WorkflowActivityDescriptor[];
+    descriptorForNode(node: WorkflowNodeDefinition): WorkflowActivityDescriptor;
+    descriptorFor(type: WorkflowNodeType): WorkflowActivityDescriptor;
+    private observedPortsOf;
+    private outcomesOf;
+    private paletteItemFor;
+    get schemaVersionMismatch(): WorkflowSchemaVersionMismatch | undefined;
+    private get slowestHeatSeconds();
+    private heatValueOf;
+    private heatStyleOf;
+    /** A node highlighted in a status colour: that colour as the border over a tint of it on the surface. */
+    private tintedState;
+    set executionStates(value: WorkflowNodeExecutionState[] | undefined);
+    get isExecutionView(): boolean;
+    get form(): WorkflowFormDocument | undefined;
+    set form(value: WorkflowFormDocument | undefined);
+    get selectedNodeId(): string | undefined;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected applyTheme(): void;
+    private observeThemeChanges;
+    undo(): void;
+    redo(): void;
+    addNode(type: WorkflowNodeType, position?: {
+        x: number;
+        y: number;
+    }, activityTypeName?: string): void;
+    private defaultNodePosition;
+    private applyNodeDefaults;
+    private pairWithNewJoinNode;
+    removeSelectedNode(): void;
+    renameSelectedNode(name: string): void;
+    setSelectedEdgeKind(edgeId: string, kind: WorkflowEdgeKind): void;
+    addBranch(nodeId: string): void;
+    removeBranch(nodeId: string, branchId: string): void;
+    moveBranch(nodeId: string, branchId: string, offset: number): void;
+    protected render(): void;
+    private handleShortcut;
+    private createGraph;
+    private countsTowardStepLimit;
+    private countedSteps;
+    private selectEdge;
+    private onNodeMoved;
+    private onSelectionChanged;
+    private applySelectionStyles;
+    private bindCanvasDropTarget;
+    private toGraphPoint;
+    private canConnect;
+    private resolveOutcomeKind;
+    private buildEdge;
+    private portIdFor;
+    private parsePortId;
+    private syncGraphFromDocument;
+    private canvasColors;
+    private nodeMetadataOf;
+    private nodeBodyAttrs;
+    private edgeStrokeWidth;
+    private canvasEdgeLabelOf;
+    private edgeMetadataOf;
+    private scheduleInitialFit;
+    private fitContentIfNeeded;
+    private executionStyleOf;
+    isUnreviewed(nodeId: string): boolean;
+    getUnreviewedNodeIds(): string[];
+    markNodeReviewed(nodeId: string): void;
+    suggestConditionForSelectedBranch(ruleText: string): Promise<void>;
+    private assistantContext;
+    private applySuggestedExpression;
+    private edgeOpacityOf;
+    private wasEdgeTaken;
+    private nodeHeightOf;
+    private outcomeRowsOf;
+    private outcomePortsOf;
+    private parallelEdgesOf;
+    private parallelPortId;
+    private portIdForEdge;
+    private buildPortsFor;
+    private applyViewport;
+    private captureViewport;
+    zoomIn(): void;
+    zoomOut(): void;
+    zoomToFit(): void;
+    resetZoom(): void;
+    select(nodeId: string): void;
+    selectAll(): void;
+    clearSelection(): void;
+    deleteSelection(): void;
+    removeEdge(edgeId: string): void;
+    copySelection(): void;
+    pasteClipboard(): void;
+    autoLayout(): void;
+    private layoutDepths;
+    private edgeLabelText;
+    private branchOf;
+    private renderSchemaVersionWarning;
+    private toolButton;
+    private renderToolbar;
+    private renderZoomControls;
+    /**
+     * The palette's heading and search box are built once and then only updated in place: rebuilding the
+     * search box on every keystroke is what made the caret jump to the start and typed text come out
+     * reversed. Only the list of matching steps below it is re-rendered.
+     */
+    private renderPalette;
+    private renderPaletteItems;
+    private bindVariablesPanel;
+    private updateVariables;
+    private nodeIconMarkup;
+    private renderInspector;
+    private renderEdgeInspector;
+    private renderConnectionsSection;
+    private inspectorTabsFor;
+    private renderCategorySettings;
+    private renderCapabilityBlockedMessage;
+    private _localEditors;
+    /**
+     * Editors that need this element's own state — the selected action's parameter descriptors, the
+     * form document, the host lookups, the graph's edges — cannot live in the shared module registry,
+     * which is a singleton. Keys are either a UI hint or a single input name; the name form lets one
+     * field of one node type be taken over.
+     */
+    private localEditors;
+    private editorFor;
+    private createActionParameterEditor;
+    /**
+     * The "when it times out" drop down carries a line of guidance that depends on whether a
+     * "Timed out" edge is drawn, so it is built here rather than by the shared drop down editor.
+     */
+    private createEventTimeoutEditor;
+    /**
+     * The condition builder keeps the branch list and the graph's branch edges in step, and drives the
+     * selected-branch state and the AI suggestion box, so it stays inside the element.
+     */
+    private createConditionBuilderEditor;
+    /**
+     * The service level editor reads the tenant's business calendar settings and the escalation target
+     * lookups, so like the other graph aware editors it stays inside the element.
+     */
+    private createSlaEditor;
+    private createEventPayloadMappingEditor;
+    private selectedNode;
+    private payloadTargetFields;
+    private renderEventPayloadMappings;
+    private bindEventPayloadMappings;
+    /**
+     * Writes one descriptor input by its path, creating the nested settings object when the document
+     * does not have it yet. This is the same write the generic panel performs.
+     */
+    updateNodeInput(nodeId: string, inputName: string, value: unknown): void;
+    private renderDescriptorInput;
+    private inputEditorContext;
+    /**
+     * Every output the graph publishes, from the descriptors of the steps that produce them. A step that
+     * has not been given a type yet publishes nothing, which is why this is derived rather than stored.
+     */
+    private stepOutputOptions;
+    /**
+     * Resolves a descriptor's named options provider. A host that ships the single `optionsProvider`
+     * callback answers everything; the older per-kind callbacks stay supported so a host does not have
+     * to migrate in the same release.
+     */
+    private resolveOptionsAsync;
+    /**
+     * Every render re-binds the inspector's pickers and each of them asks the host for its options, so
+     * opening a few dropdowns in a row (or a re-render while a lookup is still out) used to send the same
+     * request several times and stack up as many error toasts when it failed. An identical request that
+     * is still in flight is shared instead of being sent again.
+     */
+    private shareInflight;
+    private requestOptions;
+    private legacyLookupFor;
+    /**
+     * An input the document never stored falls back to the value the descriptor declares. Older graphs
+     * left these undefined and the hand written panels read them as "on", so without this a migrated
+     * checkbox would silently flip to off.
+     */
+    private readInputWithDefault;
+    private isDescriptorCapabilityBlocked;
+    private isCapabilityBlocked;
+    private resolveInputOptions;
+    private siblingValuesOf;
+    private serverProviderOptions;
+    private formFieldOptions;
+    private bindDescriptorSettings;
+    private bindSettingsSection;
+    private renderActionParameterSection;
+    private renderActionParameter;
+    private renderActionParameterEditor;
+    private renderTypedInput;
+    private bindActionParameterSection;
+    private fillActionParameterOptions;
+    private updateActionBinding;
+    private findActionBinding;
+    private actionParametersOf;
+    private groupActionParameters;
+    /**
+     * The syntaxes this parameter may be bound with, expressed as an input descriptor so the shared
+     * syntax picker can render it. A parameter that forbids form field or instance binding simply
+     * publishes a shorter list, which is the same mechanism the server uses on real descriptors.
+     */
+    private syntaxDescriptorFor;
+    private describeParameterConstraints;
+    private updateEventWait;
+    private updateAction;
+    private renderConditionSection;
+    private renderConditionAssistant;
+    private renderBranchEditor;
+    private renderSlaSection;
+    /**
+     * "Escalate after" and "Escalate to" only mean something once escalation is switched on, so they are
+     * not rendered (and the escalation target lookup is not run) until it is.
+     */
+    private renderSlaEscalation;
+    private escalationTargetContext;
+    private bindConditionSection;
+    private bindSlaSection;
+    private conditionFields;
+    private describeTarget;
+    private namedTarget;
+    private lookupName;
+    private rememberLookupNames;
+    private loadLookupNames;
+    /**
+     * A lookup answer can arrive while the user is typing into the inspector, so the re-render it causes
+     * keeps that input focused with its caret where it was.
+     */
+    private renderAfterLookup;
+    private updateBranch;
+    private updateNode;
+    private commit;
+    private hasIssue;
+    private nextNodeId;
+    private nextEdgeId;
+    private nextBranchId;
+    private normalizeDocument;
+    private fingerprintOf;
+    private emitChange;
+    private emitSelection;
+    private escape;
+    private renderSummary;
+    private renderAssistantSummary;
+    get assistantSummary(): string | undefined;
+    get assistantSummaryError(): string | undefined;
+    summarizeWithAssistant(): Promise<void>;
+    private buildSummarySentences;
+    private describeNode;
+    private format;
+    private renderOutline;
+    private outlineOrderedNodes;
+    private outlineOutcomeRows;
+    private setOutlineTarget;
+    togglePalette(): void;
+    private applyPaletteVisibility;
+    toggleOutline(): void;
+    private applyOutlineVisibility;
+}
+
+export declare interface WorkflowEdgeDefinition {
+    id: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    kind: WorkflowEdgeKind;
+    /** Reserved outcome key of the port this edge leaves from, written from schema version 3 onward. */
+    outcomeKey?: string;
+    branchId?: string;
+    label?: WorkflowLocalizableText;
+}
+
+export declare enum WorkflowEdgeKind {
+    Default = 1,
+    Approved = 2,
+    Rejected = 3,
+    ChangesRequested = 4,
+    ConditionBranch = 5,
+    Otherwise = 6,
+    ParallelBranch = 7,
+    TimerElapsed = 8,
+    SubprocessCompleted = 9,
+    SubprocessRejected = 10,
+    EventReceived = 11,
+    EventTimeout = 12
+}
+
+export declare enum WorkflowEventCorrelationSource {
+    BusinessKey = 1,
+    ReferenceNumber = 2,
+    FormField = 3
+}
+
+export declare interface WorkflowEventPayloadMapping {
+    sourcePath?: string;
+    targetFieldKey?: string;
+}
+
+export declare enum WorkflowEventTimeoutBehavior {
+    ContinueTimeoutPath = 1,
+    NeedsAttention = 2,
+    Cancel = 3
+}
+
+export declare interface WorkflowEventWaitNodeSettings {
+    eventName?: string;
+    correlationSource?: WorkflowEventCorrelationSource;
+    correlationFieldKey?: string;
+    timeout?: WorkflowSlaSettings;
+    onTimeout?: WorkflowEventTimeoutBehavior;
+    payloadMappings?: WorkflowEventPayloadMapping[];
+    waitingMessage?: WorkflowLocalizableText;
+}
+
+export declare interface WorkflowFieldMapping {
+    sourceFieldId?: string;
+    targetFieldKey?: string;
+}
+
+export declare interface WorkflowFieldMappingRow {
+    sourceFieldId?: string;
+    targetFieldKey?: string;
+}
+
+export declare class WorkflowFormBuilderElement extends WorkflowHostElement {
+    private _document;
+    private _selectedFieldId;
+    private _fingerprint;
+    private _pointerDown;
+    private _renderDeferred;
+    /**
+     * Fields added in this session whose key still follows their label. A key the user types by hand,
+     * and every key that came in with the document, stays as it is.
+     */
+    private readonly _keyFollowsLabel;
+    private _scrollToFieldId;
+    private readonly onPointerDown;
+    private readonly onPointerUp;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * Pressing a button while an input of the form still has focus commits that input first (its change
+     * event fires as focus leaves it), and that commit re-renders the form. Re-rendering between the
+     * button's pointerdown and its click replaces the button, so the click never arrives: deleting a
+     * section right after renaming it did nothing. While a pointer is down the re-render waits until
+     * the click has been handled.
+     */
+    protected requestRender(): void;
+    get fieldDescriptors(): WorkflowFormFieldDescriptor[];
+    get availableFieldDescriptors(): WorkflowFormFieldDescriptor[];
+    /**
+     * A file can only be collected through a public form, so the field is offered only when the host says
+     * this form is one (`publicFormEnabled: true`) and attachments are not switched off. Unlike the other
+     * capabilities, a host that says nothing about public forms does not get the field.
+     */
+    get fileAttachmentsAvailable(): boolean;
+    descriptorFor(type: WorkflowFormFieldType): WorkflowFormFieldDescriptor | undefined;
+    get document(): WorkflowFormDocument;
+    set document(value: WorkflowFormDocument | undefined);
+    /** Whether a field's key is still being filled in from its label (see `_keyFollowsLabel`). */
+    keyFollowsLabel(fieldId: string): boolean;
+    /**
+     * Shows the field a validation issue is about: selects it, scrolls its row into view and tells the
+     * host (through `issue-focus`) that the form tab is the one to show. Returns `false` when the issue
+     * does not name a field of this form. Safe to call before the element is connected: the selection
+     * is applied by the first render.
+     */
+    focusValidationIssue(issue: WorkflowValidationIssue): boolean;
+    get selectedFieldId(): string | undefined;
+    addSection(): void;
+    addField(type: WorkflowFormFieldType, parentFieldId?: string): void;
+    removeField(fieldId: string): void;
+    moveField(fieldId: string, delta: number): void;
+    renameSection(sectionId: string, title: string): void;
+    /**
+     * Removes a section without losing what is in it: its fields move to the section above it (or the
+     * one below when it was the first). Removing the last section leaves an unsectioned form, which is
+     * where a form without sections starts, so its fields simply lose their section.
+     */
+    removeSection(sectionId: string): void;
+    updateField(fieldId: string, changes: Partial<WorkflowFormFieldDefinition>): void;
+    protected render(): void;
+    private scrollToPendingField;
+    private fieldIconMarkup;
+    private fieldTypeLabel;
+    private inputLabel;
+    private renderLayout;
+    private renderFieldTree;
+    private renderFieldRow;
+    /** Why a field already on the form will not work where the form is used, if it will not. */
+    private fieldWarningOf;
+    private renderStructureInputs;
+    private renderFieldInspector;
+    private resolveFieldInput;
+    private fieldInputContext;
+    /**
+     * A choice field's options are edited row by row whatever hint the server sent for them: the generic
+     * multi-line text box it describes them with is not a usable way to manage a list.
+     */
+    private editorFor;
+    private renderInput;
+    private readFieldInput;
+    private applyFieldInput;
+    private toOptions;
+    /**
+     * The key is what conditions and integrations refer to, so it is worth a word on where it comes from:
+     * while it still follows the label the user can leave it alone, and once it is theirs it stays.
+     */
+    private keyHint;
+    private nextFieldKey;
+    /**
+     * What an inspector edit changes on the field. A new field's key follows its label until the user
+     * types a key of their own, after which the key is theirs.
+     */
+    private inspectorChanges;
+    private bindEvents;
+    private bindInspectorInputs;
+    private normalizeDocument;
+    private nextId;
+    private emitChange;
+    private escape;
+}
+
+export declare enum WorkflowFormCalculationOperator {
+    Sum = 1,
+    Subtract = 2,
+    Multiply = 3,
+    Average = 4,
+    Min = 5,
+    Max = 6,
+    Count = 7
+}
+
+export declare interface WorkflowFormDocument {
+    schemaVersion: number;
+    title?: WorkflowLocalizableText;
+    description?: WorkflowLocalizableText;
+    sections: WorkflowFormSection[];
+    fields: WorkflowFormFieldDefinition[];
+}
+
+export declare interface WorkflowFormFieldCalculation {
+    operator?: WorkflowFormCalculationOperator;
+    sourceFieldIds?: string[];
+}
+
+export declare interface WorkflowFormFieldDefinition {
+    id: string;
+    key?: string;
+    type: WorkflowFormFieldType;
+    label?: WorkflowLocalizableText;
+    placeholder?: WorkflowLocalizableText;
+    helpText?: WorkflowLocalizableText;
+    sectionId?: string;
+    order: number;
+    columnSpan?: number;
+    isReadOnly?: boolean;
+    isSensitive?: boolean;
+    defaultValue?: string;
+    currencyCode?: string;
+    validation?: WorkflowFormFieldValidation;
+    options?: WorkflowFormFieldOption[];
+    parentFieldId?: string;
+    calculation?: WorkflowFormFieldCalculation;
+    visibleWhen?: WorkflowConditionExpression;
+    enabledWhen?: WorkflowConditionExpression;
+    requiredWhen?: WorkflowConditionExpression;
+}
+
+export declare interface WorkflowFormFieldDescriptor {
+    type: number;
+    typeKey: string;
+    displayName?: string;
+    description?: string;
+    category?: string;
+    icon?: string;
+    order?: number;
+    isBrowsable?: boolean;
+    isContainer?: boolean;
+    isReadOnlyContent?: boolean;
+    requiredCapability?: string;
+    inputs: WorkflowInputDescriptor[];
+}
+
+export declare interface WorkflowFormFieldOption {
+    value?: string;
+    label?: WorkflowLocalizableText;
+    order: number;
+    isDisabled?: boolean;
+}
+
+export declare enum WorkflowFormFieldType {
+    ShortText = 1,
+    LongText = 2,
+    Number = 3,
+    Money = 4,
+    Date = 5,
+    Time = 6,
+    DateTime = 7,
+    Boolean = 8,
+    SingleSelect = 9,
+    MultiSelect = 10,
+    UserPicker = 11,
+    RolePicker = 12,
+    OrganizationUnitPicker = 13,
+    FileAttachment = 14,
+    StaticText = 15,
+    Repeater = 16,
+    Calculated = 17
+}
+
+export declare interface WorkflowFormFieldValidation {
+    isRequired?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    minValue?: number;
+    maxValue?: number;
+    decimalPlaces?: number;
+    regexPattern?: string;
+}
+
+export declare interface WorkflowFormSection {
+    id: string;
+    title?: WorkflowLocalizableText;
+    description?: WorkflowLocalizableText;
+    order: number;
+    isCollapsible?: boolean;
+    isInitiallyCollapsed?: boolean;
+}
+
+export declare interface WorkflowFormSubmissionNodeSettings {
+    visibleFieldIds?: string[];
+    readOnlyFieldIds?: string[];
+    allowAttachments?: boolean;
+    allowWithdraw?: boolean;
+}
+
+export declare interface WorkflowGraphDocument {
+    schemaVersion: number;
+    nodes: WorkflowNodeDefinition[];
+    edges: WorkflowEdgeDefinition[];
+    metadata?: WorkflowGraphMetadata;
+    variables?: WorkflowVariableDefinition[];
+}
+
+export declare interface WorkflowGraphMetadata {
+    nodeLayouts?: WorkflowLegacyNodeLayout[];
+    zoom?: number;
+    canvasOffsetX?: number;
+    canvasOffsetY?: number;
+}
+
+export declare interface WorkflowHostCapabilities {
+    formFieldDescriptors?: WorkflowFormFieldDescriptor[];
+    activityDescriptors?: WorkflowActivityDescriptor[];
+    graphSchemaVersion?: number;
+    maxSteps?: number;
+    maxFormFields?: number;
+    advancedApprovalsEnabled?: boolean;
+    externalActionsEnabled?: boolean;
+    attachmentsEnabled?: boolean;
+    /**
+     * Whether the form being edited is (or can be) filled in through a public form. Files can only be
+     * collected on a public form, so the form builder offers the file attachment field only when this is
+     * `true` and `attachmentsEnabled` is not `false`, and warns on a file attachment field already on a
+     * form when it is not. Unlike the other capabilities, leaving it out means "not available".
+     */
+    publicFormEnabled?: boolean;
+    eventWaitEnabled?: boolean;
+    slackEnabled?: boolean;
+    teamsEnabled?: boolean;
+    actions?: WorkflowActionDescriptor[];
+}
+
+declare abstract class WorkflowHostElement extends HTMLElement {
+    protected readonly root: ShadowRoot;
+    private _localization;
+    private _theme;
+    private _permissions;
+    private _capabilities;
+    private _lookups;
+    private _issues;
+    private _connected;
+    private _stylesAdopted;
+    private _styleElement;
+    private _dispatchingChange;
+    private readonly _hostFingerprints;
+    constructor();
+    get localization(): WorkflowLocalizationDictionary | undefined;
+    set localization(value: WorkflowLocalizationDictionary | undefined);
+    get theme(): WorkflowThemeTokens | undefined;
+    set theme(value: WorkflowThemeTokens | undefined);
+    get permissions(): WorkflowHostPermissions;
+    set permissions(value: WorkflowHostPermissions);
+    get capabilities(): WorkflowHostCapabilities;
+    set capabilities(value: WorkflowHostCapabilities);
+    get lookups(): WorkflowHostLookups;
+    set lookups(value: WorkflowHostLookups);
+    get validationIssues(): WorkflowValidationIssue[];
+    set validationIssues(value: WorkflowValidationIssue[]);
+    get readOnly(): boolean;
+    set readOnly(value: boolean);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected l(key: string, fallback?: string): string;
+    protected emit<T>(name: string, detail: T): void;
+    /**
+     * Hosts re-assign every property whenever their own state changes (React effects, Angular change
+     * detection), usually with an equal value. Re-rendering for those would rebuild the input the user is
+     * typing in, so a property only counts as changed when its content differs from the last assignment.
+     * The content is compared rather than the reference, so a host that mutates its object in place and
+     * assigns it again is still seen.
+     */
+    protected hostValueChanged(name: string, value: unknown): boolean;
+    protected requestRender(): void;
+    /**
+     * A render the host caused by assigning a property. It can arrive at any moment, including while the
+     * user is typing into one of the inputs it rebuilds, so it keeps that input focused with its caret
+     * and its not yet committed text where they were.
+     */
+    protected requestHostRender(): void;
+    protected adoptStyles(css: string): void;
+    protected applyTheme(): void;
+    protected abstract render(): void;
+}
+
+export declare interface WorkflowHostLookups {
+    optionsProvider?: WorkflowOptionsProviderCallback;
+    users?: WorkflowLookupCallback;
+    roles?: WorkflowLookupCallback;
+    organizationUnits?: WorkflowLookupCallback;
+    registeredActions?: WorkflowLookupCallback;
+    connectionProfiles?: WorkflowLookupCallback;
+    workflowDefinitions?: WorkflowLookupCallback;
+    eventDefinitions?: WorkflowLookupCallback;
+    actionParameterOptions?: (handlerName: string, parameterName: string, filter: string) => Promise<WorkflowLookupItem[]>;
+    suggestCondition?: WorkflowConditionSuggestionCallback;
+    summarizeWorkflow?: WorkflowSummaryCallback;
+}
+
+export declare interface WorkflowHostPermissions {
+    canEdit?: boolean;
+    canPublish?: boolean;
+    canSimulate?: boolean;
+}
+
+export declare interface WorkflowInputDescriptor {
+    name: string;
+    typeName?: string;
+    displayName?: string;
+    descriptionKey?: string;
+    /** Designer-local: the built-in fallback catalog carries a key because the server is not there to resolve it. */
+    displayNameKey?: string;
+    description?: string;
+    category?: string;
+    order?: number;
+    uiHint?: string;
+    uiSpecifications?: Record<string, unknown>;
+    defaultValue?: unknown;
+    defaultSyntax?: string;
+    supportedSyntaxes?: string[];
+    allowedValues?: WorkflowInputOption[];
+    optionsProviderName?: string;
+    refreshOnChange?: string[];
+    isRequired?: boolean;
+    isReadOnly?: boolean;
+    isBrowsable?: boolean;
+    isWrapped?: boolean;
+    isSynthetic?: boolean;
+    isSensitive?: boolean;
+    requiredCapability?: string;
+    minValue?: number;
+    maxValue?: number;
+    maxLength?: number;
+    regexPattern?: string;
+}
+
+export declare interface WorkflowInputEditor {
+    hint: string;
+    render: (context: WorkflowInputEditorContext) => string;
+    read: (element: HTMLElement) => unknown;
+    changeEvent?: 'change' | 'input';
+    /**
+     * Composite editors own more than one control, so they wire their own events and hand the whole
+     * value back through `commit`. When this is present the panel does not wire anything itself.
+     */
+    bind?: (container: HTMLElement, context: WorkflowInputEditorContext, commit: (value: unknown) => void) => void;
+}
+
+export declare interface WorkflowInputEditorContext {
+    descriptor: WorkflowInputDescriptor;
+    value: unknown;
+    disabled: boolean;
+    elementId: string;
+    localize: (key: string, fallback?: string) => string;
+    escape: (value: string) => string;
+    /** Present when the editor is hosted somewhere that can resolve options asynchronously. */
+    lookup?: WorkflowInputOptionLookup;
+    /**
+     * The variables and step outputs the graph currently declares. They come from the document rather
+     * than from a lookup because a variable exists the moment it is typed into the grid, long before
+     * anything is saved.
+     */
+    variables?: WorkflowVariableOption[];
+    outputs?: WorkflowOutputOption[];
+    /**
+     * The secrets this user may refer to, by name only. The host loads them; the designer never sees a
+     * value and has no way to ask for one.
+     */
+    secrets?: WorkflowSecretOption[];
+    nameOf?: (providerName: string, id: string) => string | undefined;
+}
+
+export declare interface WorkflowInputOption {
+    value: string;
+    displayText: string;
+}
+
+export declare interface WorkflowInputOptionLookup {
+    (providerName: string, filter: string): Promise<{
+        value: string;
+        displayText: string;
+    }[]>;
+}
+
+/** Detail of the `issue-focus` event: the element focused (or is forwarding) an issue, and the host should show this tab. */
+export declare interface WorkflowIssueFocusDetail extends WorkflowIssueFocusTarget {
+    issue: WorkflowValidationIssue;
+}
+
+/** Which host tab holds what a validation issue is about. */
+export declare type WorkflowIssueFocusTab = 'flow' | 'form' | 'trigger';
+
+/** What a validation issue points at, resolved against the documents the element holds. */
+export declare interface WorkflowIssueFocusTarget {
+    tab: WorkflowIssueFocusTab;
+    nodeId?: string;
+    edgeId?: string;
+    branchId?: string;
+    fieldId?: string;
+    /** The step input (dotted descriptor name) the issue is about, when its code says so. */
+    inputName?: string;
+}
+
+export declare enum WorkflowJoinMode {
+    WaitAll = 1,
+    WaitAny = 2,
+    WaitCount = 3
+}
+
+export declare interface WorkflowJoinNodeSettings {
+    parallelNodeId?: string;
+    mode?: WorkflowJoinMode;
+    requiredBranchCount?: number;
+}
+
+export declare interface WorkflowLegacyNodeLayout {
+    nodeId?: string;
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+}
+
+export declare interface WorkflowLocalizableText {
+    defaultValue?: string;
+    translations?: Record<string, string>;
+}
+
+export declare type WorkflowLocalizationDictionary = Record<string, string>;
+
+export declare type WorkflowLookupCallback = (filter: string) => Promise<WorkflowLookupItem[]>;
+
+export declare interface WorkflowLookupItem {
+    id: string;
+    displayName: string;
+}
+
+export declare type WorkflowNodeCategory = 'flow' | 'human' | 'control' | 'integration' | 'terminal';
+
+export declare interface WorkflowNodeCategoryDefinition {
+    id: WorkflowNodeCategory;
+    localizationKey: string;
+    fallbackLabel: string;
+}
+
+export declare interface WorkflowNodeDefinition {
+    id: string;
+    type: WorkflowNodeType;
+    /** Reserved activity type key, written from schema version 3 onward. */
+    activityType?: string;
+    activityVersion?: number;
+    inputs?: Record<string, unknown>;
+    customProperties?: Record<string, unknown>;
+    unknownActivity?: WorkflowUnknownActivitySettings;
+    identityKey?: string;
+    authoringOrigin?: WorkflowAuthoringOrigin;
+    name?: WorkflowLocalizableText;
+    description?: WorkflowLocalizableText;
+    layout?: WorkflowNodeLayout;
+    approval?: WorkflowApprovalNodeSettings;
+    condition?: WorkflowConditionNodeSettings;
+    notification?: WorkflowNotificationNodeSettings;
+    action?: WorkflowActionNodeSettings;
+    formSubmission?: WorkflowFormSubmissionNodeSettings;
+    parallel?: WorkflowParallelNodeSettings;
+    join?: WorkflowJoinNodeSettings;
+    timer?: WorkflowTimerNodeSettings;
+    subprocess?: WorkflowSubprocessNodeSettings;
+    eventWait?: WorkflowEventWaitNodeSettings;
+    sendSlackMessage?: WorkflowSendChatMessageNodeSettings;
+    sendTeamsMessage?: WorkflowSendChatMessageNodeSettings;
+    channels?: WorkflowChannelSettings;
+    sla?: WorkflowSlaSettings;
+}
+
+export declare interface WorkflowNodeExecutionState {
+    nodeId?: string;
+    status?: WorkflowNodeExecutionStatus;
+    visitCount?: number;
+    enteredTime?: string;
+    completedTime?: string;
+    decision?: number;
+    workflowTaskId?: number;
+}
+
+export declare enum WorkflowNodeExecutionStatus {
+    NotVisited = 0,
+    Active = 1,
+    Completed = 2,
+    Skipped = 3,
+    Faulted = 4,
+    Cancelled = 5
+}
+
+export declare interface WorkflowNodeHeat {
+    nodeId?: string;
+    enteredCount?: number;
+    averageDwellSeconds?: number;
+    ninetiethPercentileDwellSeconds?: number;
+    overdueCount?: number;
+    noAssigneeCount?: number;
+    reworkCount?: number;
+    wasNeverEntered?: boolean;
+}
+
+export declare interface WorkflowNodeLayout {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+}
+
+export declare interface WorkflowNodeOutcome {
+    kind: WorkflowEdgeKind;
+    localizationKey: string;
+    fallbackLabel: string;
+    color: string;
+    isDynamic?: boolean;
+    isOptional?: boolean;
+}
+
+export declare interface WorkflowNodePaletteItem {
+    type: number;
+    category: WorkflowNodeCategory;
+    localizationKey: string;
+    fallbackLabel: string;
+    descriptionKey: string;
+    fallbackDescription: string;
+    icon: string;
+    iconName?: string;
+    color: string;
+    isTerminal: boolean;
+    isSingleton: boolean;
+    isUnknown: boolean;
+    outcomes: WorkflowNodeOutcome[];
+}
+
+export declare enum WorkflowNodeType {
+    Start = 1,
+    FormSubmission = 2,
+    Approval = 3,
+    Condition = 4,
+    Notification = 5,
+    Action = 6,
+    Approved = 7,
+    Rejected = 8,
+    Cancelled = 9,
+    Parallel = 10,
+    Join = 11,
+    Timer = 12,
+    Subprocess = 13,
+    EventWait = 14,
+    SendSlackMessage = 15,
+    SendTeamsMessage = 16,
+    RunAiAgent = 17
+}
+
+export declare interface WorkflowNotificationNodeSettings {
+    notificationName?: string;
+    subject?: WorkflowLocalizableText;
+    body?: WorkflowLocalizableText;
+    sendInApp?: boolean;
+    sendEmail?: boolean;
+    recipients?: unknown[];
+}
+
+/**
+ * The single lookup the descriptor contract needs: the descriptor names a provider, the host resolves
+ * it. Hosts that still ship the per-kind callbacks below keep working; this one wins when present.
+ */
+export declare type WorkflowOptionsProviderCallback = (providerName: string, filter: string, context: WorkflowOptionsProviderContext) => Promise<WorkflowLookupItem[]>;
+
+export declare interface WorkflowOptionsProviderContext {
+    activityTypeName?: string;
+    inputName?: string;
+    nodeId?: string;
+    siblingValues?: Record<string, unknown>;
+}
+
+/** What a step publishes for later steps to read. Mirrors `WorkflowOutputDescriptorDto`. */
+export declare interface WorkflowOutputDescriptor {
+    name: string;
+    displayName?: string;
+    description?: string;
+    typeName?: string;
+    isSensitive?: boolean;
+}
+
+/** An output a step in the graph publishes, named by the step that produces it. */
+declare interface WorkflowOutputOption {
+    nodeId: string;
+    nodeName?: string;
+    outputName: string;
+}
+
+export declare interface WorkflowPaletteCapabilities {
+    eventWaitEnabled?: boolean;
+    externalActionsEnabled?: boolean;
+}
+
+export declare interface WorkflowParallelNodeSettings {
+    joinNodeId?: string;
+    cancelRemainingBranchesOnRejection?: boolean;
+}
+
+export declare interface WorkflowPortDescriptor {
+    name: string;
+    displayName?: string;
+    type?: string;
+    edgeKind?: number;
+    isDynamic?: boolean;
+    expansionSource?: string;
+}
+
+export declare enum WorkflowRejectionPolicy {
+    RejectImmediately = 1,
+    WaitForEveryone = 2
+}
+
+export declare interface WorkflowSchemaVersionMismatch {
+    kind: WorkflowSchemaVersionMismatchKind;
+    serverVersion: number;
+    designerVersion: number;
+}
+
+export declare type WorkflowSchemaVersionMismatchKind = 'designer-outdated' | 'server-outdated';
+
+/**
+ * A secret as the designer sees it. There is no value here and there never will be: the picker exists so
+ * a graph can refer to a secret by name without anyone having to see what it holds.
+ */
+declare interface WorkflowSecretOption {
+    name: string;
+    displayName?: string;
+    typeName?: string;
+    hasUsableValue?: boolean;
+}
+
+export declare interface WorkflowSelectionDetail {
+    nodeId?: string;
+    fieldId?: string;
+}
+
+export declare enum WorkflowSelfApprovalPolicy {
+    TenantDefault = 0,
+    Deny = 1,
+    Allow = 2,
+    SkipStep = 3
+}
+
+export declare interface WorkflowSendChatMessageNodeSettings {
+    connectionProfileName?: string;
+    target?: string;
+    title?: WorkflowLocalizableText;
+    body?: WorkflowLocalizableText;
+    severity?: number;
+    includeDeepLink?: boolean;
+    factFieldIds?: string[];
+    adaptiveCardJson?: string;
+}
+
+export declare interface WorkflowSlaSettings {
+    dueInMinutes?: number;
+    useBusinessCalendar?: boolean;
+    dueSoonThresholdInMinutes?: number;
+    reminderIntervalInMinutes?: number;
+    maxReminderCount?: number;
+    escalateOnOverdue?: boolean;
+    escalateAfterMinutes?: number;
+    escalationTarget?: WorkflowAssignmentTarget;
+}
+
+export declare interface WorkflowSubprocessNodeSettings {
+    workflowDefinitionId?: string;
+    waitForCompletion?: boolean;
+    outcomeMode?: WorkflowSubprocessOutcomeMode;
+    cancelChildOnParentCancel?: boolean;
+    inputMappings?: WorkflowFieldMapping[];
+    outputMappings?: WorkflowFieldMapping[];
+}
+
+export declare enum WorkflowSubprocessOutcomeMode {
+    SingleOutcome = 1,
+    ApprovalOutcome = 2
+}
+
+export declare type WorkflowSummaryCallback = (context: WorkflowAssistantContext) => Promise<WorkflowSummarySuggestion>;
+
+export declare interface WorkflowSummarySuggestion {
+    succeeded: boolean;
+    summary?: string;
+    failureReason?: string;
+}
+
+/**
+ * How a value is produced. The server publishes the syntaxes it is willing to evaluate on each input's
+ * `supportedSyntaxes`; anything not on that list simply never appears here. That is why the code
+ * execution syntaxes (JavaScript, C#, ...) never show up in the designer: the server does not offer them.
+ */
+export declare interface WorkflowSyntaxOption {
+    syntax: string;
+    labelKey: string;
+    fallbackLabel: string;
+}
+
+export declare interface WorkflowThemeTokens {
+    fontFamily?: string;
+    surfaceColor?: string;
+    borderColor?: string;
+    textColor?: string;
+    mutedTextColor?: string;
+    primaryColor?: string;
+    dangerColor?: string;
+    warningColor?: string;
+    successColor?: string;
+}
+
+export declare enum WorkflowTimerNodeMode {
+    Duration = 1,
+    FormFieldDate = 2,
+    FixedDate = 3
+}
+
+export declare interface WorkflowTimerNodeSettings {
+    mode?: WorkflowTimerNodeMode;
+    durationInMinutes?: number;
+    fieldId?: string;
+    offsetInMinutes?: number;
+    fixedDate?: string;
+    useBusinessCalendar?: boolean;
+}
+
+export declare interface WorkflowUnknownActivitySettings {
+    missingTypeName?: string;
+    missingTypeVersion?: number;
+    originalNodeJson?: string;
+}
+
+export declare interface WorkflowValidationIssue {
+    code?: string;
+    message?: string;
+    nodeId?: string;
+    edgeId?: string;
+    fieldId?: string;
+    branchId?: string;
+}
+
+export declare interface WorkflowVariableDefinition {
+    id?: string;
+    name: string;
+    typeName?: string;
+    isArray?: boolean;
+    /** The starting value, kept as text and read back through `typeName` and `isArray`. */
+    value?: string;
+    scope?: number;
+    isSensitive?: boolean;
+    displayName?: WorkflowLocalizableText;
+}
+
+/**
+ * A variable the graph declares. The designer feeds these in from the document rather than from a server
+ * lookup, because a variable exists as soon as it is typed into the grid and long before anything is
+ * saved.
+ */
+declare interface WorkflowVariableOption {
+    name: string;
+    typeName?: string;
+    scope?: string;
+    isSensitive?: boolean;
+}
+
+export declare interface WorkflowVisibleWhenRule {
+    input: string;
+    equalsAnyOf: unknown[];
+    isNotEmpty?: boolean;
+}
+
+export declare function writeInputValue<T>(target: T, path: string, value: unknown): T;
+
+export { }