Members

# constant GRAPH_CATEGORY_STYLE_REGISTRY

Registry mapping category names to their default style (color + icon).

Registry mapping category names to their default style (color + icon). Consumers register categories via registerGraphCategoryStyle.

The engine and renderer resolve the "effective" color/icon for a node by checking the node's explicit color / icon first, then falling back to the category's style, then a default.

View Source graph/constants.ts, line 49

# constant GRAPH_DEFAULT_CATEGORY_STYLE

Default fallback style when no category is registered and no explicit color/icon is set on the node.

View Source graph/constants.ts, line 54

# constant GRAPH_LOOP_PARAMETER_KEYS

Loop-configuration fields of legacy graph.metadata.loop bags that are node configuration rather than loop-body settings.

Loop-configuration fields of legacy graph.metadata.loop bags that are node configuration rather than loop-body settings. Per DECAF-50 §4.4.5 rule 6 (non-port operation/configuration fields belong in parameters), these are carried into the instance's parameters so legacy loop round-trips stay lossless; body/maxIterations/timeoutMs/ concurrency live on GraphLoopConfiguration.

View Source graph/document/GraphDecoratedWorkflowCompiler.ts, line 157

# constant GRAPH_VISUAL_STATE_STYLES

The default visual-state → overlay mapping contract (DECAF-48 §4.4): running=faded green, blocked=yellow, errored=red; succeeded keeps the node's own accent; unexecuted-after-failure fades/disabled. This is the shared, framework-neutral source of truth that supersedes the DECAF-32 §21.9 running colour for the live run-feedback overlay (§4.5).

View Source graph/constants.ts, line 22

# constant NODE_REGISTRY

Internal registry of all @node-decorated constructors.

View Source graph/registry.ts, line 5

# constant WORKFLOW_REGISTRY

Internal registry of all @graph-decorated constructors.

View Source graph/registry.ts, line 9

# constant isClassConstructor

Type guard that verifies if a provided UI function-like value is a class constructor.

View Source ui/utils.ts, line 10

Methods

# assertGraphWorkflowDocumentValid()

Structural validation gate for a canonical GraphWorkflowDocument (shared by the frontend builder and the backend nine-stage validator, DECAF-50 §4.8 stage 1 shape rules).

Structural validation gate for a canonical GraphWorkflowDocument (shared by the frontend builder and the backend nine-stage validator, DECAF-50 §4.8 stage 1 shape rules). Checks unique port/node/edge ids, valid schemas, binding shapes, edge endpoints, and recursively validates nested loop-body documents.

View Source graph/document/GraphWorkflowDocumentBuilder.ts, line 107

Throws:

ValidationError describing the first invalid aspect found.

# boundaryPortIdsFor()

Maps workflow input-property names to their legacy boundary-badge ids (input-{property}), so badges drawn on the canvas resolve back to the workflow port they represent (§4.11).

View Source graph/snapshot.ts, line 374

# connection()

Declares a "connection" port on a node — a third port kind alongside @input() and @output().

Declares a "connection" port on a node — a third port kind alongside @input() and @output(). Connection ports are rendered on the bottom side of the node (inputs are on the left, outputs on the right).

Connections are typed by category (e.g. "model", "memory", "workspace"). The category determines the port's color via the registerGraphCategoryStyle registry.

Unlike @input / @output, connection ports do NOT carry workflow data values — they represent structural dependencies (e.g. an Agent node connecting to a Model resource, a Memory store, or a Workspace). Nodes may have zero or more @connection() ports.

Usage:

View Source graph/decorators.ts, line 102

# edgePairKeyOf()

Endpoint-pair key for edge identity (canonical GraphEndpoint shape).

View Source graph/snapshot.ts, line 483

# getUIAttributeKey(prop, key)

Derives the metadata key for a UI attribute on a decorated property.

Parameters:

Name	Type	Description
`prop`		Property name decorated on the UI model.
`key`		Attribute identifier stored under the property metadata.

View Source ui/utils.ts, line 20

Returns:

Fully qualified metadata key scoped to UIKeys.REFLECT.

# graphCategoryStyleOf()

Returns the style registered for category, or the default fallback style.

View Source graph/constants.ts, line 69

# graphDecoratedWorkflowCompiler()

Compiles a decorated workflow (or an already-resolved GraphWorkflowDefinition) into a canonical GraphWorkflowDocument: workflow boundary ports, one instance per node (input-port defaults and loop/switch metadata folded into parameters/metadata), one edge per relation, plus UI state. Browser-safe: node constructors are never invoked, so @node classes can seed demo graphs without engine imports (DECAF-50 §4.4.4).

View Source graph/document/GraphDecoratedWorkflowCompiler.ts, line 26

Throws:

ValidationError when the input cannot be resolved to a decorated graph workflow definition.

# graphLegacyLoopMetadataOf()

Reads the legacy graph.metadata.loop bag from either the node metadata or the node definition shim, so loop-configuration fields can be split between GraphLoopConfiguration and instance parameters (§4.4.5 rule 6).

View Source graph/document/GraphDecoratedWorkflowCompiler.ts, line 201

# graphNodes()

Returns all @node-decorated constructors.

View Source graph/registry.ts, line 30

Returns:

A fresh array of constructors (mutable; does not expose the internal set).

# graphVisualStyleOf(state)

Resolves the visual style overlay for a node/edge execution state, falling back to a neutral default when the state is unknown or unregistered.

Parameters:

Name	Type	Description
`state`		The visual state string (as defined by the shared `GraphVisualState` values, e.g. `"running"`, `"blocked"`).

View Source graph/constants.ts, line 38

Returns:

The style overlay for the given state.

# graphWorkflowDocumentFromLegacySnapshot()

Maps a legacy (pre-P7) canvas snapshot to the canonical GraphWorkflowDocument (DECAF-50 §4.4.6): legacy node.data becomes instance parameters, legacy node.metadata becomes instance metadata, workflow boundary badges (input-{port}) fold back onto their workflow ports, and edge labels missing from cloned edge rows are restored from the decorated definition's relation labels (§4.4.7).

View Source graph/snapshot.ts, line 497

# graphWorkflowSnapshotFromLegacy()

Converts a legacy persisted snapshot into the canonical wrapper.

Converts a legacy persisted snapshot into the canonical wrapper. The canonical document carries executable semantics; editor.legacy keeps the sanitized (constructor-free) legacy payload so a canonical→legacy round trip is lossless for persisted data.

View Source graph/snapshot.ts, line 536

# graphWorkflowSnapshotLikeToCanonical()

Normalizes any accepted snapshot/document form to a canonical wrapper.

View Source graph/snapshot.ts, line 672

# graphWorkflowSnapshotToLegacy()

Reconstructs a legacy snapshot from a canonical wrapper.

Reconstructs a legacy snapshot from a canonical wrapper. Uses the editor.legacy payload when present for exact round trips; otherwise it rebuilds a best-effort legacy snapshot from the document + editor state (constructors are never restored).

View Source graph/snapshot.ts, line 580

# graphWorkflows()

Returns all @graph-decorated constructors.

View Source graph/registry.ts, line 37

Returns:

A fresh array of constructors.

# hidden() → {function}

Makes a property invisible in all CRUD operations This decorator is a convenience wrapper around hideOn that hides a property during all CRUD operations (CREATE, READ, UPDATE, DELETE).

Decorator that completely hides a property in all UI operations

sequenceDiagram participant Model participant hidden participant hideOn participant RenderingEngine Model->>hidden: Apply to property hidden->>hideOn: Call with all operations hideOn->>Model: Add hidden metadata RenderingEngine->>Model: Check if property should be hidden Model->>RenderingEngine: Return all operations RenderingEngine->>UI: Always hide property

View Source ui/decorators.ts, line 105

Returns:

A property decorator function

Type: function

Example

// Completely hide the internalId field in the UI
class Product {

# hideFor()

Controls property visibility based on namespace membership.

Decorator that hides a property for specific namespaces.

View Source ui/decorators.ts, line 50

# hideOn(operations) → {function}

Controls property visibility based on operation type This decorator allows you to specify which CRUD operations should hide a property in the UI. The property will only be visible during operations not specified.

Decorator that hides a property during specific CRUD operations

sequenceDiagram participant Model participant hideOn participant RenderingEngine participant UI Model->>hideOn: Apply to property hideOn->>Model: Add hidden metadata RenderingEngine->>Model: Check if property should be hidden Model->>RenderingEngine: Return hidden operations RenderingEngine->>UI: Render or hide based on current operation

Parameters:

Name	Type	Description
`operations`		The CRUD operations during which the property should be hidden

View Source ui/decorators.ts, line 6

Returns:

A property decorator function

Type: function

Example

// Hide the password field during READ operations
class User {

# isGraphNodePolicyManifest() → {boolean}

Type guard for GraphNodePolicyManifest: accepts objects whose inputMode (when present) is one of the declared GraphNodePolicyInputMode values.

View Source graph/catalog/GraphNodePolicyManifest.ts, line 9

Returns:

Whether the value is a GraphNodePolicyManifest.

Type: boolean

# legacyRelationLabelByEndpoint()

Resolves the decorated definition's own edge labels by canonical endpoint pair, so converted legacy edges that never carried a label on the edge row (canvas-drawn clones merged over the relation rows) still restore the document-carried GraphEdgeInstance.label (§4.4.7) instead of losing the display affordance on save/reload.

View Source graph/snapshot.ts, line 388

# pinnable()

Class decorator that marks a graph node as pinnable.

The metadata is stored in the node's graph.metadata.pinnable field so the Angular renderer and the core pinning policy can read it.

Usage:

View Source graph/decorators.ts, line 118

# registerGraphCategoryStyle()

Registers a category style (color + optional icon) in the global registry.

Registers a category style (color + optional icon) in the global registry. Call this at module init time (e.g. in the engine's node declarations) to define the visual style for a category of nodes or connections.

View Source graph/constants.ts, line 63

# registerNode(ctor)

Appends a constructor to the node registry.

Appends a constructor to the node registry. Called by the @node decorator. Idempotent — re-decorating the same class does not duplicate the entry.

Parameters:

Name	Type	Description
`ctor`		The `@node`-decorated constructor.

View Source graph/registry.ts, line 15

# registerWorkflow(ctor)

Appends a constructor to the workflow registry.

Appends a constructor to the workflow registry. Called by the @graph decorator. Idempotent.

Parameters:

Name	Type	Description
`ctor`		The `@graph`-decorated constructor.

View Source graph/registry.ts, line 23

# renderIf()

Convenience alias for namespace-scoped visibility control.

Decorator that renders a property only when the namespace matches.

View Source ui/decorators.ts, line 68

# renderedBy(engine) → {function}

Associates a model with a specific rendering engine implementation This decorator allows you to override the default rendering engine for a specific model class, enabling different rendering strategies for different models.

Decorator that specifies which rendering engine to use for a model

sequenceDiagram participant System participant renderedBy participant Model participant RenderingEngine System->>renderedBy: apply to Model renderedBy->>Model: adds engine metadata Model->>RenderingEngine: uses specified engine RenderingEngine->>System: renders with custom engine

Parameters:

Name	Type	Description
`engine`	`string`	The name of the rendering engine to use

View Source model/decorators.ts, line 58

Returns:

A class decorator function

Type: function

Example

// Specify a custom rendering engine for a model

# resetGraphRegistries()

Clears both registries.

Clears both registries. Intended for tests only.

View Source graph/registry.ts, line 43

# resolveEffectiveColor()

Resolves the effective color for a node: explicit color overrides the category color, which overrides the default.

View Source graph/constants.ts, line 79

# resolveEffectiveIcon()

Resolves the effective icon for a node: explicit icon overrides the category icon, which overrides the default.

View Source graph/constants.ts, line 88

# resolvePortGroups()

Builds the effective portGroups list for a node: starts from the declared GraphNodeMetadata.portGroups and ensures every Schema-typed @input / @output property not explicitly listed gets a default { property, toggle: "all" } entry.

View Source graph/reader.ts, line 227

# sanitizeLegacySnapshotPayload()

Sanitizes a legacy snapshot into a JSON-safe payload while preserving its structural keys (version, definition, state).

Sanitizes a legacy snapshot into a JSON-safe payload while preserving its structural keys (version, definition, state). Constructor-key stripping still applies to the payload contents inside, so the canonical→legacy round trip stays lossless for persisted data.

View Source graph/snapshot.ts, line 311

# schemaGroupPorts()

Returns the flattened ports of a Schema-typed @input / @output property (a "Schema port group").

Returns the flattened ports of a Schema-typed @input / @output property (a "Schema port group"). The Schema's own @input / @output properties whose direction matches direction are spliced into the result UNPREFIXED (no <schemaProp>. prefix). The carrier property itself is not a port.

Returns undefined when the property is not a Schema group (not graph.schema, or not Schema-typed), so the caller falls back to the legacy single-port / composite expansion path.

View Source graph/reader.ts, line 93

# showFor()

Namespace-aware counterpart to hideFor.

Decorator that shows a property only for specific namespaces.

View Source ui/decorators.ts, line 59

# uichild(clazz, tag, propsopt, serializeopt) → {function}

Defines how a parent component should render the child model when nested.

This decorator is used to decorate properties that are nested models. When applied, it allows overriding the default tag of the child model with the provided one, enabling different rendering behavior when the model acts as a child (nested) compared to when it is rendered as the parent model.

It requires the class to be decorated with @uimodel.

Decorator that maps a nested model property to a UI component property.

sequenceDiagram participant Model participant uichild participant RenderingEngine participant Component Model->>uichild: Apply to property uichild->>Model: Add child metadata RenderingEngine->>Model: Get child metadata Model->>RenderingEngine: Return prop name, stringify flag, and child tag override RenderingEngine->>Component: Pass property with specified name and render with overridden tag if nested

Parameters:

Name	Type	Attributes	Default	Description
`clazz`	`string`			The model class name to pass to the component (defaults to the property key).
`tag`	`string`			The HTML element or component tag name to override the UI tag of the nested model
`props`	`Record.<string, any>`	<optional>		Additional properties to pass to the element
`serialize`	`boolean`	<optional>	false	Whether the property should be serialized

View Source ui/decorators.ts, line 253

Returns:

A property decorator function.

Type: function

Example

// Map a nested model to a component property with a different tag when nested

# uielement(tag, propsopt, serializeopt) → {function}

Maps a model property to a specific UI element with custom properties This decorator allows you to define which HTML element or component should be used to render a specific property, along with any additional properties to pass to that element.

Decorator that specifies how a property should be rendered as a UI element

sequenceDiagram participant Model participant uielement participant RenderingEngine participant UI Model->>uielement: Apply to property uielement->>Model: Add element metadata RenderingEngine->>Model: Get element metadata Model->>RenderingEngine: Return tag and props RenderingEngine->>UI: Render with specified element

Parameters:

Name	Type	Attributes	Default	Description
`tag`	`string`			The HTML element or component tag name to use for rendering
`props`	`Record.<string, any>`	<optional>		Additional properties to pass to the element
`serialize`	`boolean`	<optional>	false	Whether the property should be serialized

View Source ui/decorators.ts, line 143

Returns:

A property decorator function

Type: function

Example

// Render a property as a text input
class LoginForm {

# uihandlers(propsopt) → {function}

Specifies event handlers that should be attached to the rendered model This decorator allows you to define event handlers that will be automatically attached to the rendered UI element. The handlers are passed as properties to the rendering engine.

Decorator that adds event handlers to a UI model

sequenceDiagram participant System participant uihandlers participant Model participant RenderingEngine participant UI System->>uihandlers: apply to Model uihandlers->>Model: adds handler metadata Model->>RenderingEngine: requests rendering with handlers RenderingEngine->>UI: renders element with event handlers attached UI->>Model: triggers handlers on events

Parameters:

Name	Type	Attributes	Description
`props`	`Record.<string, any>`	<optional>	Object containing event handler functions and other properties

View Source model/decorators.ts, line 150

Returns:

A class decorator function

Type: function

Example

// Add event handlers to a model

# uilayout(tag, colsModeopt, rowsopt, breakpointopt) → {function}

Combines UI model functionality with layout grid configuration This decorator creates a UI model that acts as a layout container with specified column and row configurations. It's a convenience decorator that combines.

Decorator that creates a layout container with grid specifications

sequenceDiagram participant System participant uilayout participant uimodel participant Model participant RenderingEngine System->>uilayout: apply to Model uilayout->>uimodel: call with layout props uimodel->>Model: adds model metadata with layout config Model->>RenderingEngine: requests rendering as layout container RenderingEngine->>System: renders grid layout with specified dimensions

Parameters:

Name	Type	Attributes	Default	Description
`tag`	`string`			The HTML tag to use for the layout container
`colsMode`	`number` \| `boolean`	<optional>	1	Number of columns in the grid layout or a boolean for flex mode
`rows`	`number` \| `Array.<string>`	<optional>	1	Number of rows or array of row definitions
`breakpoint`	`UIMediaBreakPoints`	<optional>	'm'	Media breakpoint for responsive behavior

View Source model/decorators.ts, line 211

Returns:

A class decorator function

Type: function

Example

// Create a simple 2-column layout

# uilayoutprop(col, rowopt, propsopt) → {function}

Specifies the column and row position for a property in a UI layout grid This decorator allows you to define the specific position of a property within a grid-based layout system. It specifies which column and row the property should occupy when rendered in the UI.

Decorator that positions a property in a specific grid layout position

sequenceDiagram participant Model participant uilayoutprop participant RenderingEngine participant LayoutContainer Model->>uilayoutprop: Apply to property uilayoutprop->>Model: Add layout item metadata RenderingEngine->>Model: Get layout item metadata Model->>RenderingEngine: Return column, row, and props RenderingEngine->>LayoutContainer: Position element at grid coordinates LayoutContainer->>RenderingEngine: Return positioned element

Parameters:

Name	Type	Attributes	Default	Description
`col`	`number`			The column position in the grid layout
`row`	`number`	<optional>	1	The row position in the grid layout (defaults to 1)
`props`	`Record.<string, any>`	<optional>	{}	Additional properties to pass to the layout item

View Source ui/decorators.ts, line 378

Returns:

A property decorator function

Type: function

Example

// Position properties in a grid layout

# uilistmodel(tagopt, propsopt) → {function}

Specifies how a model should be rendered when displayed in a list context This decorator applies metadata to the class that enables it to be rendered as a list item by the UI rendering engine. The model will be rendered with the specified tag and properties when it appears in a list.

Decorator that tags a model as a list item for UI rendering

sequenceDiagram participant System participant uilistmodel participant Model participant RenderingEngine System->>uilistmodel: apply to Model uilistmodel->>Model: adds list item metadata Model->>RenderingEngine: uses list item metadata when in list context RenderingEngine->>System: renders with list item styling

Parameters:

Name	Type	Attributes	Description
`tag`	`string`	<optional>	The HTML tag to use when rendering this model as a list item (defaults to class name)
`props`	`Record.<string, any>`	<optional>	Additional properties to pass to the rendered list item element

View Source model/decorators.ts, line 93

Returns:

A class decorator function

Type: function

Example

// Basic usage with default tag (class name)

# uilistprop(propNameopt, propsopt) → {function}

Specifies how a property should be rendered in a list context This decorator allows you to define how a model property containing a list should be rendered. It requires the class to be decorated with @uilistmodel.

Decorator that maps a model property to a list item component

sequenceDiagram participant Model participant uilistprop participant RenderingEngine participant ListContainer participant ListItems Model->>uilistprop: Apply to property uilistprop->>Model: Add list prop metadata RenderingEngine->>Model: Get list prop metadata Model->>RenderingEngine: Return prop name and container props RenderingEngine->>ListContainer: Create container with props RenderingEngine->>ListItems: Render each item using @uilistmodel ListContainer->>RenderingEngine: Return rendered list

Parameters:

Name	Type	Attributes	Description
`propName`	`string`	<optional>	The name of the property to pass to the list component (defaults to the property key)
`props`	`Record.<string, any>`	<optional>	Additional properties to pass to the list container

View Source ui/decorators.ts, line 320

Returns:

A property decorator function

Type: function

Example

// Define a list property with custom rendering

# uimodel(tagopt, propsopt) → {function}

Adds rendering capabilities to a model class by providing a render method This decorator applies metadata to the class that enables it to be rendered by the UI rendering engine. The model will be rendered with the specified tag and properties.

Decorator that tags a class as a UI model

sequenceDiagram participant System participant uimodel participant constructor participant instance System->>uimodel:do(constructor) uimodel->>constructor: Executes the constructor constructor->>uimodel: returns instance uimodel->>instance: adds the render method uimodel->>System: returns UIModel instance

Parameters:

Name	Type	Attributes	Description
`tag`	`string`	<optional>	The HTML tag to use when rendering this model (defaults to class name)
`props`	`Record.<string, any>`	<optional>	Additional properties to pass to the rendered element

View Source model/decorators.ts, line 5

Returns:

A class decorator function

Type: function

Example

// Basic usage with default tag (class name)

# uionclick(handler)

A decorator function that associates a UI click handler with the 'handleClick' event.

Parameters:

Name	Type	Description
`handler`		A function that conforms to the `UIEventHandler` type, which will be executed when the 'handleClick' event is triggered.

View Source ui/decorators.ts, line 519

Returns:

A decorated function that binds the handler to the 'handleClick' event.

# uionrender(handler)

A decorator function that associates a UI rendering handler with the 'render' event.

Parameters:

Name	Type	Description
`handler`		A function that conforms to the `UIEventHandler` type, which will be executed when the 'render' event is triggered.

View Source ui/decorators.ts, line 529

Returns:

A decorated function that binds the handler to the 'render' event.

# uiorder(orderopt) → {function}

Specifies the rendering order for UI components This decorator applies metadata to the property or class, indicating its order in the UI rendering sequence.

Decorator that sets the order of a UI element

sequenceDiagram participant System participant uiorder participant property System->>uiorder:do(property) uiorder->>property: sets order metadata uiorder->>System: returns decorated property

Parameters:

Name	Type	Attributes	Default	Description
`order`	`number`	<optional>	1	The order value for the UI element (default is 1)

View Source ui/decorators.ts, line 71

Returns:

A property or class decorator function

Type: function

Example

// Set order for a field

# uipageprop(pageopt) → {function}

Specifies which page a property should appear on in paginated UI layouts This decorator applies metadata to the property, indicating which page number it belongs to in a multi-page form or wizard. Properties with the same page number are grouped together and rendered on the same page. This is typically used in conjunction with @uisteppedmodel to organize large forms into manageable sections.

Decorator that assigns a property to a specific page in multi-page forms

sequenceDiagram participant Model participant uipageprop participant RenderingEngine participant PaginationController participant UI Model->>uipageprop: Apply to property uipageprop->>Model: Add page metadata RenderingEngine->>Model: Get page metadata Model->>RenderingEngine: Return page number RenderingEngine->>PaginationController: Group properties by page PaginationController->>UI: Render current page properties

Parameters:

Name	Type	Attributes	Default	Description
`page`	`number`	<optional>	1	The page number where the property should appear (default is 1)

View Source ui/decorators.ts, line 439

Returns:

A property decorator function

Type: function

Example

// Create a multi-step registration form with page-based layout

# uiprop(propNameopt, stringifyopt) → {function}

Specifies how a property should be passed to a UI component This decorator allows you to define how a model property should be mapped to a property of the UI component when rendering. It requires the class to be decorated with @uimodel.

Decorator that maps a model property to a UI component property

sequenceDiagram participant Model participant uiprop participant RenderingEngine participant Component Model->>uiprop: Apply to property uiprop->>Model: Add prop metadata RenderingEngine->>Model: Get prop metadata Model->>RenderingEngine: Return prop name and stringify flag RenderingEngine->>Component: Pass property with specified name

Parameters:

Name	Type	Attributes	Default	Description
`propName`	`string`	<optional>		The name of the property to pass to the component (defaults to the property key)
`stringify`	`boolean`	<optional>	false	Whether to stringify the property value

View Source ui/decorators.ts, line 201

Returns:

A property decorator function

Type: function

Example

// Map model properties to component properties

# uisteppedmodel(tag, pagesopt, paginatedopt, propsopt) → {function}

Combines UI model functionality with stepped/wizard form configuration This decorator creates a UI model that acts as a multi-step container with page navigation capabilities. It is designed for wizard-style forms or multi-page workflows where users progress through sequential steps. The decorator combines @uimodel with page-specific properties and optional pagination controls.

Decorator that creates a multi-step form model with page navigation

sequenceDiagram participant System participant uisteppedmodel participant uimodel participant Model participant RenderingEngine participant PaginationController System->>uisteppedmodel: apply to Model uisteppedmodel->>uimodel: call with page config uimodel->>Model: adds model metadata with pages and pagination Model->>RenderingEngine: requests rendering as stepped form RenderingEngine->>PaginationController: initialize page navigation PaginationController->>System: renders current page with navigation controls

Parameters:

Name	Type	Attributes	Default	Description
`tag`	`string`			The HTML tag to use for the stepped form container
`pages`	`number` \| `Array.<IPagedComponentProperties>`	<optional>	1	Number of pages or an array of page definitions with metadata
`paginated`	`boolean`	<optional>	false	Whether to show pagination controls (e.g., prev/next buttons)
`props`	`any`	<optional>	{}	Additional properties to pass to the container element

View Source model/decorators.ts, line 288

Returns:

A class decorator function

Type: function

Example

// Create a simple 3-step wizard form

# uitablecol(sequence, valueParserFnopt) → {function}

Controls column ordering and optional value parsing for table props Use this decorator to register list properties as table columns, define the sequence in which they appear, and optionally provide a parser that formats the value before rendering.

Decorator that marks a property as a column in a UI table

sequenceDiagram participant Model participant uitablecol participant RenderingEngine participant Table Model->>uitablecol: Apply to property uitablecol->>Model: Store column metadata RenderingEngine->>Model: Retrieve column props Model->>RenderingEngine: Return order and parser RenderingEngine->>Table: Render column in sequence

Parameters:

Name	Type	Attributes	Description
`sequence`	`number`		The display order for the column (lower means first)
`valueParserFn`	`UIFunctionLike`	<optional>	Optional formatter executed per cell

View Source ui/decorators.ts, line 532

Returns:

A property decorator function

Type: function

Example

class Order {

Type Definitions

Type: Constructor | Model | GraphWorkflowDefinition

# GraphDecoratedWorkflowInput

Anything the compiler can resolve into a GraphWorkflowDefinition: a decorated workflow class (constructor), a model instance, or a definition.

View Source graph/document/GraphDecoratedWorkflowCompiler.ts, line 390

Type: object

# GraphNodeIoMetadata

Node I/O inspection metadata (DECAF-48 §4.6) — hints the workflow canvas uses to open the inline split view for an already-ran node.

Node I/O inspection metadata (DECAF-48 §4.6) — hints the workflow canvas uses to open the inline split view for an already-ran node. Framework neutral, frontend-safe, no engine/runtime dependency (DECAF-24 §4).

Properties:

Name	Type	Attributes	Description
`view`	`GraphNodeIoViewMode`	<optional>	Default view mode for the reusable viewer. Defaults to "json".
`inputPorts`	`Array`	<optional>	Port property names shown in the right-side inputs pane.
`outputPorts`	`Array`	<optional>	Port property names shown in the left-side outputs pane.
`editable`	`boolean`	<optional>	Whether the node exposes editable config (opens the edit modal instead).
`metadata`	`Record.<string, unknown>`	<optional>	Free-form extension points.

View Source graph/constants.ts, line 105

Type: "json" | "table" | "raw"

# GraphNodeIoViewMode

A view-mode choice for the reusable I/O viewer (DECAF-48 §4.6 / Req-9).

A view-mode choice for the reusable I/O viewer (DECAF-48 §4.6 / Req-9). One shared component renders both the inputs and outputs panes.

Legacy persisted snapshot ({ version, definition, state }).

Legacy persisted snapshot ({ version, definition, state }). Kept only for loading/compatibility of persisted data; the canonical snapshot is GraphWorkflowSnapshot ({ document, editor?, metadata? }). Convert with graphWorkflowSnapshotFromLegacy / graphWorkflowSnapshotToLegacy.

Properties:

Name	Type	Description
`version`	`GraphWorkflowSnapshotVersion`
`definition`	`GraphWorkflowSnapshotDefinition`
`state`	`GraphWorkflowSnapshotState`

View Source graph/snapshot.ts, line 709

ui-decorators

Members

# constant GRAPH_CATEGORY_STYLE_REGISTRY

# constant GRAPH_DEFAULT_CATEGORY_STYLE

# constant GRAPH_LOOP_PARAMETER_KEYS

# constant GRAPH_VISUAL_STATE_STYLES

# constant NODE_REGISTRY

# constant WORKFLOW_REGISTRY

# constant isClassConstructor

Methods

# assertGraphWorkflowDocumentValid()

# boundaryPortIdsFor()

# connection()

# edgePairKeyOf()

# getUIAttributeKey(prop, key)

Parameters:

# graphCategoryStyleOf()

# graphDecoratedWorkflowCompiler()

# graphLegacyLoopMetadataOf()

# graphNodes()

# graphVisualStyleOf(state)

Parameters:

# graphWorkflowDocumentFromLegacySnapshot()

# graphWorkflowSnapshotFromLegacy()

# graphWorkflowSnapshotLikeToCanonical()

# graphWorkflowSnapshotToLegacy()

# graphWorkflows()

# hidden() → {function}

Example

# hideFor()

# hideOn(operations) → {function}

Parameters:

Example

# isGraphNodePolicyManifest() → {boolean}

# legacyRelationLabelByEndpoint()

# pinnable()

# registerGraphCategoryStyle()

# registerNode(ctor)

Parameters:

# registerWorkflow(ctor)

Parameters:

# renderIf()

# renderedBy(engine) → {function}

Parameters:

Example

# resetGraphRegistries()

# resolveEffectiveColor()

# resolveEffectiveIcon()

# resolvePortGroups()

# sanitizeLegacySnapshotPayload()

# schemaGroupPorts()

# showFor()

# uichild(clazz, tag, propsopt, serializeopt) → {function}

Parameters:

Example

# uielement(tag, propsopt, serializeopt) → {function}

Parameters:

Example

# uihandlers(propsopt) → {function}

Parameters:

Example

# uilayout(tag, colsModeopt, rowsopt, breakpointopt) → {function}

Parameters:

Example

# uilayoutprop(col, rowopt, propsopt) → {function}

Parameters:

Example

# uilistmodel(tagopt, propsopt) → {function}

Parameters:

Example

# uilistprop(propNameopt, propsopt) → {function}

Parameters:

Example

# uimodel(tagopt, propsopt) → {function}

Parameters:

Example

# uionclick(handler)

Parameters:

# uionrender(handler)

Parameters: