@stndrds/schema 0.1.0-alpha.38 → 0.1.0-alpha.39

package/dist/{runtime-Hwgvv9Bn.d.mts → runtime-B3RCubTj.d.mts}

@@ -1227,6 +1227,8 @@ declare function isNoValueOperator(operator: FilterOperator): operator is NoValu
  * Ex: "mr" for the first contact, "company" for the company
  *
  * Note: Named "Slot" to avoid confusion with DB entities
+ *
+ * @deprecated Use WorkflowSlot from types/workflows instead
  */
 interface FlowSlot {
     /** Unique identifier for the slot (ex: "mr", "mme", "company") */
@@ -1966,269 +1968,1365 @@ interface AssignRoleInput {
 }
 
 /**
- * Inline attribute group configuration
- * Groups multiple attributes into a single composite field with dropdown editing
- */
-interface AttributeGroupField {
-    /** Unique identifier for the group */
-    id: string;
-    /** Display label for the composite field */
-    label: string;
-    /** Description shown in the dropdown */
-    description?: string;
-    /** Attribute names to include in this group */
-    attributes: string[];
-    /**
-     * Template for the display value
-     * Uses {attributeName} syntax for interpolation
-     * @example "{billing_street}, {billing_city} {billing_postal_code}"
-     */
-    displayTemplate?: string;
-}
-/**
- * Field definition within a form group
- * Can be either a single attribute or an inline attribute group
- */
-interface Field {
-    /** Attribute name to display (for single attribute fields) */
-    attribute?: string;
-    /** Inline attribute group (groups multiple attributes into one composite field) */
-    attributeGroup?: AttributeGroupField;
-    /** Grid span (1-12 columns) */
-    span?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
-    /** Override label for this view (only for single attribute fields) */
-    label?: string;
-    /** Force read-only display */
-    readOnly?: boolean;
-}
-/**
- * Group of fields for organizing forms
- */
-interface Group {
-    id: string;
-    label: string;
-    description?: string;
-    fields: Field[];
-    collapsible?: boolean;
-    collapsed?: boolean;
-    order?: number;
-}
-type TabType = "form" | "table" | "custom" | "activity" | "notes";
-/**
- * Base properties shared by all tab types
+ * Document generated during workflow execution
  */
-interface BaseTab {
+interface GeneratedDocument {
+    /** Document ID */
     id: string;
-    name: string;
-    label: string;
-    icon?: IconName;
-    order?: number;
-    /** If true, tab is defined by developer (protected) */
-    system?: boolean;
+    /** URL to access the document */
+    url: string;
+    /** Document filename */
+    filename?: string;
+    /** MIME type */
+    mimeType?: string;
+    /** File size in bytes */
+    size?: number;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
 }
 /**
- * Form tab - displays attributes organized in groups
+ * Accumulated context during workflow execution.
+ *
+ * This context is built up as nodes execute and is passed to each node.
+ * It contains all the data collected and generated during the workflow.
+ *
+ * @example
+ * ```typescript
+ * const context: WorkflowExecutionContext = {
+ *   slots: {
+ *     client: {
+ *       id: "rec_123",
+ *       firstName: "John",
+ *       lastName: "Doe",
+ *       email: "john@example.com",
+ *       type: "vip"
+ *     }
+ *   },
+ *   forms: {
+ *     "client-form": {
+ *       firstName: "John",
+ *       lastName: "Doe"
+ *     }
+ *   },
+ *   documents: {},
+ *   variables: {
+ *     totalAmount: 15000
+ *   },
+ *   conditionResults: {
+ *     "check-vip": true
+ *   }
+ * };
+ * ```
  */
-interface FormTab extends BaseTab {
-    type: "form";
-    groups: Group[];
+interface WorkflowExecutionContext {
+    /**
+     * Records created/modified during execution, indexed by slot ID.
+     * Contains the full record data for each slot.
+     */
+    slots: Record<string, Record<string, unknown>>;
+    /**
+     * Form submissions indexed by node ID.
+     * Contains the raw form data submitted at each form node.
+     */
+    forms: Record<string, Record<string, unknown>>;
+    /**
+     * Documents generated during execution, indexed by node ID.
+     * Contains document metadata and URLs.
+     */
+    documents: Record<string, GeneratedDocument>;
+    /**
+     * Custom variables set during execution.
+     * Can be used by action nodes to store computed values.
+     */
+    variables: Record<string, unknown>;
+    /**
+     * Results of condition evaluations for debugging.
+     * Indexed by condition node ID.
+     */
+    conditionResults: Record<string, boolean>;
+    /**
+     * IDs of records created during workflow completion.
+     * Used for idempotence (avoid creating duplicates on retry).
+     * Indexed by slot ID.
+     */
+    createdRecordIds?: Record<string, string>;
 }
 /**
- * Shared properties for table tabs
+ * Create an empty execution context
  */
-interface TableTabBase extends BaseTab {
-    type: "table";
-    /** Columns to display (attribute names from target object) */
-    columns: string[];
-    /** Allow creating new records */
-    allowCreate?: boolean;
-    /** Allow inline editing */
-    allowEdit?: boolean;
-    /** Allow deleting records */
-    allowDelete?: boolean;
-    /** Default filters applied to the table */
-    filters?: FilterState;
-    /** Default sort rules */
-    sorts?: SortRule[];
-}
+declare function createEmptyContext(): WorkflowExecutionContext;
 /**
- * Direct table tab - displays records from a relation attribute on the current object
+ * Get a value from the context using dot notation path.
  *
- * @example Project.members → shows Users linked via the "members" relation
+ * Supports paths like:
+ * - "slots.client.email"
+ * - "forms.step1.amount"
+ * - "variables.customVar"
+ *
+ * @param context - The execution context
+ * @param path - Dot notation path to the value
+ * @returns The value at the path, or undefined if not found
+ *
+ * @example
  * ```typescript
- * {
- *   type: "table",
- *   relationMode: "direct",
- *   relationAttribute: "members",
- *   columns: ["name", "email"]
- * }
+ * const email = getContextValue(context, "slots.client.email");
+ * const amount = getContextValue(context, "forms.quote.amount");
  * ```
  */
-interface DirectTableTab extends TableTabBase {
-    relationMode: "direct";
-    /** Relation attribute name on the current object */
-    relationAttribute: string;
-}
+declare function getContextValue(context: WorkflowExecutionContext, path: string): unknown;
 /**
- * Inverse table tab - displays records from another object that have a relation to us
+ * Set a value in the context using dot notation path.
  *
- * @example Contact.company → on Company, shows Contacts that point to this Company
+ * @param context - The execution context (mutated in place)
+ * @param path - Dot notation path to set
+ * @param value - Value to set
+ *
+ * @example
  * ```typescript
- * {
- *   type: "table",
- *   relationMode: "inverse",
- *   sourceObject: "contacts",
- *   relationAttribute: "company",
- *   columns: ["firstName", "lastName", "email"]
- * }
+ * setContextValue(context, "variables.computed", 42);
+ * setContextValue(context, "slots.client.status", "active");
  * ```
  */
-interface InverseTableTab extends TableTabBase {
-    relationMode: "inverse";
-    /** Object name that has the relation to us */
-    sourceObject: string;
-    /** Relation attribute name on the source object that points to us */
-    relationAttribute: string;
-}
-/**
- * Table tab - displays related records in a table
- * Discriminated union by relationMode for type-safe configuration
- */
-type TableTab = DirectTableTab | InverseTableTab;
+declare function setContextValue(context: WorkflowExecutionContext, path: string, value: unknown): void;
 /**
- * Custom tab - renders a developer-defined component
+ * Merge form data into slot record
  */
-interface CustomTab extends BaseTab {
-    type: "custom";
-    /** Component identifier to render */
-    component: string;
-    /** Props to pass to the component */
-    props?: Record<string, unknown>;
-}
+declare function mergeFormToSlot(context: WorkflowExecutionContext, nodeId: string, slotId: string): void;
+
 /**
- * Activity tab - displays activity feed for the current record
+ * All supported comparison operators for condition rules
  */
-interface ActivityTab extends BaseTab {
-    type: "activity";
-    /** Maximum number of activities to display (optional) */
-    limit?: number;
-}
+type ConditionOperator = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "contains" | "startsWith" | "endsWith" | "isEmpty" | "isNotEmpty" | "in" | "notIn";
 /**
- * Notes tab - displays notes linked to the current record
+ * A single condition rule that compares a field value against a target value.
  *
- * Shows all notes where linked_object_name matches the current object
- * and linked_record_id matches the current record ID.
- * Respects visibility rules (private notes only visible to author).
+ * Field paths support dot notation for nested access:
+ * - `slots.client.type` - Access slot record attribute
+ * - `forms.step1.amount` - Access form submission data
+ * - `context.variables.customVar` - Access custom variables
  *
  * @example
  * ```typescript
- * {
- *   type: "notes",
- *   id: "notes",
- *   name: "notes",
- *   label: "Notes",
- *   allowCreate: true
- * }
+ * const rule: ConditionRule = {
+ *   field: "slots.client.type",
+ *   operator: "eq",
+ *   value: "vip"
+ * };
  * ```
  */
-interface NotesTab extends BaseTab {
-    type: "notes";
-    /** Show only private notes of the current user */
-    privateOnly?: boolean;
-    /** Allow creating new notes from this tab */
-    allowCreate?: boolean;
+interface ConditionRule {
+    /** Field path to evaluate (dot notation) */
+    field: string;
+    /** Comparison operator */
+    operator: ConditionOperator;
+    /** Value to compare against (type depends on operator) */
+    value: unknown;
 }
 /**
- * Union of all tab types
- */
-type Tab = FormTab | TableTab | CustomTab | ActivityTab | NotesTab;
-/**
- * View layout mode
- * - `page`: Full view with multiple tabs (form, table, activity, notes, custom)
- * - `modal`: Simplified view for modals, single FormTab without tabs UI
- */
-type ViewLayout = "page" | "modal";
-/**
- * View definition - organizes object attributes into tabs/pages
+ * A group of conditions combined with AND/OR logic.
+ * Groups can be nested for complex conditions.
  *
- * @example
+ * @example Simple AND condition
  * ```typescript
- * const companyView: ViewDefinition = {
- *   name: "detail",
- *   label: "Company Detail",
- *   object: "companies",
- *   layout: "page",
- *   tabs: [
- *     { type: "form", name: "general", label: "Info", groups: [...] },
- *     { type: "table", relationMode: "inverse", sourceObject: "contacts", relationAttribute: "company", columns: [...] }
- *   ],
- *   default: true,
- *   system: true
+ * const condition: ConditionGroup = {
+ *   operator: "and",
+ *   rules: [
+ *     { field: "slots.client.type", operator: "eq", value: "vip" },
+ *     { field: "slots.client.active", operator: "eq", value: true }
+ *   ]
+ * };
+ * ```
+ *
+ * @example Nested condition (VIP OR (Premium AND Active))
+ * ```typescript
+ * const condition: ConditionGroup = {
+ *   operator: "or",
+ *   rules: [
+ *     { field: "slots.client.type", operator: "eq", value: "vip" },
+ *     {
+ *       operator: "and",
+ *       rules: [
+ *         { field: "slots.client.type", operator: "eq", value: "premium" },
+ *         { field: "slots.client.active", operator: "eq", value: true }
+ *       ]
+ *     }
+ *   ]
  * };
  * ```
  */
-interface ViewDefinition {
-    id?: Uuid;
-    /** Technical name (kebab-case) */
-    name: string;
-    /** Display label */
-    label: string;
-    /** Description */
-    description?: string;
-    /** Icon */
-    icon?: IconName;
-    /** Object this view belongs to (object name) */
-    object: string;
-    /**
-     * Layout mode for the view
-     * - `page`: Full view with multiple tabs
-     * - `modal`: Simplified view for modals (single FormTab, no tabs UI)
-     * @default "page"
-     */
-    layout?: ViewLayout;
-    /** Tabs in this view */
-    tabs: Tab[];
-    /** Default view for this object (per layout) */
-    default?: boolean;
-    /** System view (defined by developer, protected) */
-    system?: boolean;
-    /** Extensible metadata */
-    metadata?: Record<string, unknown>;
+interface ConditionGroup {
+    /** Logical operator to combine rules */
+    operator: "and" | "or";
+    /** Array of rules or nested groups */
+    rules: Array<ConditionRule | ConditionGroup>;
 }
 /**
- * Check if a tab is a form tab
+ * Check if an item is a ConditionRule (not a ConditionGroup)
  */
-declare function isFormTab(tab: Tab): tab is FormTab;
+declare function isConditionRule(item: ConditionRule | ConditionGroup): item is ConditionRule;
 /**
- * Check if a tab is a table tab
+ * Check if an item is a ConditionGroup
  */
-declare function isTableTab(tab: Tab): tab is TableTab;
+declare function isConditionGroup(item: ConditionRule | ConditionGroup): item is ConditionGroup;
 /**
- * Check if a table tab is a direct relation tab
+ * Create a simple equality condition
  */
-declare function isDirectTableTab(tab: Tab): tab is DirectTableTab;
+declare function eq(field: string, value: unknown): ConditionRule;
 /**
- * Check if a table tab is an inverse relation tab
+ * Create a simple inequality condition
  */
-declare function isInverseTableTab(tab: Tab): tab is InverseTableTab;
+declare function neq(field: string, value: unknown): ConditionRule;
 /**
- * Check if a tab is a custom tab
+ * Create an AND condition group
  */
-declare function isCustomTab(tab: Tab): tab is CustomTab;
+declare function and(...rules: Array<ConditionRule | ConditionGroup>): ConditionGroup;
 /**
- * Check if a tab is an activity tab
+ * Create an OR condition group
  */
-declare function isActivityTab(tab: Tab): tab is ActivityTab;
+declare function or(...rules: Array<ConditionRule | ConditionGroup>): ConditionGroup;
 /**
- * Check if a tab is a notes tab
+ * Create an "in" condition (value in array)
  */
-declare function isNotesTab(tab: Tab): tab is NotesTab;
+declare function inValues(field: string, values: unknown[]): ConditionRule;
+/**
+ * Create an isEmpty condition
+ */
+declare function isEmpty(field: string): ConditionRule;
+/**
+ * Create an isNotEmpty condition
+ */
+declare function isNotEmpty(field: string): ConditionRule;
 
 /**
- * Object as stored in database (metadata)
+ * Base properties shared by all workflow nodes
  */
-interface DBObject extends Timestamps {
-    id: Uuid;
+interface BaseNode {
+    /** Unique node identifier */
+    id: string;
+}
+/**
+ * Entry point of the workflow. Each workflow has exactly one StartNode.
+ */
+interface StartNode extends BaseNode {
+    type: "start";
+    /** ID of the next node to execute (optional for drafts) */
+    next?: string | null;
+}
+/**
+ * Form node for collecting user input.
+ *
+ * Each FormNode acts as a "step" or "page" in the workflow.
+ * It can contain fields from multiple slots, allowing complex forms
+ * that collect data for different objects.
+ *
+ * @example Simple mode (single slot, quick setup)
+ * ```typescript
+ * const node: FormNode = {
+ *   type: "form",
+ *   id: "client-info",
+ *   label: "Client Information",
+ *   fields: [
+ *     { slotId: "client", attribute: "firstName" },
+ *     { slotId: "client", attribute: "lastName" },
+ *   ],
+ *   next: "check-vip"
+ * };
+ * ```
+ *
+ * @example Advanced mode (multiple slots, custom layout)
+ * ```typescript
+ * const node: FormNode = {
+ *   type: "form",
+ *   id: "couple-info",
+ *   label: "Couple Information",
+ *   rows: [
+ *     { id: "row-1", order: 1, fields: [
+ *       { id: "f1", slotId: "mr", attribute: "firstName" },
+ *       { id: "f2", slotId: "mme", attribute: "firstName" },
+ *     ]},
+ *     { id: "row-2", order: 2, fields: [
+ *       { id: "f3", slotId: "company", attribute: "name" },
+ *     ]},
+ *   ],
+ *   next: "check-vip"
+ * };
+ * ```
+ */
+interface FormNode extends BaseNode {
+    type: "form";
+    /** Display label for the form step */
+    label: string;
+    /** Optional description */
+    description?: string;
+    /**
+     * Simple mode: list of field references.
+     * Each field specifies the slot and attribute.
+     * Creates one field per row with equal width.
+     * Mutually exclusive with `rows`.
+     */
+    fields?: FormFieldRef[];
+    /**
+     * Advanced mode: full row/field structure for custom layouts.
+     * Each row can contain multiple fields from different slots.
+     * Mutually exclusive with `fields`.
+     */
+    rows?: FlowRow[];
+    /**
+     * ID of the participant template allowed to fill this form.
+     * If set, only this participant can execute this node.
+     */
+    participantId?: string | null;
+    /** ID of the next node to execute (optional for drafts) */
+    next?: string | null;
+}
+/**
+ * Simple field reference for FormNode simple mode
+ */
+interface FormFieldRef {
+    /** Reference to WorkflowSlot.id */
+    slotId: string;
+    /** Attribute name on the object */
+    attribute: string;
+}
+/**
+ * Check if a FormNode uses simple mode (fields array)
+ */
+declare function isSimpleFormNode(node: FormNode): boolean;
+/**
+ * Check if a FormNode uses advanced mode (rows array)
+ */
+declare function isAdvancedFormNode(node: FormNode): boolean;
+
+/**
+ * Conditional branching node.
+ * Evaluates a condition and routes to different nodes based on the result.
+ *
+ * @example
+ * ```typescript
+ * const node: ConditionNode = {
+ *   type: "condition",
+ *   id: "check-vip",
+ *   label: "Is VIP Customer?",
+ *   condition: {
+ *     operator: "or",
+ *     rules: [
+ *       { field: "slots.client.type", operator: "eq", value: "vip" },
+ *       { field: "slots.client.type", operator: "eq", value: "premium" }
+ *     ]
+ *   },
+ *   onTrue: "premium-flow",
+ *   onFalse: "standard-flow"
+ * };
+ * ```
+ */
+interface ConditionNode extends BaseNode {
+    type: "condition";
+    /** Display label for the condition */
+    label: string;
+    /** Condition to evaluate */
+    condition: ConditionGroup;
+    /** ID of node to execute if condition is true (optional for drafts) */
+    onTrue?: string | null;
+    /** ID of node to execute if condition is false (optional for drafts) */
+    onFalse?: string | null;
+}
+/**
+ * Terminal node marking the end of a workflow path.
+ * A workflow can have multiple EndNodes for different outcomes.
+ *
+ * @example
+ * ```typescript
+ * const successEnd: EndNode = {
+ *   type: "end",
+ *   id: "end-success",
+ *   label: "Completed Successfully",
+ *   status: "completed"
+ * };
+ *
+ * const declinedEnd: EndNode = {
+ *   type: "end",
+ *   id: "end-declined",
+ *   label: "Customer Declined",
+ *   status: "declined"
+ * };
+ * ```
+ */
+interface EndNode extends BaseNode {
+    type: "end";
+    /** Optional display label */
+    label?: string;
+    /**
+     * Final status for the workflow instance.
+     * Common values: "completed", "declined", "cancelled", "expired"
+     */
+    status?: string;
+}
+/**
+ * Union of all workflow node types.
+ * Use discriminated union on `type` field for type narrowing.
+ */
+type WorkflowNode = StartNode | FormNode | ConditionNode | EndNode;
+/**
+ * All possible node types
+ */
+type WorkflowNodeType = WorkflowNode["type"];
+/**
+ * Check if a node is a StartNode
+ */
+declare function isStartNode(node: WorkflowNode): node is StartNode;
+/**
+ * Check if a node is a FormNode
+ */
+declare function isFormNode(node: WorkflowNode): node is FormNode;
+/**
+ * Check if a node is a ConditionNode
+ */
+declare function isConditionNode(node: WorkflowNode): node is ConditionNode;
+/**
+ * Check if a node is an EndNode
+ */
+declare function isEndNode(node: WorkflowNode): node is EndNode;
+/**
+ * Get the output node IDs from a node (for graph traversal)
+ */
+declare function getNodeOutputs(node: WorkflowNode): string[];
+
+/**
+ * Logo configuration for external-facing interface
+ */
+interface ThemeLogo {
+    /** URL to the logo image */
+    url: string;
+    /** Alt text for accessibility */
+    alt?: string;
+    /** Max height in pixels */
+    maxHeight?: number;
+}
+/**
+ * Color configuration for theming
+ */
+interface ThemeColors {
+    /** Primary brand color (hex) */
+    primary?: string;
+    /** Primary color for text on primary background */
+    primaryForeground?: string;
+    /** Background color */
+    background?: string;
+    /** Foreground/text color */
+    foreground?: string;
+    /** Muted/secondary color */
+    muted?: string;
+    /** Border color */
+    border?: string;
+    /** Accent color for highlights */
+    accent?: string;
+}
+/**
+ * Typography configuration
+ */
+interface ThemeTypography {
+    /** Font family for headings */
+    headingFont?: string;
+    /** Font family for body text */
+    bodyFont?: string;
+    /** Base font size in pixels */
+    baseFontSize?: number;
+}
+/**
+ * Complete theme configuration for external-facing workflow interface.
+ *
+ * Allows full branding customization for forms displayed to external users.
+ *
+ * @example
+ * ```typescript
+ * const theme: WorkflowTheme = {
+ *   logo: {
+ *     url: "https://example.com/logo.png",
+ *     alt: "Company Logo",
+ *     maxHeight: 48
+ *   },
+ *   colors: {
+ *     primary: "#3B82F6",
+ *     primaryForeground: "#FFFFFF",
+ *     background: "#F8FAFC"
+ *   },
+ *   typography: {
+ *     headingFont: "Inter, sans-serif",
+ *     bodyFont: "Inter, sans-serif"
+ *   },
+ *   borderRadius: 8
+ * };
+ * ```
+ */
+interface WorkflowTheme {
+    /** Logo configuration */
+    logo?: ThemeLogo;
+    /** Color palette */
+    colors?: ThemeColors;
+    /** Typography settings */
+    typography?: ThemeTypography;
+    /** Border radius for cards/buttons in pixels */
+    borderRadius?: number;
+    /** Show powered by badge */
+    showPoweredBy?: boolean;
+    /** Custom CSS (advanced) */
+    customCss?: string;
+}
+/**
+ * Default theme values
+ */
+declare const DEFAULT_THEME: Required<Pick<WorkflowTheme, "borderRadius" | "showPoweredBy">>;
+/**
+ * Merge a partial theme with defaults
+ */
+declare function mergeWithDefaults(theme?: WorkflowTheme): WorkflowTheme;
+/**
+ * Generate CSS variables from theme colors
+ */
+declare function generateCssVariables(colors?: ThemeColors): Record<string, string>;
+
+/**
+ * Mode for slot initialization when starting a workflow
+ */
+type SlotMode = "create" | "select" | "optional";
+/**
+ * Represents a "slot" for an object in the workflow.
+ * Slots define which objects are manipulated during workflow execution.
+ *
+ * @example
+ * ```typescript
+ * const clientSlot: WorkflowSlot = {
+ *   id: "client",
+ *   objectName: "contacts",
+ *   label: "Client",
+ *   mode: "optional",
+ *   color: "blue",
+ *   icon: "User"
+ * };
+ * ```
+ */
+interface WorkflowSlot {
+    /** Unique identifier for the slot */
+    id: string;
+    /** Name of the object definition (e.g., "contacts", "companies") */
+    objectName: string;
+    /** Display label */
+    label: string;
+    /** How the slot is initialized at workflow start */
+    mode: SlotMode;
+    /** Color for visual distinction in the builder */
+    color?: ColorId;
+    /** Optional icon */
+    icon?: IconName;
+}
+/**
+ * Position of a node in the visual builder
+ */
+interface NodePosition {
+    x: number;
+    y: number;
+}
+/**
+ * Viewport state for the canvas
+ */
+interface CanvasViewport {
+    x: number;
+    y: number;
+    zoom: number;
+}
+/**
+ * Layout information for the workflow builder.
+ * Separated from business data to allow different visualizations.
+ */
+interface WorkflowLayout {
+    /** Node positions by node ID */
+    positions: Record<string, NodePosition>;
+    /** Canvas viewport state */
+    viewport?: CanvasViewport;
+}
+/**
+ * Authentication method for external participants
+ */
+type AuthMethod = "signed_link" | "pin_code";
+/**
+ * Channel for sending authentication credentials
+ */
+type AuthChannel = "email" | "sms";
+/**
+ * Default authentication configuration for a participant
+ */
+interface ParticipantAuthConfig {
+    /** Authentication method */
+    method: AuthMethod;
+    /** Link/code expiration (e.g., "7d", "24h") */
+    expiresIn?: string;
+    /** Channel for sending credentials */
+    channel?: AuthChannel;
+}
+/**
+ * Template for a participant in the workflow.
+ * Defines who can participate and how they authenticate.
+ *
+ * Note: This is a template defined in WorkflowDefinition.
+ * At runtime, WorkflowParticipation instances are created from this.
+ *
+ * @example
+ * ```typescript
+ * const externalClient: ParticipantTemplate = {
+ *   id: "external-client",
+ *   label: "Client Externe",
+ *   type: "external",
+ *   emailSource: "slots.client.email",
+ *   defaultAuth: {
+ *     method: "signed_link",
+ *     expiresIn: "7d",
+ *     channel: "email"
+ *   },
+ *   allowedNodeIds: ["client-form", "signature-step"]
+ * };
+ * ```
+ */
+interface ParticipantTemplate {
+    /** Unique identifier */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Type of participant */
+    type: "internal" | "external";
+    /**
+     * Path to email in execution context (for external participants).
+     * Supports dot notation: "slots.client.email"
+     */
+    emailSource?: string;
+    /**
+     * Path to phone in execution context (for SMS auth).
+     * Supports dot notation: "slots.client.phone"
+     */
+    phoneSource?: string;
+    /** Default authentication configuration */
+    defaultAuth: ParticipantAuthConfig;
+    /** IDs of nodes this participant can execute */
+    allowedNodeIds: string[];
+}
+/**
+ * Global configuration options for a workflow
+ */
+interface WorkflowConfig {
+    /** Time-to-live for workflow instances (e.g., "30d") */
+    instanceTtl?: string;
+    /** Time-to-live for external participation links (e.g., "7d") */
+    externalLinkTtl?: string;
+    /** Whether external participants are allowed */
+    allowExternalParticipants?: boolean;
+}
+/**
+ * Workflow lifecycle status
+ */
+type WorkflowStatus = "draft" | "published" | "archived";
+/**
+ * Complete workflow definition (the "blueprint").
+ *
+ * This is the design-time representation of a workflow.
+ * When executed, a WorkflowInstance is created from this definition.
+ *
+ * @example
+ * ```typescript
+ * const workflow: WorkflowDefinition = {
+ *   name: "client-onboarding",
+ *   label: "Client Onboarding",
+ *   status: "draft",
+ *   version: 1,
+ *   slots: [{ id: "client", objectName: "contacts", label: "Client", mode: "create" }],
+ *   nodes: {
+ *     "start": { type: "start", id: "start", next: "form-1" },
+ *     "form-1": { type: "form", id: "form-1", label: "Info", slotId: "client", fields: ["name"], next: "end" },
+ *     "end": { type: "end", id: "end" }
+ *   },
+ *   startNodeId: "start",
+ *   layout: { positions: { "start": { x: 0, y: 0 }, "form-1": { x: 200, y: 0 }, "end": { x: 400, y: 0 } } }
+ * };
+ * ```
+ */
+interface WorkflowDefinition {
+    /** Database ID */
+    id?: Uuid;
+    /** Technical name (kebab-case, unique per tenant) */
+    name: string;
+    /** Display label */
+    label: string;
+    /** Optional description */
+    description?: string;
+    /** Optional icon */
+    icon?: IconName;
+    /** Workflow lifecycle status */
+    status: WorkflowStatus;
+    /** Version number (incremented on publish) */
+    version: number;
+    /** Slots (objects) manipulated in this workflow */
+    slots: WorkflowSlot[];
+    /** Nodes indexed by ID for O(1) access */
+    nodes: Record<string, WorkflowNode>;
+    /** ID of the start node */
+    startNodeId: string;
+    /** Layout information for the visual builder */
+    layout: WorkflowLayout;
+    /** Participant templates (for external users) */
+    participants?: ParticipantTemplate[];
+    /** Theming for external-facing interface */
+    theme?: WorkflowTheme;
+    /** Global configuration options */
+    config?: WorkflowConfig;
+    /** Tenant ID for multi-tenant isolation */
+    tenantId?: string;
+    /** If true, defined in code (protected from UI deletion) */
+    system?: boolean;
+    /** Extensible metadata */
+    metadata?: Record<string, unknown>;
+    /** Timestamps */
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/**
+ * Check if an object is a WorkflowDefinition
+ */
+declare function isWorkflowDefinition(obj: unknown): obj is WorkflowDefinition;
+/**
+ * Check if a workflow is published
+ */
+declare function isWorkflowPublished(workflow: WorkflowDefinition): boolean;
+/**
+ * Check if a workflow is a system workflow
+ */
+declare function isSystemWorkflow(workflow: WorkflowDefinition): boolean;
+
+/**
+ * Status of a workflow instance
+ */
+type InstanceStatus = "running" | "waiting" | "completed" | "failed" | "cancelled";
+/**
+ * Record of a transition between nodes
+ */
+interface WorkflowTransition {
+    /** Timestamp of the transition */
+    timestamp: Date;
+    /** ID of the source node */
+    fromNodeId: string | null;
+    /** ID of the target node */
+    toNodeId: string;
+    /** Type of the target node */
+    nodeType: string;
+    /** ID of the user/participant who triggered the transition */
+    triggeredBy?: string;
+    /** Duration of node execution in milliseconds */
+    durationMs?: number;
+    /** Metadata about the transition */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Error information when instance is in "failed" status
+ */
+interface WorkflowError {
+    /** Error code for programmatic handling */
+    code: string;
+    /** Human-readable error message */
+    message: string;
+    /** ID of the node where error occurred */
+    nodeId?: string;
+    /** Stack trace (if available) */
+    stack?: string;
+    /** Additional error details */
+    details?: Record<string, unknown>;
+    /** Timestamp when error occurred */
+    timestamp: Date;
+}
+/**
+ * Information about the action the workflow is waiting for.
+ * Populated when status is "waiting".
+ */
+interface PendingAction {
+    /** ID of the node waiting for action */
+    nodeId: string;
+    /** Type of the waiting node */
+    nodeType: "form" | "signature" | "approval";
+    /** Display label for the action */
+    nodeLabel: string;
+    /** ID of the participation required to complete this action */
+    requiredParticipationId?: string;
+    /** When the pending action expires */
+    expiresAt?: Date;
+}
+/**
+ * A specific execution of a workflow.
+ *
+ * Each instance maintains its own state, context, and history.
+ * The workflow definition is snapshotted at creation to ensure
+ * consistent execution even if the definition is later modified.
+ *
+ * @example
+ * ```typescript
+ * const instance: WorkflowInstance = {
+ *   id: "inst_123",
+ *   workflowId: "wf_456",
+ *   workflowVersion: 3,
+ *   workflowSnapshot: { ... }, // Full definition at creation time
+ *   status: "waiting",
+ *   currentNodeId: "client-form",
+ *   context: { slots: {}, forms: {}, documents: {}, variables: {}, conditionResults: {} },
+ *   history: [{ timestamp: new Date(), fromNodeId: null, toNodeId: "start", nodeType: "start" }],
+ *   pendingAction: {
+ *     nodeId: "client-form",
+ *     nodeType: "form",
+ *     nodeLabel: "Client Information",
+ *     requiredParticipationId: "part_789"
+ *   },
+ *   startedBy: "user_001",
+ *   tenantId: "tenant_abc",
+ *   createdAt: new Date()
+ * };
+ * ```
+ */
+interface WorkflowInstance {
+    /** Unique instance ID */
+    id: Uuid;
+    /** Reference to the workflow definition */
+    workflowId: Uuid;
+    /** Version of the workflow at creation time */
+    workflowVersion: number;
+    /** Complete snapshot of the workflow definition */
+    workflowSnapshot: WorkflowDefinition;
+    /** Current execution status */
+    status: InstanceStatus;
+    /** ID of the current node */
+    currentNodeId: string;
+    /** Accumulated execution context */
+    context: WorkflowExecutionContext;
+    /** History of node transitions */
+    history: WorkflowTransition[];
+    /** Current pending action (when status is "waiting") */
+    pendingAction?: PendingAction;
+    /** Error information (when status is "failed") */
+    error?: WorkflowError;
+    /** ID of the user who started the workflow */
+    startedBy: string;
+    /** Tenant ID for multi-tenant isolation */
+    tenantId: string;
+    /** When the instance expires */
+    expiresAt?: Date;
+    /** Timestamps */
+    createdAt: Date;
+    updatedAt: Date;
+    completedAt?: Date;
+}
+/**
+ * Check if an instance is in a terminal state
+ */
+declare function isInstanceTerminal(instance: WorkflowInstance): boolean;
+/**
+ * Check if an instance is waiting for external action
+ */
+declare function isInstanceWaiting(instance: WorkflowInstance): boolean;
+/**
+ * Check if an instance can be resumed
+ */
+declare function canResumeInstance(instance: WorkflowInstance): boolean;
+/**
+ * Create initial transition record for workflow start
+ */
+declare function createStartTransition(startNodeId: string, startedBy: string): WorkflowTransition;
+
+/**
+ * Inline attribute group configuration
+ * Groups multiple attributes into a single composite field with dropdown editing
+ */
+interface AttributeGroupField {
+    /** Unique identifier for the group */
+    id: string;
+    /** Display label for the composite field */
+    label: string;
+    /** Description shown in the dropdown */
+    description?: string;
+    /** Attribute names to include in this group */
+    attributes: string[];
+    /**
+     * Template for the display value
+     * Uses {attributeName} syntax for interpolation
+     * @example "{billing_street}, {billing_city} {billing_postal_code}"
+     */
+    displayTemplate?: string;
+}
+/**
+ * Field definition within a form group
+ * Can be either a single attribute or an inline attribute group
+ */
+interface Field {
+    /** Attribute name to display (for single attribute fields) */
+    attribute?: string;
+    /** Inline attribute group (groups multiple attributes into one composite field) */
+    attributeGroup?: AttributeGroupField;
+    /** Grid span (1-12 columns) */
+    span?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+    /** Override label for this view (only for single attribute fields) */
+    label?: string;
+    /** Force read-only display */
+    readOnly?: boolean;
+}
+/**
+ * Group of fields for organizing forms
+ */
+interface Group {
+    id: string;
+    label: string;
+    description?: string;
+    fields: Field[];
+    collapsible?: boolean;
+    collapsed?: boolean;
+    order?: number;
+}
+type TabType = "form" | "table" | "custom" | "activity" | "notes" | "flows";
+/**
+ * Base properties shared by all tab types
+ */
+interface BaseTab {
+    id: string;
+    name: string;
+    label: string;
+    icon?: IconName;
+    order?: number;
+    /** If true, tab is defined by developer (protected) */
+    system?: boolean;
+}
+/**
+ * Form tab - displays attributes organized in groups
+ */
+interface FormTab extends BaseTab {
+    type: "form";
+    groups: Group[];
+}
+/**
+ * Shared properties for table tabs
+ */
+interface TableTabBase extends BaseTab {
+    type: "table";
+    /** Columns to display (attribute names from target object) */
+    columns: string[];
+    /** Allow creating new records */
+    allowCreate?: boolean;
+    /** Allow inline editing */
+    allowEdit?: boolean;
+    /** Allow deleting records */
+    allowDelete?: boolean;
+    /** Default filters applied to the table */
+    filters?: FilterState;
+    /** Default sort rules */
+    sorts?: SortRule[];
+}
+/**
+ * Direct table tab - displays records from a relation attribute on the current object
+ *
+ * @example Project.members → shows Users linked via the "members" relation
+ * ```typescript
+ * {
+ *   type: "table",
+ *   relationMode: "direct",
+ *   relationAttribute: "members",
+ *   columns: ["name", "email"]
+ * }
+ * ```
+ */
+interface DirectTableTab extends TableTabBase {
+    relationMode: "direct";
+    /** Relation attribute name on the current object */
+    relationAttribute: string;
+}
+/**
+ * Inverse table tab - displays records from another object that have a relation to us
+ *
+ * @example Contact.company → on Company, shows Contacts that point to this Company
+ * ```typescript
+ * {
+ *   type: "table",
+ *   relationMode: "inverse",
+ *   sourceObject: "contacts",
+ *   relationAttribute: "company",
+ *   columns: ["firstName", "lastName", "email"]
+ * }
+ * ```
+ */
+interface InverseTableTab extends TableTabBase {
+    relationMode: "inverse";
+    /** Object name that has the relation to us */
+    sourceObject: string;
+    /** Relation attribute name on the source object that points to us */
+    relationAttribute: string;
+}
+/**
+ * Table tab - displays related records in a table
+ * Discriminated union by relationMode for type-safe configuration
+ */
+type TableTab = DirectTableTab | InverseTableTab;
+/**
+ * Custom tab - renders a developer-defined component
+ */
+interface CustomTab extends BaseTab {
+    type: "custom";
+    /** Component identifier to render */
+    component: string;
+    /** Props to pass to the component */
+    props?: Record<string, unknown>;
+}
+/**
+ * Activity tab - displays activity feed for the current record
+ */
+interface ActivityTab extends BaseTab {
+    type: "activity";
+    /** Maximum number of activities to display (optional) */
+    limit?: number;
+}
+/**
+ * Notes tab - displays notes linked to the current record
+ *
+ * Shows all notes where linked_object_name matches the current object
+ * and linked_record_id matches the current record ID.
+ * Respects visibility rules (private notes only visible to author).
+ *
+ * @example
+ * ```typescript
+ * {
+ *   type: "notes",
+ *   id: "notes",
+ *   name: "notes",
+ *   label: "Notes",
+ *   allowCreate: true
+ * }
+ * ```
+ */
+interface NotesTab extends BaseTab {
+    type: "notes";
+    /** Show only private notes of the current user */
+    privateOnly?: boolean;
+    /** Allow creating new notes from this tab */
+    allowCreate?: boolean;
+}
+/**
+ * Flows tab - displays workflow instances linked to the current record
+ *
+ * Uses record.metadata.createdByWorkflow to find linked instances.
+ * Allows launching new instances from published workflows that have
+ * a slot matching the current object.
+ *
+ * @example
+ * ```typescript
+ * {
+ *   type: "flows",
+ *   id: "workflows",
+ *   name: "workflows",
+ *   label: "Workflows",
+ *   allowStart: true,
+ *   allowCancel: true
+ * }
+ * ```
+ */
+interface FlowsTab extends BaseTab {
+    type: "flows";
+    /** Show only instances with specific statuses */
+    statusFilter?: InstanceStatus[];
+    /** Allow starting new workflow instances */
+    allowStart?: boolean;
+    /** Allow canceling running instances */
+    allowCancel?: boolean;
+    /** Columns to display in the instances table */
+    columns?: ("workflow" | "status" | "startedBy" | "createdAt" | "updatedAt")[];
+}
+/**
+ * Union of all tab types
+ */
+type Tab = FormTab | TableTab | CustomTab | ActivityTab | NotesTab | FlowsTab;
+/**
+ * View layout mode
+ * - `page`: Full view with multiple tabs (form, table, activity, notes, custom)
+ * - `modal`: Simplified view for modals, single FormTab without tabs UI
+ */
+type ViewLayout = "page" | "modal";
+/**
+ * View definition - organizes object attributes into tabs/pages
+ *
+ * @example
+ * ```typescript
+ * const companyView: ViewDefinition = {
+ *   name: "detail",
+ *   label: "Company Detail",
+ *   object: "companies",
+ *   layout: "page",
+ *   tabs: [
+ *     { type: "form", name: "general", label: "Info", groups: [...] },
+ *     { type: "table", relationMode: "inverse", sourceObject: "contacts", relationAttribute: "company", columns: [...] }
+ *   ],
+ *   default: true,
+ *   system: true
+ * };
+ * ```
+ */
+interface ViewDefinition {
+    id?: Uuid;
+    /** Technical name (kebab-case) */
+    name: string;
+    /** Display label */
+    label: string;
+    /** Description */
+    description?: string;
+    /** Icon */
+    icon?: IconName;
+    /** Object this view belongs to (object name) */
+    object: string;
+    /**
+     * Layout mode for the view
+     * - `page`: Full view with multiple tabs
+     * - `modal`: Simplified view for modals (single FormTab, no tabs UI)
+     * @default "page"
+     */
+    layout?: ViewLayout;
+    /** Tabs in this view */
+    tabs: Tab[];
+    /** Default view for this object (per layout) */
+    default?: boolean;
+    /** System view (defined by developer, protected) */
+    system?: boolean;
+    /** Extensible metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Check if a tab is a form tab
+ */
+declare function isFormTab(tab: Tab): tab is FormTab;
+/**
+ * Check if a tab is a table tab
+ */
+declare function isTableTab(tab: Tab): tab is TableTab;
+/**
+ * Check if a table tab is a direct relation tab
+ */
+declare function isDirectTableTab(tab: Tab): tab is DirectTableTab;
+/**
+ * Check if a table tab is an inverse relation tab
+ */
+declare function isInverseTableTab(tab: Tab): tab is InverseTableTab;
+/**
+ * Check if a tab is a custom tab
+ */
+declare function isCustomTab(tab: Tab): tab is CustomTab;
+/**
+ * Check if a tab is an activity tab
+ */
+declare function isActivityTab(tab: Tab): tab is ActivityTab;
+/**
+ * Check if a tab is a notes tab
+ */
+declare function isNotesTab(tab: Tab): tab is NotesTab;
+/**
+ * Check if a tab is a flows tab
+ */
+declare function isFlowsTab(tab: Tab): tab is FlowsTab;
+
+/**
+ * Status of a workflow participation
+ */
+type ParticipationStatus = "pending" | "active" | "completed" | "expired" | "revoked";
+/**
+ * Signed link authentication (JWT-based)
+ */
+interface SignedLinkAuth {
+    type: "signed_link";
+    /** JWT token for authentication */
+    token: string;
+    /** Token expiration date */
+    expiresAt: Date;
+    /** Whether the link has been used */
+    used: boolean;
+    /** IP address that used the link (for audit) */
+    usedFromIp?: string;
+}
+/**
+ * PIN code authentication
+ */
+interface PinCodeAuth {
+    type: "pin_code";
+    /** Hashed PIN code */
+    codeHash: string;
+    /** Code expiration date */
+    expiresAt: Date;
+    /** Number of failed attempts */
+    attempts: number;
+    /** Max allowed attempts before lockout */
+    maxAttempts: number;
+    /** Whether currently locked out */
+    lockedOut: boolean;
+    /** When lockout expires */
+    lockedUntil?: Date;
+}
+/**
+ * Union of all authentication types
+ */
+type ParticipationAuth = SignedLinkAuth | PinCodeAuth;
+/**
+ * Represents an external or internal user's participation in a workflow instance.
+ *
+ * Created at runtime from ParticipantTemplate when the workflow reaches
+ * a node that requires participation.
+ *
+ * @example
+ * ```typescript
+ * const participation: WorkflowParticipation = {
+ *   id: "part_123",
+ *   instanceId: "inst_456",
+ *   participantTemplateId: "external-client",
+ *   type: "external",
+ *   email: "client@example.com",
+ *   name: "John Doe",
+ *   auth: {
+ *     type: "signed_link",
+ *     token: "eyJ...",
+ *     expiresAt: new Date("2024-01-15"),
+ *     used: false
+ *   },
+ *   allowedNodeIds: ["client-form", "signature-step"],
+ *   status: "pending",
+ *   createdAt: new Date()
+ * };
+ * ```
+ */
+interface WorkflowParticipation {
+    /** Unique participation ID */
+    id: Uuid;
+    /** ID of the workflow instance */
+    instanceId: Uuid;
+    /** ID of the participant template this was created from */
+    participantTemplateId: string;
+    /** Type of participant */
+    type: "internal" | "external";
+    /** Participant's email */
+    email: string;
+    /** Participant's display name */
+    name?: string;
+    /** Participant's phone (for SMS auth) */
+    phone?: string;
+    /** Authentication credentials */
+    auth: ParticipationAuth;
+    /** IDs of nodes this participant can execute */
+    allowedNodeIds: string[];
+    /** Current participation status */
+    status: ParticipationStatus;
+    /** When the participant authenticated */
+    authenticatedAt?: Date;
+    /** Last activity timestamp */
+    lastActivityAt?: Date;
+    /** Completed node IDs */
+    completedNodeIds: string[];
+    /** Timestamps */
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Check if auth is signed link type
+ */
+declare function isSignedLinkAuth(auth: ParticipationAuth): auth is SignedLinkAuth;
+/**
+ * Check if auth is PIN code type
+ */
+declare function isPinCodeAuth(auth: ParticipationAuth): auth is PinCodeAuth;
+/**
+ * Check if participation is active and can execute nodes
+ */
+declare function canParticipate(participation: WorkflowParticipation): boolean;
+/**
+ * Check if participation can be authenticated (pending and not expired)
+ */
+declare function canAuthenticate(participation: WorkflowParticipation): boolean;
+/**
+ * Check if a participation can execute a specific node
+ */
+declare function canExecuteNode(participation: WorkflowParticipation, nodeId: string): boolean;
+
+/**
+ * Workflow access mode - determines how the user is authenticated
+ * and what permissions they have.
+ */
+type WorkflowAccessMode = {
+    type: "internal";
+    userId: string;
+} | {
+    type: "external";
+    token: string;
+    participationId: string;
+};
+/**
+ * Reason why a field is read-only
+ */
+type ReadOnlyReason = "user_field" | "computed" | "system";
+/**
+ * Context for a single form field.
+ * Contains schema, current value, and access information.
+ */
+interface FormFieldContext {
+    /** Slot ID this field belongs to */
+    slotId: string;
+    /** Attribute name */
+    attributeName: string;
+    /** Full attribute schema */
+    schema: Attribute;
+    /** Current value (from slot) */
+    value: unknown;
+    /** Is this field read-only for the current access mode? */
+    readOnly: boolean;
+    /** Reason for read-only (if applicable) */
+    readOnlyReason?: ReadOnlyReason;
+}
+/**
+ * A row of form fields.
+ * Preserves the row structure defined in the workflow form node.
+ */
+interface FormFieldRow {
+    /** Row ID from the workflow definition */
+    id: string;
+    /** Fields in this row */
+    fields: FormFieldContext[];
+}
+/**
+ * Form node information
+ */
+interface FormNodeInfo {
+    /** Node ID */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Optional description */
+    description?: string;
+}
+/**
+ * Complete form context response.
+ * Contains all information needed to render a workflow form.
+ */
+interface FormContextResponse {
+    /** Form node definition */
+    node: FormNodeInfo;
+    /** Structured rows with their fields (preserves layout from workflow) */
+    rows: FormFieldRow[];
+    /** Flat list of all fields (for backward compatibility) */
+    fields: FormFieldContext[];
+    /** Current slot values */
+    slotValues: Record<string, Record<string, unknown>>;
+    /** Slot definitions for displaying slot labels and colors */
+    slots: WorkflowSlot[];
+    /** Workflow theme for styling */
+    theme?: WorkflowTheme;
+    /** Access mode for the current user */
+    accessMode: "internal" | "external";
+}
+
+/**
+ * Object as stored in database (metadata)
+ */
+interface DBObject extends Timestamps {
+    id: Uuid;
     tenantId: TenantId;
     name: string;
     label: string;
@@ -2482,51 +3580,175 @@ interface UpsertDBView {
     metadata?: Record<string, unknown>;
 }
 /**
- * Flow as stored in database
+ * Workflow definition as stored in database.
+ * Uses snake_case to match database column names.
  */
-interface DBFlow extends Timestamps {
-    id: Uuid;
-    tenantId: TenantId;
+interface DBWorkflow {
+    id: string;
+    tenant_id: string;
     name: string;
     label: string;
-    description?: string;
-    icon?: IconName;
-    status: FlowStatus;
+    description: string | null;
+    icon: string | null;
+    status: WorkflowStatus;
     version: number;
-    slots: FlowSlot[];
-    pages: FlowPage[];
-    relations: FlowRelation[];
+    slots: WorkflowSlot[];
+    nodes: Record<string, WorkflowNode>;
+    start_node_id: string;
+    layout: WorkflowLayout;
+    participants: ParticipantTemplate[] | null;
+    theme: WorkflowTheme | null;
+    config: WorkflowConfig | null;
     system: boolean;
-    metadata?: Record<string, unknown>;
+    metadata: Record<string, unknown> | null;
+    created_at: string;
+    updated_at: string;
 }
 /**
- * Data for creating a new flow.
+ * Data for creating a new workflow.
  * Tenant ID is automatically set from the execution context.
  */
-interface CreateDBFlow {
+interface CreateDBWorkflow {
     name: string;
     label: string;
     description?: string;
     icon?: IconName;
-    status?: FlowStatus;
+    status?: WorkflowStatus;
     version?: number;
-    slots: FlowSlot[];
-    pages: FlowPage[];
-    relations: FlowRelation[];
+    slots: WorkflowSlot[];
+    nodes: Record<string, WorkflowNode>;
+    startNodeId: string;
+    layout: WorkflowLayout;
+    participants?: ParticipantTemplate[];
+    theme?: WorkflowTheme;
+    config?: WorkflowConfig;
     system?: boolean;
     metadata?: Record<string, unknown>;
 }
-interface UpdateDBFlow {
+/**
+ * Data for updating a workflow.
+ */
+interface UpdateDBWorkflow {
     label?: string;
     description?: string;
     icon?: IconName;
-    status?: FlowStatus;
+    status?: WorkflowStatus;
     version?: number;
-    slots?: FlowSlot[];
-    pages?: FlowPage[];
-    relations?: FlowRelation[];
+    slots?: WorkflowSlot[];
+    nodes?: Record<string, WorkflowNode>;
+    startNodeId?: string;
+    layout?: WorkflowLayout;
+    participants?: ParticipantTemplate[];
+    theme?: WorkflowTheme;
+    config?: WorkflowConfig;
     metadata?: Record<string, unknown>;
 }
+/**
+ * Workflow instance as stored in database.
+ * Uses snake_case to match database column names.
+ */
+interface DBWorkflowInstance {
+    id: string;
+    tenant_id: string;
+    workflow_id: string;
+    workflow_version: number;
+    workflow_snapshot: WorkflowDefinition;
+    status: InstanceStatus;
+    current_node_id: string;
+    context: WorkflowExecutionContext;
+    history: WorkflowTransition[];
+    pending_action: PendingAction | null;
+    error: {
+        code: string;
+        message: string;
+        nodeId?: string;
+    } | null;
+    started_by: string;
+    expires_at: string | null;
+    created_at: string;
+    updated_at: string;
+    completed_at: string | null;
+}
+/**
+ * Data for creating a workflow instance.
+ * Tenant ID is automatically set from the execution context.
+ */
+interface CreateDBWorkflowInstance {
+    workflowId: string;
+    workflowVersion: number;
+    workflowSnapshot: WorkflowDefinition;
+    status: InstanceStatus;
+    currentNodeId: string;
+    context: WorkflowExecutionContext;
+    history: WorkflowTransition[];
+    pendingAction?: PendingAction;
+    startedBy: string;
+    expiresAt?: Date;
+}
+/**
+ * Data for updating a workflow instance.
+ */
+interface UpdateDBWorkflowInstance {
+    status?: InstanceStatus;
+    currentNodeId?: string;
+    context?: WorkflowExecutionContext;
+    history?: WorkflowTransition[];
+    pendingAction?: PendingAction | null;
+    error?: {
+        code: string;
+        message: string;
+        nodeId?: string;
+    } | null;
+    expiresAt?: Date | null;
+    completedAt?: Date | null;
+}
+/**
+ * Workflow participation as stored in database.
+ * Uses snake_case to match database column names.
+ */
+interface DBWorkflowParticipation {
+    id: string;
+    tenant_id: string;
+    instance_id: string;
+    participant_template_id: string;
+    type: "internal" | "external";
+    email: string;
+    name: string | null;
+    phone: string | null;
+    auth: ParticipationAuth;
+    allowed_node_ids: string[];
+    status: ParticipationStatus;
+    authenticated_at: string | null;
+    last_activity_at: string | null;
+    completed_node_ids: string[];
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Data for creating a workflow participation.
+ * Tenant ID is automatically set from the execution context.
+ */
+interface CreateDBWorkflowParticipation {
+    instanceId: string;
+    participantTemplateId: string;
+    type: "internal" | "external";
+    email: string;
+    name?: string;
+    phone?: string;
+    auth: ParticipationAuth;
+    allowedNodeIds: string[];
+    status?: ParticipationStatus;
+}
+/**
+ * Data for updating a workflow participation.
+ */
+interface UpdateDBWorkflowParticipation {
+    status?: ParticipationStatus;
+    auth?: ParticipationAuth;
+    authenticatedAt?: Date | null;
+    lastActivityAt?: Date | null;
+    completedNodeIds?: string[];
+}
 /**
  * Result of an operation
  */
@@ -4166,18 +5388,27 @@ interface ObjectRecordsRepository {
      * Batch update labels for all records of an object.
      * Used after labelExpression changes to refresh all record labels.
      *
+     * Supports both sync and async compute functions to allow for
+     * relation resolution when the label expression references relations.
+     *
      * @param objectId - Object UUID
-     * @param computeLabel - Function to compute label from record values
+     * @param computeLabel - Function to compute label from record values (sync or async)
      * @returns Number of records that were updated
      *
      * @example
      * ```typescript
+     * // Sync compute (simple labels)
      * const updated = await repo.batchRefreshLabels("obj-123", (values) => {
      *   return `${values.sku} - ${values.name}`;
      * });
+     *
+     * // Async compute (with relation resolution)
+     * const updated = await repo.batchRefreshLabels("obj-123", async (values) => {
+     *   return await computeLabelWithRelations(template, values, attributes, resolver);
+     * });
      * ```
      */
-    batchRefreshLabels(objectId: Uuid, computeLabel: (values: Record<string, unknown>) => string): Promise<number>;
+    batchRefreshLabels(objectId: Uuid, computeLabel: (values: Record<string, unknown>) => Promise<string> | string): Promise<number>;
     /**
      * Batch update completion status for all records of an object.
      * Used after required attribute changes to refresh status.
@@ -4276,55 +5507,186 @@ interface ViewsRepository {
     upsert(data: UpsertDBView): Promise<DBView>;
 }
 /**
- * Repository for flow definitions.
+ * Repository for workflow definitions.
  *
  * This repository is optional - if not provided in the DatabaseAdapter,
- * flow features are disabled.
+ * workflow features are disabled.
  *
  * All operations are automatically scoped to the current tenant
  * from the execution context (via AsyncLocalStorage).
  */
-interface FlowsRepository {
+interface WorkflowsRepository {
     /**
-     * Find flow by ID.
+     * Find workflow by ID.
      * Automatically filtered by current tenant context.
      */
-    findById(id: Uuid): Promise<DBFlow | null>;
+    findById(id: Uuid): Promise<DBWorkflow | null>;
     /**
-     * Find flow by name.
+     * Find workflow by name.
      * Automatically filtered by current tenant context.
      */
-    findByName(name: string): Promise<DBFlow | null>;
+    findByName(name: string): Promise<DBWorkflow | null>;
     /**
-     * Find all flows for current tenant.
-     * Automatically filtered by current tenant context.
+     * Find system workflow by name (for sync).
+     * System workflows are shared across tenants.
      */
-    findAllForTenant(): Promise<DBFlow[]>;
+    findSystemByName(name: string): Promise<DBWorkflow | null>;
     /**
-     * Find flows by status.
+     * List all workflows for current tenant.
      * Automatically filtered by current tenant context.
      */
-    findByStatus(status: FlowStatus): Promise<DBFlow[]>;
+    list(): Promise<DBWorkflow[]>;
     /**
-     * Find system flow by name (for sync).
-     * System flows are shared across tenants.
+     * List workflows by status.
+     * Automatically filtered by current tenant context.
      */
-    findSystemByName(name: string): Promise<DBFlow | null>;
+    listByStatus(status: WorkflowStatus): Promise<DBWorkflow[]>;
     /**
-     * Create flow.
+     * Create workflow.
      * Tenant ID is automatically set from context.
      */
-    create(data: CreateDBFlow): Promise<DBFlow>;
+    create(data: CreateDBWorkflow): Promise<DBWorkflow>;
     /**
-     * Update flow.
+     * Update workflow.
      * Automatically filtered by current tenant context.
      */
-    update(id: Uuid, data: Partial<UpdateDBFlow>): Promise<DBFlow>;
+    update(id: Uuid, data: Partial<UpdateDBWorkflow>): Promise<DBWorkflow>;
     /**
-     * Delete flow.
+     * Delete workflow.
      * Automatically filtered by current tenant context.
      */
     delete(id: Uuid): Promise<void>;
+    /**
+     * Upsert workflow (create or update based on name + system flag).
+     * Tenant ID is automatically set from context.
+     */
+    upsert(data: CreateDBWorkflow): Promise<DBWorkflow>;
+}
+/**
+ * Repository for workflow instances (running/completed workflows).
+ *
+ * This repository is optional - if not provided in the DatabaseAdapter,
+ * workflow execution features are disabled.
+ *
+ * All operations are automatically scoped to the current tenant
+ * from the execution context (via AsyncLocalStorage).
+ */
+interface WorkflowInstancesRepository {
+    /**
+     * Find instance by ID.
+     * Automatically filtered by current tenant context.
+     */
+    findById(id: Uuid): Promise<DBWorkflowInstance | null>;
+    /**
+     * Find instances by workflow ID.
+     * Automatically filtered by current tenant context.
+     */
+    findByWorkflowId(workflowId: Uuid): Promise<DBWorkflowInstance[]>;
+    /**
+     * Find instances by workflow name.
+     * Automatically filtered by current tenant context.
+     */
+    findByWorkflowName(workflowName: string): Promise<DBWorkflowInstance[]>;
+    /**
+     * List all instances for current tenant.
+     * Automatically filtered by current tenant context.
+     */
+    list(options?: ListOptions): Promise<{
+        instances: DBWorkflowInstance[];
+        total: number;
+    }>;
+    /**
+     * List instances by status.
+     * Automatically filtered by current tenant context.
+     */
+    listByStatus(status: InstanceStatus): Promise<DBWorkflowInstance[]>;
+    /**
+     * Create instance.
+     * Tenant ID is automatically set from context.
+     */
+    create(data: CreateDBWorkflowInstance): Promise<DBWorkflowInstance>;
+    /**
+     * Update instance.
+     * Automatically filtered by current tenant context.
+     */
+    update(id: Uuid, data: Partial<UpdateDBWorkflowInstance>): Promise<DBWorkflowInstance>;
+    /**
+     * Upsert instance (create or update based on ID).
+     * Tenant ID is automatically set from context.
+     */
+    upsert(data: CreateDBWorkflowInstance & {
+        id: string;
+    }): Promise<DBWorkflowInstance>;
+    /**
+     * Find instances that reference a specific record in their slot context.
+     * Searches in context.slots for slots where objectName and id match.
+     * Automatically filtered by current tenant context.
+     *
+     * This method is required and must be implemented by all adapters.
+     * No fallback is provided for performance reasons - all implementations
+     * must use database-level optimizations (e.g., JSONB queries in PostgreSQL).
+     *
+     * @param objectName - Object name to match in slot data
+     * @param recordId - Record ID to match in slot data
+     * @param options - Optional filtering options
+     */
+    findByRecordInSlots(objectName: string, recordId: string, options?: {
+        status?: InstanceStatus;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        instances: DBWorkflowInstance[];
+        total: number;
+    }>;
+}
+/**
+ * Repository for workflow participations (external user access to workflows).
+ *
+ * This repository is optional - if not provided in the DatabaseAdapter,
+ * external participation features are disabled.
+ *
+ * All operations are automatically scoped to the current tenant
+ * from the execution context (via AsyncLocalStorage).
+ */
+interface WorkflowParticipationsRepository {
+    /**
+     * Find participation by ID.
+     * Automatically filtered by current tenant context.
+     */
+    findById(id: Uuid): Promise<DBWorkflowParticipation | null>;
+    /**
+     * Find participations by instance ID.
+     * Automatically filtered by current tenant context.
+     */
+    findByInstanceId(instanceId: Uuid): Promise<DBWorkflowParticipation[]>;
+    /**
+     * Find participations by email.
+     * Automatically filtered by current tenant context.
+     */
+    findByEmail(email: string): Promise<DBWorkflowParticipation[]>;
+    /**
+     * Create participation.
+     * Tenant ID is automatically set from context.
+     */
+    create(data: CreateDBWorkflowParticipation): Promise<DBWorkflowParticipation>;
+    /**
+     * Update participation.
+     * Automatically filtered by current tenant context.
+     */
+    update(id: Uuid, data: Partial<UpdateDBWorkflowParticipation>): Promise<DBWorkflowParticipation>;
+    /**
+     * Upsert participation (create or update based on ID).
+     * Tenant ID is automatically set from context.
+     */
+    upsert(data: CreateDBWorkflowParticipation & {
+        id: string;
+    }): Promise<DBWorkflowParticipation>;
+    /**
+     * Update only the auth field of a participation.
+     * Used for recording failed PIN attempts without touching other fields.
+     * Automatically filtered by current tenant context.
+     */
+    updateAuth(id: Uuid, auth: ParticipationAuth): Promise<void>;
 }
 /**
  * Repository for audit logs.
@@ -4667,23 +6029,171 @@ interface UploadFileInput {
  * import { createPrismaAdapter } from "./adapters/prisma";
  * import { prisma } from "./db";
  *
- * const adapter = createPrismaAdapter(prisma);
- * ```
+ * const adapter = createPrismaAdapter(prisma);
+ * ```
+ */
+interface DatabaseAdapter {
+    objects: ObjectsRepository;
+    attributes: AttributesRepository;
+    views: ViewsRepository;
+    workflows?: WorkflowsRepository;
+    workflowInstances?: WorkflowInstancesRepository;
+    workflowParticipations?: WorkflowParticipationsRepository;
+    userProfiles: UserProfilesRepository;
+    files: FilesRepository;
+    objectRecords: ObjectRecordsRepository;
+    permissions?: PermissionsRepository;
+    audit?: AuditRepository;
+    storage?: StorageAdapter;
+    cache?: CacheAdapter;
+    transaction<T>(callback: (adapter: DatabaseAdapter) => Promise<T>): Promise<T>;
+}
+
+/**
+ * Payload encoded in the participation token
+ */
+interface ParticipationTokenPayload {
+    /** Participation ID */
+    participationId: string;
+    /** Instance ID */
+    instanceId: string;
+    /** Tenant ID */
+    tenantId: string;
+    /** Expiration timestamp (unix ms) */
+    exp: number;
+    /** Issued at timestamp (unix ms) */
+    iat: number;
+    /** Token ID (for revocation) */
+    jti: string;
+}
+/**
+ * Options for token generation
+ */
+interface TokenGenerationOptions {
+    /** Expiration duration (e.g., "7d", "24h", "1h") */
+    expiresIn?: string;
+}
+/**
+ * Result of token verification
+ */
+interface TokenVerificationResult {
+    valid: boolean;
+    payload?: ParticipationTokenPayload;
+    error?: string;
+}
+/**
+ * Service for generating and verifying participation tokens.
+ *
+ * This is a minimal implementation that encodes data in base64.
+ * In production, this should use proper JWT with HMAC/RSA signing.
+ *
+ * The signing key should be injected from environment configuration.
+ */
+declare class ParticipationTokenService {
+    private secret;
+    constructor(secret?: string);
+    /**
+     * Generate a participation token (signed link)
+     */
+    generateToken(participation: Pick<WorkflowParticipation, "id" | "instanceId"> & {
+        tenantId: string;
+    }, options?: TokenGenerationOptions): SignedLinkAuth;
+    /**
+     * Verify a participation token
+     */
+    verifyToken(token: string): TokenVerificationResult;
+    /**
+     * Generate a shareable link URL
+     */
+    generateLink(baseUrl: string, token: string): string;
+    /**
+     * Extract token from a participation link
+     */
+    extractTokenFromLink(url: string): string | null;
+    private encodeToken;
+    private decodeToken;
+    private sign;
+    private parseExpiration;
+    private base64Encode;
+    private base64Decode;
+}
+/**
+ * Get the default token service instance
+ */
+declare function getDefaultTokenService(): ParticipationTokenService;
+/**
+ * Initialize the token service with a custom secret
+ */
+declare function initializeTokenService(secret: string): ParticipationTokenService;
+
+/**
+ * Options for PIN code generation
+ */
+interface PinCodeGenerationOptions {
+    /** Length of the PIN code (default: 6) */
+    length?: number;
+    /** Expiration duration (e.g., "24h", "7d") */
+    expiresIn?: string;
+    /** Maximum attempts before lockout (default: 3) */
+    maxAttempts?: number;
+}
+/**
+ * Result of PIN code verification
+ */
+interface PinCodeVerificationResult {
+    valid: boolean;
+    error?: string;
+    attemptsRemaining?: number;
+    lockedUntil?: Date;
+}
+/**
+ * Service for generating and verifying PIN codes.
+ *
+ * PIN codes are hashed before storage for security.
+ * This implementation uses a simple hash for demonstration.
+ * In production, use bcrypt or argon2.
  */
-interface DatabaseAdapter {
-    objects: ObjectsRepository;
-    attributes: AttributesRepository;
-    views: ViewsRepository;
-    flows?: FlowsRepository;
-    userProfiles: UserProfilesRepository;
-    files: FilesRepository;
-    objectRecords: ObjectRecordsRepository;
-    permissions?: PermissionsRepository;
-    audit?: AuditRepository;
-    storage?: StorageAdapter;
-    cache?: CacheAdapter;
-    transaction<T>(callback: (adapter: DatabaseAdapter) => Promise<T>): Promise<T>;
+declare class PinCodeService {
+    private salt;
+    constructor(salt?: string);
+    /**
+     * Generate a PIN code and its auth object
+     */
+    generate(options?: PinCodeGenerationOptions): {
+        code: string;
+        auth: PinCodeAuth;
+    };
+    /**
+     * Verify a PIN code against stored auth
+     */
+    verify(inputCode: string, auth: PinCodeAuth): PinCodeVerificationResult;
+    /**
+     * Record a failed attempt and return updated auth
+     */
+    recordFailedAttempt(auth: PinCodeAuth): PinCodeAuth;
+    /**
+     * Reset attempts (after successful verification or admin reset)
+     */
+    resetAttempts(auth: PinCodeAuth): PinCodeAuth;
+    /**
+     * Generate a new PIN code (for resend functionality)
+     */
+    regenerate(auth: PinCodeAuth, options?: PinCodeGenerationOptions): {
+        code: string;
+        auth: PinCodeAuth;
+    };
+    private generateNumericCode;
+    private hashCode;
+    private parseExpiration;
 }
+/**
+ * Get the default PIN code service instance
+ */
+declare function getDefaultPinCodeService(): PinCodeService;
+/**
+ * Initialize the PIN code service with a custom salt
+ */
+declare function initializePinCodeService(salt: string): PinCodeService;
 
 /**
  * Formatted record with values flattened to root level.
@@ -6153,6 +7663,70 @@ interface QueryBuilderOptions {
  */
 declare function createQueryBuilder<T extends Record<string, unknown> = Record<string, unknown>>(recordService: RecordService, adapter: DatabaseAdapter, objectName: string, options?: QueryBuilderOptions): QueryBuilder<T>;
 
+/**
+ * Result of a condition evaluation with debug information
+ */
+interface EvaluationResult {
+    /** The final result of the evaluation */
+    result: boolean;
+    /** Debug trace of the evaluation (for debugging UI) */
+    trace?: EvaluationTrace;
+}
+/**
+ * Trace of a single rule or group evaluation
+ */
+interface EvaluationTrace {
+    /** Type of evaluation */
+    type: "rule" | "group";
+    /** Result of this specific evaluation */
+    result: boolean;
+    /** For rules: the field path */
+    field?: string;
+    /** For rules: the operator used */
+    operator?: ConditionOperator;
+    /** For rules: the expected value */
+    expectedValue?: unknown;
+    /** For rules: the actual value found */
+    actualValue?: unknown;
+    /** For groups: the logical operator */
+    groupOperator?: "and" | "or";
+    /** For groups: child evaluations */
+    children?: EvaluationTrace[];
+}
+/**
+ * Evaluate a condition group against an execution context
+ *
+ * @param condition - The condition group to evaluate
+ * @param context - The workflow execution context
+ * @param trace - Whether to include debug trace
+ * @returns The evaluation result
+ *
+ * @example
+ * ```typescript
+ * const condition: ConditionGroup = {
+ *   operator: "and",
+ *   rules: [
+ *     { field: "slots.client.type", operator: "eq", value: "vip" },
+ *     { field: "forms.quote.amount", operator: "gte", value: 10000 }
+ *   ]
+ * };
+ *
+ * const result = evaluateCondition(condition, context);
+ * if (result.result) {
+ *   // Condition is true
+ * }
+ * ```
+ */
+declare function evaluateCondition(condition: ConditionGroup, context: WorkflowExecutionContext, trace?: boolean): EvaluationResult;
+/**
+ * Quick evaluation without trace (for production use)
+ */
+declare function evaluate(condition: ConditionGroup, context: WorkflowExecutionContext): boolean;
+/**
+ * Evaluate with full debug trace
+ */
+declare function evaluateWithTrace(condition: ConditionGroup, context: WorkflowExecutionContext): EvaluationResult;
+
 /**
  * Context-related errors for tenant isolation
  */
@@ -6314,6 +7888,231 @@ declare function runWithContext<T>(context: TenantContext, fn: () => T): T;
  */
 declare function withTenantContext<T>(tenantId: TenantId, fn: () => Promise<T>, userId?: UserId): Promise<T>;
 
+/**
+ * Result of a successful node execution
+ */
+interface ExecutorSuccessResult {
+    status: "success";
+    /** ID of the next node to execute */
+    nextNodeId: string;
+    /** Updated context (will be merged with current context) */
+    contextUpdates?: Partial<WorkflowExecutionContext>;
+}
+/**
+ * Result indicating the workflow should wait for external action
+ */
+interface ExecutorWaitResult {
+    status: "wait";
+    /** Reason for waiting */
+    reason: string;
+    /** Required participation ID (if any) */
+    requiredParticipationId?: string;
+    /** When the wait expires */
+    expiresAt?: Date;
+}
+/**
+ * Result indicating the workflow has completed
+ */
+interface ExecutorCompleteResult {
+    status: "complete";
+    /** Final status from the end node */
+    finalStatus?: string;
+}
+/**
+ * Result indicating an error occurred
+ */
+interface ExecutorErrorResult {
+    status: "error";
+    /** Error code */
+    code: string;
+    /** Error message */
+    message: string;
+    /** Whether to retry */
+    retryable?: boolean;
+}
+/**
+ * Union of all executor result types
+ */
+type ExecutorResult = ExecutorSuccessResult | ExecutorWaitResult | ExecutorCompleteResult | ExecutorErrorResult;
+/**
+ * Context passed to executors
+ */
+interface ExecutorContext {
+    /** The workflow instance being executed */
+    instance: WorkflowInstance;
+    /** The workflow definition (from snapshot) */
+    definition: WorkflowDefinition;
+    /** Current execution context */
+    executionContext: WorkflowExecutionContext;
+    /** Input data for the node (e.g., form submission) */
+    input?: Record<string, unknown>;
+    /** ID of the user/participant executing */
+    executorId?: string;
+}
+/**
+ * Interface for node executors.
+ * Each node type has its own executor implementation.
+ */
+interface NodeExecutor<T extends WorkflowNode = WorkflowNode> {
+    /**
+     * The node type this executor handles
+     */
+    readonly nodeType: WorkflowNodeType;
+    /**
+     * Execute the node
+     *
+     * @param node - The node to execute
+     * @param context - Execution context
+     * @returns The execution result (sync or async)
+     */
+    execute(node: T, context: ExecutorContext): ExecutorResult | Promise<ExecutorResult>;
+    /**
+     * Check if the node can be executed
+     * (e.g., check if required input is available)
+     *
+     * @param node - The node to check
+     * @param context - Execution context
+     * @returns Whether the node can be executed
+     */
+    canExecute?(node: T, context: ExecutorContext): boolean;
+    /**
+     * Validate the node configuration
+     *
+     * @param node - The node to validate
+     * @returns Validation errors, or empty array if valid
+     */
+    validate?(node: T): string[];
+}
+/**
+ * Registry for node executors.
+ * Maps node types to their executor implementations.
+ */
+declare class ExecutorRegistry {
+    private executors;
+    /**
+     * Register an executor for a node type
+     */
+    register<T extends WorkflowNode>(executor: NodeExecutor<T>): void;
+    /**
+     * Get the executor for a node type
+     */
+    get(nodeType: WorkflowNodeType): NodeExecutor | undefined;
+    /**
+     * Check if an executor is registered for a node type
+     */
+    has(nodeType: WorkflowNodeType): boolean;
+    /**
+     * Execute a node using the appropriate executor
+     */
+    execute(node: WorkflowNode, context: ExecutorContext): Promise<ExecutorResult>;
+    /**
+     * Get all registered node types
+     */
+    getRegisteredTypes(): WorkflowNodeType[];
+}
+/**
+ * Create a success result
+ */
+declare function success(nextNodeId: string, contextUpdates?: Partial<WorkflowExecutionContext>): ExecutorSuccessResult;
+/**
+ * Create a wait result
+ */
+declare function wait(reason: string, options?: {
+    requiredParticipationId?: string;
+    expiresAt?: Date;
+}): ExecutorWaitResult;
+/**
+ * Create a complete result
+ */
+declare function complete(finalStatus?: string): ExecutorCompleteResult;
+/**
+ * Create an error result
+ */
+declare function error(code: string, message: string, retryable?: boolean): ExecutorErrorResult;
+
+/**
+ * Executor for ConditionNode.
+ * Evaluates the condition and routes to onTrue or onFalse.
+ */
+declare class ConditionExecutor implements NodeExecutor<ConditionNode> {
+    readonly nodeType: "condition";
+    execute(node: ConditionNode, context: ExecutorContext): ExecutorResult;
+    canExecute(_node: ConditionNode, _context: ExecutorContext): boolean;
+    validate(node: ConditionNode): string[];
+}
+
+/**
+ * Executor for EndNode.
+ * Marks the workflow as completed with an optional status.
+ */
+declare class EndExecutor implements NodeExecutor<EndNode> {
+    readonly nodeType: "end";
+    execute(node: EndNode, _context: ExecutorContext): ExecutorResult;
+    canExecute(_node: EndNode, _context: ExecutorContext): boolean;
+    validate(_node: EndNode): string[];
+}
+
+/**
+ * Executor for FormNode.
+ * Handles both simple and advanced form modes.
+ *
+ * In the new structure:
+ * - Simple mode: Uses `fields: FormFieldRef[]`
+ * - Advanced mode: Uses `rows: FlowRow[]`
+ *
+ * Behavior:
+ * - If no input is provided: Returns "wait" status (waiting for form submission)
+ * - If input is provided: Validates and stores the data, then proceeds to next node
+ */
+declare class FormExecutor implements NodeExecutor<FormNode> {
+    readonly nodeType: "form";
+    execute(node: FormNode, context: ExecutorContext): ExecutorResult;
+    canExecute(node: FormNode, context: ExecutorContext): boolean;
+    validate(node: FormNode): string[];
+    /**
+     * Extract all slot IDs referenced in the form
+     */
+    private extractSlotIds;
+    /**
+     * Validate required fields based on slot mode.
+     *
+     * Logic:
+     * - Slot mode "create" or "optional" → fields with required=true on the attribute must be filled
+     * - Slot mode "select" → required validation is skipped (record already exists)
+     *
+     * @param node - The FormNode being validated
+     * @param input - The form input data, structured as { [slotId]: { [attribute]: value } }
+     * @param slots - All workflow slots for mode lookup
+     * @param objects - All object definitions for attribute metadata
+     * @returns Array of validation error messages
+     */
+    validateRequiredFields(node: FormNode, input: Record<string, Record<string, unknown>>, slots: WorkflowSlot[], objects: ObjectDefinition[]): string[];
+    /**
+     * Collect all field references from a FormNode
+     */
+    private collectFieldRefs;
+}
+
+/**
+ * Executor for StartNode.
+ * Simply transitions to the next node.
+ */
+declare class StartExecutor implements NodeExecutor<StartNode> {
+    readonly nodeType: "start";
+    execute(node: StartNode, _context: ExecutorContext): ExecutorResult;
+    canExecute(_node: StartNode, _context: ExecutorContext): boolean;
+    validate(node: StartNode): string[];
+}
+
+/**
+ * Create a default executor registry with all core executors registered
+ */
+declare function createDefaultExecutorRegistry(): ExecutorRegistry;
+/**
+ * Get the default executor registry (singleton)
+ */
+declare function getDefaultExecutorRegistry(): ExecutorRegistry;
+
 /**
  * Resolved relation values for a record
  * Maps relation attribute name to the resolved record's values
@@ -6713,6 +8512,9 @@ interface MockStores {
     roles: Map<Uuid, Role>;
     permissions: Map<Uuid, Permission>;
     userRoles: Map<Uuid, UserRoleAssignment>;
+    workflows: Map<Uuid, DBWorkflow>;
+    workflowInstances: Map<Uuid, DBWorkflowInstance>;
+    workflowParticipations: Map<Uuid, DBWorkflowParticipation>;
 }
 /**
  * Create an in-memory mock adapter for testing and development
@@ -7017,94 +8819,6 @@ declare class FileService extends TenantAwareService {
     removeTags(fileId: string, tags: string[]): Promise<File>;
 }
 
-/**
- * Input for creating a flow
- */
-interface CreateFlowInput {
-    name: string;
-    label: string;
-    description?: string;
-    icon?: IconName;
-    slots: FlowSlot[];
-    pages: FlowPage[];
-    relations: FlowRelation[];
-    metadata?: Record<string, unknown>;
-}
-/**
- * Input for updating a flow
- */
-interface UpdateFlowInput {
-    label?: string;
-    description?: string;
-    icon?: IconName;
-    slots?: FlowSlot[];
-    pages?: FlowPage[];
-    relations?: FlowRelation[];
-    metadata?: Record<string, unknown>;
-}
-/**
- * Service for managing flow definitions.
- * Handles fusion of system flows (from registry) and custom flows (from database).
- * Automatically uses tenant context from AsyncLocalStorage.
- */
-declare class FlowService extends TenantAwareService {
-    private adapter;
-    private systemFlows;
-    constructor(adapter: DatabaseAdapter, systemFlows?: FlowDefinition[]);
-    /**
-     * Get all flows for current tenant (system + custom)
-     */
-    getAllFlows(): Promise<FlowDefinition[]>;
-    /**
-     * Get published flows only
-     */
-    getPublishedFlows(): Promise<FlowDefinition[]>;
-    /**
-     * Get a specific flow by name
-     */
-    getFlow(name: string): Promise<FlowDefinition | null>;
-    /**
-     * Get a flow by ID
-     */
-    getFlowById(flowId: string): Promise<FlowDefinition | null>;
-    /**
-     * Create a new custom flow (as draft)
-     */
-    createFlow(input: CreateFlowInput): Promise<FlowDefinition>;
-    /**
-     * Update a custom flow
-     */
-    updateFlow(flowId: string, input: UpdateFlowInput): Promise<FlowDefinition>;
-    /**
-     * Publish a flow
-     */
-    publishFlow(flowId: string): Promise<FlowDefinition>;
-    /**
-     * Archive a flow
-     */
-    archiveFlow(flowId: string): Promise<FlowDefinition>;
-    /**
-     * Delete a custom flow
-     */
-    deleteFlow(flowId: string): Promise<void>;
-    /**
-     * Validate flow name format (kebab-case)
-     */
-    private validateFlowName;
-    /**
-     * Validate flow structure (slots, pages, relations)
-     */
-    private validateFlowStructure;
-    private validateBasicFlowRequirements;
-    private validateSlotIds;
-    private validateFieldReferences;
-    private validateRelationReferences;
-    /**
-     * Convert database flow to FlowDefinition
-     */
-    private convertDBFlowToDefinition;
-}
-
 /**
  * Geocoding service for address autocomplete and geocoding operations
  *
@@ -7541,6 +9255,8 @@ interface GetRelationOptionsParams {
     pageSize?: number;
     /** Filter by specific target object */
     targetObject?: string;
+    /** Additional filter to apply (e.g., workflow context filtering) */
+    filter?: FilterState;
 }
 /**
  * Options for RelationService constructor
@@ -7637,11 +9353,77 @@ declare class RelationService extends TenantAwareService {
      * // [{ id: "rec-1", label: "Nike Air Max", objectName: "products", ... }]
      * ```
      */
-    resolveIds(ids: string[], attributeId: string): Promise<RelationOption[]>;
+    resolveIds(ids: string[], attributeId: string): Promise<RelationOption[]>;
+    /**
+     * Find a relation attribute by ID
+     */
+    findAttributeById(attributeId: string): Promise<RelationAttribute | null>;
+}
+
+/**
+ * Options for the rollup scheduler
+ */
+interface RollupSchedulerOptions {
+    /** Debounce delay in milliseconds (default: 100) */
+    debounceMs?: number;
+    /** Maximum pending recalculations before forced flush (default: 100) */
+    maxPending?: number;
+}
+/**
+ * Scheduler for debouncing rollup recalculations
+ *
+ * When multiple child records are updated in quick succession (e.g., bulk import),
+ * this scheduler batches the rollup recalculations to avoid N+1 updates.
+ *
+ * @example
+ * ```typescript
+ * const scheduler = new RollupScheduler(adapter, {
+ *   debounceMs: 100,
+ *   maxPending: 50,
+ * });
+ *
+ * // Schedule recalculation (will be debounced)
+ * scheduler.scheduleRecalculation("company-123", "companies-obj-id");
+ * scheduler.scheduleRecalculation("company-123", "companies-obj-id"); // Ignored, already pending
+ *
+ * // Force immediate processing
+ * await scheduler.flush();
+ * ```
+ */
+declare class RollupScheduler {
+    private adapter;
+    private getSchemaById;
+    private pending;
+    private rollupService;
+    private debounceMs;
+    private maxPending;
+    constructor(adapter: DatabaseAdapter, getSchemaById: (id: string) => Promise<ObjectDefinition | null>, options?: RollupSchedulerOptions);
+    /**
+     * Schedule a rollup recalculation for a parent record.
+     *
+     * If the same record is already pending, the timer is reset.
+     * If too many recalculations are pending, triggers an immediate flush.
+     *
+     * @param parentId - ID of the parent record to recalculate
+     * @param parentObjectId - Object ID of the parent
+     */
+    scheduleRecalculation(parentId: string, parentObjectId: string): void;
+    /**
+     * Execute all pending recalculations immediately
+     */
+    flush(): Promise<void>;
+    /**
+     * Execute a single recalculation
+     */
+    private executeRecalculation;
+    /**
+     * Get number of pending recalculations
+     */
+    get pendingCount(): number;
     /**
-     * Find a relation attribute by ID
+     * Clear all pending recalculations without executing them
      */
-    findAttributeById(attributeId: string): Promise<RelationAttribute | null>;
+    clear(): void;
 }
 
 /**
@@ -7802,72 +9584,6 @@ declare class RollupService {
     findRecordsWithForwardRollup(changedRecord: ObjectRecord, changedSchema: ObjectDefinition): Promise<ObjectRecord[]>;
 }
 
-/**
- * Options for the rollup scheduler
- */
-interface RollupSchedulerOptions {
-    /** Debounce delay in milliseconds (default: 100) */
-    debounceMs?: number;
-    /** Maximum pending recalculations before forced flush (default: 100) */
-    maxPending?: number;
-}
-/**
- * Scheduler for debouncing rollup recalculations
- *
- * When multiple child records are updated in quick succession (e.g., bulk import),
- * this scheduler batches the rollup recalculations to avoid N+1 updates.
- *
- * @example
- * ```typescript
- * const scheduler = new RollupScheduler(adapter, {
- *   debounceMs: 100,
- *   maxPending: 50,
- * });
- *
- * // Schedule recalculation (will be debounced)
- * scheduler.scheduleRecalculation("company-123", "companies-obj-id");
- * scheduler.scheduleRecalculation("company-123", "companies-obj-id"); // Ignored, already pending
- *
- * // Force immediate processing
- * await scheduler.flush();
- * ```
- */
-declare class RollupScheduler {
-    private adapter;
-    private getSchemaById;
-    private pending;
-    private rollupService;
-    private debounceMs;
-    private maxPending;
-    constructor(adapter: DatabaseAdapter, getSchemaById: (id: string) => Promise<ObjectDefinition | null>, options?: RollupSchedulerOptions);
-    /**
-     * Schedule a rollup recalculation for a parent record.
-     *
-     * If the same record is already pending, the timer is reset.
-     * If too many recalculations are pending, triggers an immediate flush.
-     *
-     * @param parentId - ID of the parent record to recalculate
-     * @param parentObjectId - Object ID of the parent
-     */
-    scheduleRecalculation(parentId: string, parentObjectId: string): void;
-    /**
-     * Execute all pending recalculations immediately
-     */
-    flush(): Promise<void>;
-    /**
-     * Execute a single recalculation
-     */
-    private executeRecalculation;
-    /**
-     * Get number of pending recalculations
-     */
-    get pendingCount(): number;
-    /**
-     * Clear all pending recalculations without executing them
-     */
-    clear(): void;
-}
-
 /**
  * Options for UserProfileService constructor
  */
@@ -8211,6 +9927,408 @@ declare class ViewService extends TenantAwareService {
     private convertDBViewToDefinition;
 }
 
+/**
+ * Input for creating a workflow
+ */
+interface CreateWorkflowInput {
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    slots: WorkflowSlot[];
+    nodes: Record<string, WorkflowNode>;
+    startNodeId: string;
+    layout: WorkflowLayout;
+    participants?: ParticipantTemplate[];
+    theme?: WorkflowTheme;
+    config?: WorkflowConfig;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Input for updating a workflow
+ */
+interface UpdateWorkflowInput {
+    label?: string;
+    description?: string;
+    icon?: IconName;
+    slots?: WorkflowSlot[];
+    nodes?: Record<string, WorkflowNode>;
+    startNodeId?: string;
+    layout?: WorkflowLayout;
+    participants?: ParticipantTemplate[];
+    theme?: WorkflowTheme;
+    config?: WorkflowConfig;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Service for managing workflow definitions.
+ * Handles fusion of system workflows (from registry) and custom workflows (from database).
+ * Automatically uses tenant context from AsyncLocalStorage.
+ */
+declare class WorkflowService extends TenantAwareService {
+    private adapter;
+    private systemWorkflows;
+    constructor(adapter: DatabaseAdapter, systemWorkflows?: WorkflowDefinition[]);
+    /**
+     * Get all workflows for current tenant (system + custom)
+     */
+    getAllWorkflows(): Promise<WorkflowDefinition[]>;
+    /**
+     * Get published workflows only
+     */
+    getPublishedWorkflows(): Promise<WorkflowDefinition[]>;
+    /**
+     * Get a specific workflow by name
+     */
+    getWorkflow(name: string): Promise<WorkflowDefinition | null>;
+    /**
+     * Get a specific workflow by ID
+     */
+    getWorkflowById(id: string): Promise<WorkflowDefinition | null>;
+    /**
+     * Create a new workflow
+     */
+    createWorkflow(input: CreateWorkflowInput): Promise<WorkflowDefinition>;
+    /**
+     * Update an existing workflow
+     */
+    updateWorkflow(name: string, input: UpdateWorkflowInput): Promise<WorkflowDefinition>;
+    /**
+     * Publish a workflow (make it available for execution)
+     */
+    publishWorkflow(name: string): Promise<WorkflowDefinition>;
+    /**
+     * Archive a workflow (make it unavailable)
+     */
+    archiveWorkflow(name: string): Promise<WorkflowDefinition>;
+    /**
+     * Delete a workflow
+     */
+    deleteWorkflow(name: string): Promise<void>;
+    /**
+     * Duplicate a workflow
+     */
+    duplicateWorkflow(name: string, newName: string, newLabel?: string): Promise<WorkflowDefinition>;
+    private convertDBWorkflowToDefinition;
+}
+
+/**
+ * Input for starting a workflow instance
+ */
+interface StartWorkflowInput {
+    /** Name of the workflow to start */
+    workflowName: string;
+    /** Initial slot data (for "select" mode slots) */
+    initialSlots?: Record<string, Record<string, unknown>>;
+    /** Custom variables to initialize */
+    variables?: Record<string, unknown>;
+    /** User ID who starts the workflow */
+    startedBy: string;
+}
+/**
+ * Input for resuming a waiting instance
+ */
+interface ResumeWorkflowInput {
+    /** Form/action data to submit */
+    input: Record<string, unknown>;
+    /** ID of the user/participant submitting */
+    submittedBy?: string;
+}
+/**
+ * Options for WorkflowInstanceService
+ */
+interface WorkflowInstanceServiceOptions {
+    /** Custom executor registry */
+    executorRegistry?: ExecutorRegistry;
+    /** Schema service for resolving object definitions */
+    schemaService?: ObjectSchemaService;
+    /** Record service for persisting slots at workflow completion */
+    recordService?: RecordService;
+}
+/**
+ * Service for executing and managing workflow instances.
+ * Handles the state machine logic and node execution.
+ */
+declare class WorkflowInstanceService extends TenantAwareService {
+    private adapter;
+    private workflowService;
+    private executorRegistry;
+    private schemaService?;
+    private recordService?;
+    constructor(adapter: DatabaseAdapter, workflowService: WorkflowService, options?: WorkflowInstanceServiceOptions);
+    /**
+     * Start a new workflow instance
+     */
+    startWorkflow(input: StartWorkflowInput): Promise<WorkflowInstance>;
+    /**
+     * Resume a waiting workflow instance
+     */
+    resumeWorkflow(instanceId: string, input: ResumeWorkflowInput): Promise<WorkflowInstance>;
+    /**
+     * Cancel a workflow instance
+     */
+    cancelWorkflow(instanceId: string, reason?: string): Promise<WorkflowInstance>;
+    /**
+     * Get an instance by ID
+     */
+    getInstance(id: string): Promise<WorkflowInstance | null>;
+    /**
+     * Get all instances for a workflow
+     */
+    getInstancesByWorkflow(workflowName: string): Promise<WorkflowInstance[]>;
+    /**
+     * List all workflow instances with optional filtering and pagination.
+     *
+     * @param options - Filtering and pagination options
+     * @returns Paginated list of instances with total count
+     */
+    listInstances(options?: {
+        workflowName?: string;
+        status?: InstanceStatus;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        instances: WorkflowInstance[];
+        total: number;
+    }>;
+    /**
+     * Get all instances linked to a specific record.
+     * Finds instances where the record appears in any slot context.
+     *
+     * Uses database-optimized query (required implementation in all adapters).
+     *
+     * @param objectName - Object name of the record
+     * @param recordId - Record ID
+     * @param options - Optional filtering options
+     */
+    getInstancesByRecord(objectName: string, recordId: string, options?: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        instances: WorkflowInstance[];
+        total: number;
+    }>;
+    /**
+     * Get pending action for an instance
+     */
+    getPendingAction(instanceId: string): Promise<PendingAction | null>;
+    /**
+     * Execute the current node and continue until wait/complete/error
+     */
+    private executeCurrentNode;
+    private mergeContext;
+    private getNodeLabel;
+    /**
+     * Persist all slots as records in the database.
+     * - Slots with mode "create" create new records
+     * - Slots with mode "select" or "optional" with existing ID update the record
+     * - Slots with mode "optional" without ID create new records
+     *
+     * Returns updated context with createdRecordIds populated.
+     */
+    private persistSlots;
+    /**
+     * Clean slot data by removing undefined and null values.
+     * This prevents form submissions from overwriting existing record values
+     * with empty values when the form didn't actually provide a value.
+     */
+    private cleanSlotData;
+    /**
+     * Sort slots by dependencies.
+     * Slots that reference other slots via "$slot:xxx" syntax must come after the referenced slot.
+     */
+    private sortSlotsByDependencies;
+    /**
+     * Find all "$slot:xxx" references in an object
+     */
+    private findSlotReferences;
+    /**
+     * Resolve "$slot:xxx" references to actual record IDs
+     */
+    private resolveSlotReferences;
+    /**
+     * Recursively resolve slot references in a value
+     */
+    private resolveValue;
+    private saveInstance;
+    private convertDBInstanceToInstance;
+}
+
+/**
+ * Input for creating a participation
+ */
+interface CreateParticipationInput {
+    /** Workflow instance ID */
+    instanceId: string;
+    /** Participant template ID */
+    participantTemplateId: string;
+    /** Override email (if not using emailSource) */
+    email?: string;
+    /** Override name */
+    name?: string;
+    /** Override phone */
+    phone?: string;
+    /** Override auth method */
+    authMethod?: "signed_link" | "pin_code";
+}
+/**
+ * Result of creating a participation
+ */
+interface CreateParticipationResult {
+    participation: WorkflowParticipation;
+    /** For signed_link: the shareable URL */
+    link?: string;
+    /** For pin_code: the plain PIN (only returned once!) */
+    pinCode?: string;
+}
+/**
+ * Result of authentication
+ */
+interface AuthenticationResult {
+    success: boolean;
+    participation?: WorkflowParticipation;
+    error?: string;
+    attemptsRemaining?: number;
+}
+/**
+ * Service for managing external participant access to workflow instances.
+ * Handles invitation, authentication, and participation tracking.
+ */
+declare class WorkflowParticipationService extends TenantAwareService {
+    private adapter;
+    private instanceService;
+    private tokenService;
+    private pinCodeService;
+    constructor(adapter: DatabaseAdapter, instanceService: WorkflowInstanceService, tokenService?: ParticipationTokenService, pinCodeService?: PinCodeService);
+    /**
+     * Create a participation for an external user
+     */
+    createParticipation(input: CreateParticipationInput, baseUrl: string): Promise<CreateParticipationResult>;
+    /**
+     * Authenticate using a signed link token
+     */
+    authenticateWithToken(token: string): Promise<AuthenticationResult>;
+    /**
+     * Authenticate using a PIN code
+     */
+    authenticateWithPin(participationId: string, pinCode: string): Promise<AuthenticationResult>;
+    /**
+     * Get a participation by ID
+     */
+    getParticipation(id: string): Promise<WorkflowParticipation | null>;
+    /**
+     * Get participations for an instance
+     */
+    getParticipationsForInstance(instanceId: string): Promise<WorkflowParticipation[]>;
+    /**
+     * Mark a node as completed by a participation
+     */
+    markNodeCompleted(participationId: string, nodeId: string): Promise<WorkflowParticipation>;
+    /**
+     * Revoke a participation
+     */
+    revokeParticipation(id: string): Promise<WorkflowParticipation>;
+    private resolveEmailFromContext;
+    private resolvePhoneFromContext;
+    private markAuthenticated;
+    private updateParticipationAuth;
+    private saveParticipation;
+    private convertDBToParticipation;
+}
+
+/**
+ * Result of checking if a field is read-only
+ */
+interface FieldReadOnlyResult {
+    /** Whether the field is read-only */
+    readOnly: boolean;
+    /** Reason for being read-only */
+    reason?: "user_field" | "computed" | "system";
+}
+/**
+ * Service for handling relation filtering in workflow context.
+ *
+ * This service is used by both internal (admin) and external (participant)
+ * users when filling workflow forms. It computes contextual filters based on
+ * the workflow's slot data.
+ *
+ * @example
+ * ```typescript
+ * const service = new WorkflowRelationService(adapter);
+ *
+ * // Compute filter for a relation based on workflow context
+ * const filter = await service.computeContextualFilter(
+ *   relationAttribute,
+ *   instance.context,
+ *   definition.slots
+ * );
+ *
+ * // Check if a field is read-only for external users
+ * const { readOnly, reason } = service.isFieldReadOnly(
+ *   userAttribute,
+ *   { type: "external", token: "...", participationId: "..." }
+ * );
+ * ```
+ */
+declare class WorkflowRelationService extends TenantAwareService {
+    private adapter;
+    private schemaService;
+    constructor(adapter: DatabaseAdapter, nativeRegistry: typeof registry);
+    /**
+     * Compute contextual filter for a relation attribute based on workflow context.
+     *
+     * Logic: If the target object has a relation attribute that points to an object
+     * type matching a filled slot, we filter by that slot's record ID.
+     *
+     * This ensures that when an external participant is filling a form, they only
+     * see related records that are relevant to the workflow context.
+     *
+     * @example
+     * ```typescript
+     * // Workflow has a "company" slot filled with company ID "comp-123"
+     * // User is selecting contacts, and Contact has a "company" relation
+     * // -> Filter returns contacts where company = "comp-123"
+     *
+     * const filter = await service.computeContextualFilter(
+     *   contactsRelationAttr,
+     *   { slots: { company: { id: "comp-123" } } },
+     *   [{ id: "company", objectName: "companies", ... }]
+     * );
+     * // Result: { combinator: "and", rules: [{ attribute: "company", operator: "any_of", value: ["comp-123"] }] }
+     * ```
+     *
+     * @param attribute - The relation attribute being queried for options
+     * @param context - Current workflow execution context with slot values
+     * @param slots - Slot definitions from the workflow
+     * @returns Filter state to apply, or undefined if no filtering needed
+     */
+    computeContextualFilter(attribute: RelationAttribute, context: WorkflowExecutionContext, slots: WorkflowSlot[]): Promise<FilterState | undefined>;
+    /**
+     * Determine if a field is read-only based on the access mode.
+     *
+     * - User fields are read-only for external participants
+     * - Formula fields are always read-only
+     * - Other fields are editable
+     *
+     * @param attribute - The attribute to check
+     * @param accessMode - The current access mode (internal or external)
+     * @returns Whether the field is read-only and the reason
+     */
+    isFieldReadOnly(attribute: Attribute, accessMode: WorkflowAccessMode): FieldReadOnlyResult;
+    /**
+     * Check if a field should be hidden entirely for external users.
+     *
+     * Some fields may be marked as internal-only in the workflow definition.
+     * This is a placeholder for future extension.
+     *
+     * @param _attributeName - The attribute name
+     * @param _accessMode - The current access mode
+     * @returns Whether the field should be hidden
+     */
+    isFieldHidden(_attributeName: string, _accessMode: WorkflowAccessMode): boolean;
+}
+
 /**
  * Result of view sync operation
  */
@@ -8488,5 +10606,52 @@ declare function extractAttributeNames(template: string): string[];
  * ```
  */
 declare function enrichValuesWithSelectLabels(values: Record<string, unknown>, attributes: Attribute[]): Record<string, unknown>;
+/**
+ * Extract relation IDs from a value (string or array)
+ * For cardinality "many", only the first ID is extracted for label display
+ *
+ * @param val - Relation value (string ID or array of IDs)
+ * @returns Array of IDs (max 1 element for display purposes)
+ *
+ * @example
+ * ```typescript
+ * extractRelationIds("rec-123") // → ["rec-123"]
+ * extractRelationIds(["rec-1", "rec-2"]) // → ["rec-1"]
+ * extractRelationIds(null) // → []
+ * ```
+ */
+declare function extractRelationIds(val: unknown): string[];
+/**
+ * Resolver function type for fetching relation labels
+ * Takes an array of record IDs and returns a map of ID → label
+ */
+type RelationLabelResolver = (ids: string[]) => Promise<Map<string, string>>;
+/**
+ * Compute a label from a template with full relation resolution (1 level deep)
+ *
+ * Uses pre-computed record.label for nested relations to avoid infinite recursion.
+ * This function enriches select/multiselect values AND resolves relation IDs to their labels.
+ *
+ * @param template - Label expression template (e.g., "{{ company }} - {{ name }}")
+ * @param values - Record values to interpolate
+ * @param attributes - Attribute definitions for the object
+ * @param resolveRelationIds - Function to resolve record IDs to their labels
+ * @returns The rendered label string
+ *
+ * @example
+ * ```typescript
+ * const label = await computeLabelWithRelations(
+ *   "{{ company }} - {{ name }}",
+ *   { company: "rec-123", name: "Product A" },
+ *   objectSchema.attributes,
+ *   async (ids) => {
+ *     const records = await adapter.objectRecords.findByIds(ids);
+ *     return new Map(records.map(r => [r.id, r.label]));
+ *   }
+ * );
+ * // → "Acme Corp - Product A"
+ * ```
+ */
+declare function computeLabelWithRelations(template: string, values: Record<string, unknown>, attributes: Attribute[], resolveRelationIds: RelationLabelResolver): Promise<string>;
 
-export { type Currency as $, type Attribute as A, type FilterState as B, type CheckboxAttribute as C, type DateAttribute as D, type SortRule as E, type FileAttribute as F, type Group as G, type DirectTableTab as H, type InferAttributeValue as I, type BlockNoteContent as J, type StatusGroup as K, type LocationAttribute as L, type MultiselectAttribute as M, type NumberAttribute as N, type ObjectAction as O, type PhoneAttribute as P, type AttributeGroup as Q, type RichtextAttribute as R, type SystemResource as S, type TextAttribute as T, type UserAttribute as U, type ViewLayout as V, type BaseAttribute as W, type NumberUnit as X, type DateFormat as Y, type DateValue as Z, type Phone as _, type SystemAction as a, type FlowRelation as a$, type Location as a0, type LocationGranularity as a1, RELATION_TARGET_ANY as a2, type RelationAttribute as a3, isUniversalRelation as a4, type BlockNoteBlock as a5, type BlockNoteCustomInlineContent as a6, type BlockNoteDefaultProps as a7, type BlockNoteInlineContent as a8, type BlockNoteLink as a9, type NumberFilterOperator as aA, type CheckboxFilterOperator as aB, type DateFilterOperator as aC, type SelectFilterOperator as aD, type MultiselectFilterOperator as aE, type RelationFilterOperator as aF, type FilterOperator as aG, type RelativeDateValue as aH, type CurrencyFilterValue as aI, type PhoneFilterValue as aJ, type FilterValue as aK, type FilterRule as aL, type ExtendedFilterRule as aM, type FilterCombinator as aN, type FilterGroup as aO, type AdvancedFilterState as aP, isAdvancedFilterState as aQ, toAdvancedFilterState as aR, toSimpleFilterState as aS, type SortDirection as aT, type QueryState as aU, OPERATORS_BY_TYPE as aV, type NoValueOperator as aW, NO_VALUE_OPERATORS as aX, isNoValueOperator as aY, type FlowSlot as aZ, type FlowRowField as a_, type BlockNoteStyledText as aa, type BlockNoteStyles as ab, type BlockNoteTableCell as ac, type BlockNoteTableCellProps as ad, type BlockNoteTableContent as ae, type PartialBlockNoteBlock as af, type PartialBlockNoteContent as ag, type PartialBlockNoteInlineContent as ah, type PartialBlockNoteLink as ai, type PartialBlockNoteStyledText as aj, type PartialBlockNoteTableCell as ak, type PartialBlockNoteTableContent as al, type AuditResourceType as am, type AuditAction as an, type AuditActorType as ao, type AuditChange as ap, type AuditLogEntry as aq, type CreateAuditLogInput as ar, type AuditListOptions as as, type AuditServiceOptions as at, type StorageProvider as au, type FileVisibility as av, type File as aw, type CreateFile as ax, type UpdateFile as ay, type TextFilterOperator as az, type TextAreaAttribute as b, isFormTab as b$, type FlowStatus as b0, isFlowDefinition as b1, isFlowPublished as b2, isSystemFlow as b3, type GeocodingSuggestion as b4, type GeocodingAutocompleteParams as b5, type ReverseGeocodingParams as b6, type GeocodingParams as b7, type GeocodingAdapter as b8, NoopGeocodingAdapter as b9, type CompletionStatus as bA, type ObjectRecord as bB, type PermissionScope as bC, type Role as bD, type Permission as bE, type UserRoleAssignment as bF, type EffectivePermissions as bG, type ObjectPermissions as bH, type SystemPermissions as bI, type CreateRoleInput as bJ, type UpdateRoleInput as bK, type CreatePermissionInput as bL, type AssignRoleInput as bM, type PolicyContext as bN, type RecordPolicy as bO, PolicyViolationError as bP, type UserRole as bQ, type UserStatus as bR, type UserProfile as bS, type CreateUserProfile as bT, type UpdateUserProfile as bU, type InviteUserInput as bV, type TabType as bW, type FormTab as bX, type CustomTab as bY, type ActivityTab as bZ, type NotesTab as b_, type AttributeSchema as ba, type InferRecordFromSchema as bb, type InferRecordWithRequirements as bc, type TypedAttribute as bd, type AttributeMap as be, type AddAttribute as bf, type InferRecord as bg, type InferRecordInput as bh, type InferRecordUpdate as bi, type CustomAttributeValue as bj, type WithCustomAttributes as bk, type RecordMetadata as bl, type SystemFields as bm, type ExtractRecord as bn, type ExtractRecordStrict as bo, type ExtractRecordInput as bp, type ExtractRecordInputStrict as bq, type ExtractRecordUpdate as br, type ExtractRecordUpdateStrict as bs, type ExtractAttributes as bt, RESERVED_ATTRIBUTE_NAMES as bu, SYSTEM_FIELD_NAMES as bv, type ReservedAttributeName as bw, type SystemFieldName as bx, type Timestamps as by, type ObjectAttribute as bz, type RichtextFeature as c, type ValidationResult as c$, isTableTab as c0, isDirectTableTab as c1, isInverseTableTab as c2, isCustomTab as c3, isActivityTab as c4, isNotesTab as c5, type Uuid as c6, type TenantId as c7, type UserId as c8, asTenantId as c9, getAttributeConfigSchema as cA, validateAttributeConfig as cB, parseAttributeConfig as cC, safeParseAttributeConfig as cD, createTextValidator as cE, createNumberValidator as cF, createCheckboxValidator as cG, createDateValidator as cH, createPhoneValidator as cI, createCurrencyValidator as cJ, createStatusValidator as cK, createSelectValidator as cL, createMultiselectValidator as cM, createLocationValidator as cN, createFileValidator as cO, createUserValidator as cP, createSingleRelationValidator as cQ, createMultiRelationValidator as cR, createRelationValidator as cS, createRatingValidator as cT, createFormulaValidator as cU, createRollupValidator as cV, createTextAreaValidator as cW, createRichtextValidator as cX, createAttributeValidator as cY, createFormAttributeValidator as cZ, createObjectValidator as c_, asUserId as ca, generateId as cb, generatePrefixedId as cc, registry as cd, viewRegistry as ce, type ValidationMessages as cf, DEFAULT_VALIDATION_MESSAGES as cg, textConfigSchema as ch, textareaConfigSchema as ci, richtextConfigSchema as cj, numberConfigSchema as ck, checkboxConfigSchema as cl, dateConfigSchema as cm, phoneConfigSchema as cn, currencyConfigSchema as co, statusConfigSchema as cp, locationConfigSchema as cq, selectConfigSchema as cr, multiselectConfigSchema as cs, fileConfigSchema as ct, userConfigSchema as cu, relationConfigSchema as cv, ratingConfigSchema as cw, formulaConfigSchema as cx, rollupConfigSchema as cy, attributeConfigSchemas as cz, type CurrencyAttribute as d, type PathSegment as d$, validateAttribute as d0, validateObject as d1, validateObjectOrThrow as d2, createDraftValidator as d3, validateDraft as d4, validateDraftOrThrow as d5, getMissingRequiredAttributes as d6, isRecordComplete as d7, computeRecordStatus as d8, type DatabaseAdapter as d9, getUserId as dA, hasContext as dB, runWithContext as dC, withTenantContext as dD, type TenantContext as dE, evaluateFormula as dF, evaluateFormulaAttribute as dG, evaluateFormulaAttributeWithRelations as dH, evaluateFormulaWithRelations as dI, evaluateFormulaWithResult as dJ, extractFormulaVariables as dK, extractRelationNames as dL, extractRelationReferences as dM, flattenRelationsForEval as dN, formatFormulaResult as dO, hasRelationReferences as dP, validateFormulaExpression as dQ, type FormulaResult as dR, getPathDepth as dS, getRelationPath as dT, getTargetAttributeName as dU, InvalidPathError as dV, MaxDepthExceededError as dW, parsePath as dX, pathHasManyCardinality as dY, validatePath as dZ, type PathCardinality as d_, type CacheAdapter as da, type CacheOptions as db, cacheKeys as dc, cacheTtl as dd, NoopCacheAdapter as de, type FetchResult as df, type FormattedRecord as dg, type GroupedFetchResult as dh, type InsertOptions as di, type QueryBuilderState as dj, type RegistryMap as dk, type RegistryObjectNames as dl, type ShortcutOperator as dm, createDefaultState as dn, formatRecord as dp, formatRecords as dq, QueryMultipleResultsError as dr, QueryNoResultError as ds, SHORTCUT_TO_FILTER_OPERATOR as dt, createQueryBuilder as du, QueryBuilder as dv, type QueryBuilderOptions as dw, TenantContextError as dx, getContext as dy, getTenantId as dz, type Option as e, type UserValidationResult as e$, type PathSegmentType as e0, type SchemaResolver as e1, resolveMultiplePaths as e2, resolveSingleValue as e3, traversePath as e4, type TraversalOptions as e5, type TraversalResult as e6, type AttributeChange as e7, type HookContext as e8, type HookDefinition as e9, GeocodingService as eA, GlobalSearchService as eB, type CreateCustomObjectInput as eC, type AddAttributeInput as eD, type UpdateObjectInput as eE, type ObjectSchemaServiceOptions as eF, ObjectSchemaService as eG, type PermissionServiceOptions as eH, PermissionService as eI, type RecordServiceOptions as eJ, RecordService as eK, type RelationValidationResult as eL, type RelationValidationError as eM, type RelationOption as eN, type RelationOptionsResponse as eO, type GetRelationOptionsParams as eP, type RelationServiceOptions as eQ, RelationService as eR, type ResolvedRelations as eS, RelationResolverService as eT, type RollupResult as eU, type RollupServiceOptions as eV, RollupService as eW, type RollupSchedulerOptions as eX, RollupScheduler as eY, type UserProfileServiceOptions as eZ, UserProfileService as e_, type HookHandler as ea, type HookType as eb, NoopHookRegistry as ec, type HookRegistry as ed, createMockAdapter as ee, defaultPolicyRegistry as ef, PolicyRegistry as eg, notesPolicy as eh, type ObjectsRepository as ei, type AttributesRepository as ej, type UserProfilesRepository as ek, type FilesRepository as el, type ObjectRecordsRepository as em, type ViewsRepository as en, type FlowsRepository as eo, type AuditRepository as ep, type PermissionsRepository as eq, buildAuditChanges as er, AuditService as es, TenantAwareService as et, TenantAwareRepository as eu, type FileServiceOptions as ev, FileService as ew, type CreateFlowInput as ex, type UpdateFlowInput as ey, FlowService as ez, type StatusAttribute as f, type UserValidationError as f0, UserService as f1, type CreateViewInput as f2, type UpdateViewInput as f3, ViewService as f4, type FileContent as f5, type StorageUploadInput as f6, type StorageUploadResult as f7, type SignedUrlOptions as f8, type StorageAdapter as f9, type GlobalSearchResultItem as fA, type FileListOptions as fB, type DBView as fC, type CreateDBView as fD, type UpdateDBView as fE, type UpsertDBView as fF, type DBFlow as fG, type CreateDBFlow as fH, type UpdateDBFlow as fI, type OperationResult as fJ, type ViewSyncResult as fK, type ViewSyncOptions as fL, syncNativeViews as fM, verifyNativeViewsSync as fN, getViewSyncPreview as fO, type UploadFileInput as fa, type SyncResult as fb, type SyncOptions as fc, syncNativeObjects as fd, verifyNativeObjectsSync as fe, getSyncPreview as ff, type FullSyncResult as fg, type FullSyncOptions as fh, syncAll as fi, DEFAULT_LABEL_FALLBACK as fj, renderLabelExpression as fk, isLabelExpression as fl, extractAttributeNames as fm, enrichValuesWithSelectLabels as fn, type DBObject as fo, type CreateDBObject as fp, type UpdateDBObject as fq, type UpsertDBObject as fr, type DBAttribute as fs, type CreateDBAttribute as ft, type UpdateDBAttribute as fu, type UpsertDBAttribute as fv, type CreateObjectRecord as fw, type ListOptions as fx, type SearchOptions as fy, type GlobalSearchOptions as fz, type SelectAttribute as g, type SingleRelationAttribute as h, type MultiRelationAttribute as i, type RelationTarget as j, type RatingAttribute as k, type FormulaAttribute as l, type FormulaReturnType as m, type RollupAttribute as n, type RollupFunction as o, type AttributeType as p, type FlowDefinition as q, type FlowPage as r, type FlowRow as s, type ObjectDefinition as t, type Field as u, type AttributeGroupField as v, type TableTab as w, type InverseTableTab as x, type ViewDefinition as y, type Tab as z };
+export { type FlowRow as $, type Attribute as A, type DirectTableTab as B, type CheckboxAttribute as C, type DateAttribute as D, type WorkflowConfig as E, type FileAttribute as F, type Group as G, type SlotMode as H, type InferAttributeValue as I, type AuthMethod as J, type AuthChannel as K, type LocationAttribute as L, type MultiselectAttribute as M, type NumberAttribute as N, type ObjectAction as O, type PhoneAttribute as P, type ParticipantTemplate as Q, type RichtextAttribute as R, type SystemResource as S, type TextAttribute as T, type UserAttribute as U, type ViewLayout as V, type WorkflowTheme as W, type ConditionGroup as X, type ConditionRule as Y, type WorkflowNode as Z, type WorkflowDefinition as _, type SystemAction as a, toSimpleFilterState as a$, type BlockNoteContent as a0, type StatusGroup as a1, type AttributeGroup as a2, type BaseAttribute as a3, type NumberUnit as a4, type DateFormat as a5, type DateValue as a6, type Phone as a7, type Currency as a8, type Location as a9, type CreateAuditLogInput as aA, type AuditListOptions as aB, type AuditServiceOptions as aC, type StorageProvider as aD, type FileVisibility as aE, type File as aF, type CreateFile as aG, type UpdateFile as aH, type TextFilterOperator as aI, type NumberFilterOperator as aJ, type CheckboxFilterOperator as aK, type DateFilterOperator as aL, type SelectFilterOperator as aM, type MultiselectFilterOperator as aN, type RelationFilterOperator as aO, type FilterOperator as aP, type RelativeDateValue as aQ, type CurrencyFilterValue as aR, type PhoneFilterValue as aS, type FilterValue as aT, type FilterRule as aU, type ExtendedFilterRule as aV, type FilterCombinator as aW, type FilterGroup as aX, type AdvancedFilterState as aY, isAdvancedFilterState as aZ, toAdvancedFilterState as a_, type LocationGranularity as aa, RELATION_TARGET_ANY as ab, type RelationAttribute as ac, isUniversalRelation as ad, type BlockNoteBlock as ae, type BlockNoteCustomInlineContent as af, type BlockNoteDefaultProps as ag, type BlockNoteInlineContent as ah, type BlockNoteLink as ai, type BlockNoteStyledText as aj, type BlockNoteStyles as ak, type BlockNoteTableCell as al, type BlockNoteTableCellProps as am, type BlockNoteTableContent as an, type PartialBlockNoteBlock as ao, type PartialBlockNoteContent as ap, type PartialBlockNoteInlineContent as aq, type PartialBlockNoteLink as ar, type PartialBlockNoteStyledText as as, type PartialBlockNoteTableCell as at, type PartialBlockNoteTableContent as au, type AuditResourceType as av, type AuditAction as aw, type AuditActorType as ax, type AuditChange as ay, type AuditLogEntry as az, type TextAreaAttribute as b, type UserRole as b$, type SortDirection as b0, type QueryState as b1, OPERATORS_BY_TYPE as b2, type NoValueOperator as b3, NO_VALUE_OPERATORS as b4, isNoValueOperator as b5, type FlowSlot as b6, type FlowRowField as b7, type FlowPage as b8, type FlowRelation as b9, type ExtractRecordInput as bA, type ExtractRecordInputStrict as bB, type ExtractRecordUpdate as bC, type ExtractRecordUpdateStrict as bD, type ExtractAttributes as bE, RESERVED_ATTRIBUTE_NAMES as bF, SYSTEM_FIELD_NAMES as bG, type ReservedAttributeName as bH, type SystemFieldName as bI, type Timestamps as bJ, type ObjectAttribute as bK, type CompletionStatus as bL, type ObjectRecord as bM, type PermissionScope as bN, type Role as bO, type Permission as bP, type UserRoleAssignment as bQ, type EffectivePermissions as bR, type ObjectPermissions as bS, type SystemPermissions as bT, type CreateRoleInput as bU, type UpdateRoleInput as bV, type CreatePermissionInput as bW, type AssignRoleInput as bX, type PolicyContext as bY, type RecordPolicy as bZ, PolicyViolationError as b_, type FlowStatus as ba, type FlowDefinition as bb, isFlowDefinition as bc, isFlowPublished as bd, isSystemFlow as be, type GeocodingSuggestion as bf, type GeocodingAutocompleteParams as bg, type ReverseGeocodingParams as bh, type GeocodingParams as bi, type GeocodingAdapter as bj, NoopGeocodingAdapter as bk, type AttributeSchema as bl, type InferRecordFromSchema as bm, type InferRecordWithRequirements as bn, type TypedAttribute as bo, type AttributeMap as bp, type AddAttribute as bq, type InferRecord as br, type InferRecordInput as bs, type InferRecordUpdate as bt, type CustomAttributeValue as bu, type WithCustomAttributes as bv, type RecordMetadata as bw, type SystemFields as bx, type ExtractRecord as by, type ExtractRecordStrict as bz, type RichtextFeature as c, type WorkflowParticipation as c$, type UserStatus as c0, type UserProfile as c1, type CreateUserProfile as c2, type UpdateUserProfile as c3, type InviteUserInput as c4, type TabType as c5, type FormTab as c6, type CustomTab as c7, type ActivityTab as c8, type NotesTab as c9, neq as cA, and as cB, or as cC, inValues as cD, isEmpty as cE, isNotEmpty as cF, type WorkflowSlot as cG, type NodePosition as cH, type CanvasViewport as cI, type WorkflowLayout as cJ, type ParticipantAuthConfig as cK, type WorkflowStatus as cL, isWorkflowDefinition as cM, isWorkflowPublished as cN, isSystemWorkflow as cO, type WorkflowTransition as cP, type WorkflowError as cQ, type PendingAction as cR, type WorkflowInstance as cS, isInstanceTerminal as cT, isInstanceWaiting as cU, canResumeInstance as cV, createStartTransition as cW, type ParticipationStatus as cX, type SignedLinkAuth as cY, type PinCodeAuth as cZ, type ParticipationAuth as c_, type FlowsTab as ca, isFormTab as cb, isTableTab as cc, isDirectTableTab as cd, isInverseTableTab as ce, isCustomTab as cf, isActivityTab as cg, isNotesTab as ch, isFlowsTab as ci, type StartNode as cj, type FormNode as ck, type FormFieldRef as cl, type ConditionNode as cm, type EndNode as cn, type WorkflowNodeType as co, isStartNode as cp, isFormNode as cq, isConditionNode as cr, isEndNode as cs, isSimpleFormNode as ct, isAdvancedFormNode as cu, getNodeOutputs as cv, type ConditionOperator as cw, isConditionRule as cx, isConditionGroup as cy, eq as cz, type CurrencyAttribute as d, createCurrencyValidator as d$, isSignedLinkAuth as d0, isPinCodeAuth as d1, canParticipate as d2, canAuthenticate as d3, canExecuteNode as d4, type GeneratedDocument as d5, type WorkflowExecutionContext as d6, createEmptyContext as d7, getContextValue as d8, setContextValue as d9, textareaConfigSchema as dA, richtextConfigSchema as dB, numberConfigSchema as dC, checkboxConfigSchema as dD, dateConfigSchema as dE, phoneConfigSchema as dF, currencyConfigSchema as dG, statusConfigSchema as dH, locationConfigSchema as dI, selectConfigSchema as dJ, multiselectConfigSchema as dK, fileConfigSchema as dL, userConfigSchema as dM, relationConfigSchema as dN, ratingConfigSchema as dO, formulaConfigSchema as dP, rollupConfigSchema as dQ, attributeConfigSchemas as dR, getAttributeConfigSchema as dS, validateAttributeConfig as dT, parseAttributeConfig as dU, safeParseAttributeConfig as dV, createTextValidator as dW, createNumberValidator as dX, createCheckboxValidator as dY, createDateValidator as dZ, createPhoneValidator as d_, mergeFormToSlot as da, type WorkflowAccessMode as db, type ReadOnlyReason as dc, type FormFieldContext as dd, type FormFieldRow as de, type FormNodeInfo as df, type FormContextResponse as dg, type ThemeLogo as dh, type ThemeColors as di, type ThemeTypography as dj, DEFAULT_THEME as dk, mergeWithDefaults as dl, generateCssVariables as dm, type Uuid as dn, type TenantId as dp, type UserId as dq, asTenantId as dr, asUserId as ds, generateId as dt, generatePrefixedId as du, registry as dv, viewRegistry as dw, type ValidationMessages as dx, DEFAULT_VALIDATION_MESSAGES as dy, textConfigSchema as dz, type Option as e, evaluateCondition as e$, createStatusValidator as e0, createSelectValidator as e1, createMultiselectValidator as e2, createLocationValidator as e3, createFileValidator as e4, createUserValidator as e5, createSingleRelationValidator as e6, createMultiRelationValidator as e7, createRelationValidator as e8, createRatingValidator as e9, initializePinCodeService as eA, type PinCodeGenerationOptions as eB, type PinCodeVerificationResult as eC, type CacheAdapter as eD, type CacheOptions as eE, cacheKeys as eF, cacheTtl as eG, NoopCacheAdapter as eH, type FetchResult as eI, type FormattedRecord as eJ, type GroupedFetchResult as eK, type InsertOptions as eL, type QueryBuilderState as eM, type RegistryMap as eN, type RegistryObjectNames as eO, type ShortcutOperator as eP, createDefaultState as eQ, formatRecord as eR, formatRecords as eS, QueryMultipleResultsError as eT, QueryNoResultError as eU, SHORTCUT_TO_FILTER_OPERATOR as eV, createQueryBuilder as eW, QueryBuilder as eX, type QueryBuilderOptions as eY, type EvaluationResult as eZ, type EvaluationTrace as e_, createFormulaValidator as ea, createRollupValidator as eb, createTextAreaValidator as ec, createRichtextValidator as ed, createAttributeValidator as ee, createFormAttributeValidator as ef, createObjectValidator as eg, type ValidationResult as eh, validateAttribute as ei, validateObject as ej, validateObjectOrThrow as ek, createDraftValidator as el, validateDraft as em, validateDraftOrThrow as en, getMissingRequiredAttributes as eo, isRecordComplete as ep, computeRecordStatus as eq, type DatabaseAdapter as er, ParticipationTokenService as es, getDefaultTokenService as et, initializeTokenService as eu, type ParticipationTokenPayload as ev, type TokenGenerationOptions as ew, type TokenVerificationResult as ex, PinCodeService as ey, getDefaultPinCodeService as ez, type StatusAttribute as f, NoopHookRegistry as f$, evaluate as f0, evaluateWithTrace as f1, TenantContextError as f2, getContext as f3, getTenantId as f4, getUserId as f5, hasContext as f6, runWithContext as f7, withTenantContext as f8, type TenantContext as f9, flattenRelationsForEval as fA, formatFormulaResult as fB, hasRelationReferences as fC, validateFormulaExpression as fD, type FormulaResult as fE, getPathDepth as fF, getRelationPath as fG, getTargetAttributeName as fH, InvalidPathError as fI, MaxDepthExceededError as fJ, parsePath as fK, pathHasManyCardinality as fL, validatePath as fM, type PathCardinality as fN, type PathSegment as fO, type PathSegmentType as fP, type SchemaResolver as fQ, resolveMultiplePaths as fR, resolveSingleValue as fS, traversePath as fT, type TraversalOptions as fU, type TraversalResult as fV, type AttributeChange as fW, type HookContext as fX, type HookDefinition as fY, type HookHandler as fZ, type HookType as f_, createDefaultExecutorRegistry as fa, getDefaultExecutorRegistry as fb, type ExecutorCompleteResult as fc, type ExecutorContext as fd, type ExecutorErrorResult as fe, type ExecutorResult as ff, type ExecutorSuccessResult as fg, type ExecutorWaitResult as fh, type NodeExecutor as fi, complete as fj, error as fk, ExecutorRegistry as fl, success as fm, wait as fn, ConditionExecutor as fo, EndExecutor as fp, FormExecutor as fq, StartExecutor as fr, evaluateFormula as fs, evaluateFormulaAttribute as ft, evaluateFormulaAttributeWithRelations as fu, evaluateFormulaWithRelations as fv, evaluateFormulaWithResult as fw, extractFormulaVariables as fx, extractRelationNames as fy, extractRelationReferences as fz, type SelectAttribute as g, type FieldReadOnlyResult as g$, type HookRegistry as g0, createMockAdapter as g1, defaultPolicyRegistry as g2, PolicyRegistry as g3, notesPolicy as g4, type ObjectsRepository as g5, type AttributesRepository as g6, type UserProfilesRepository as g7, type FilesRepository as g8, type ObjectRecordsRepository as g9, type RelationValidationError as gA, type RelationOption as gB, type RelationOptionsResponse as gC, type GetRelationOptionsParams as gD, type RelationServiceOptions as gE, RelationService as gF, type RollupSchedulerOptions as gG, RollupScheduler as gH, type RollupResult as gI, type RollupServiceOptions as gJ, RollupService as gK, type UserProfileServiceOptions as gL, UserProfileService as gM, type UserValidationResult as gN, type UserValidationError as gO, UserService as gP, type CreateViewInput as gQ, type UpdateViewInput as gR, ViewService as gS, type StartWorkflowInput as gT, type ResumeWorkflowInput as gU, type WorkflowInstanceServiceOptions as gV, WorkflowInstanceService as gW, type CreateParticipationInput as gX, type CreateParticipationResult as gY, type AuthenticationResult as gZ, WorkflowParticipationService as g_, type ViewsRepository as ga, type WorkflowsRepository as gb, type WorkflowInstancesRepository as gc, type WorkflowParticipationsRepository as gd, type AuditRepository as ge, type PermissionsRepository as gf, buildAuditChanges as gg, AuditService as gh, TenantAwareService as gi, TenantAwareRepository as gj, type FileServiceOptions as gk, FileService as gl, GeocodingService as gm, GlobalSearchService as gn, type CreateCustomObjectInput as go, type AddAttributeInput as gp, type UpdateObjectInput as gq, type ObjectSchemaServiceOptions as gr, ObjectSchemaService as gs, type PermissionServiceOptions as gt, PermissionService as gu, type RecordServiceOptions as gv, RecordService as gw, type ResolvedRelations as gx, RelationResolverService as gy, type RelationValidationResult as gz, type SingleRelationAttribute as h, WorkflowRelationService as h0, type CreateWorkflowInput as h1, type UpdateWorkflowInput as h2, WorkflowService as h3, type FileContent as h4, type StorageUploadInput as h5, type StorageUploadResult as h6, type SignedUrlOptions as h7, type StorageAdapter as h8, type UploadFileInput as h9, type SearchOptions as hA, type GlobalSearchOptions as hB, type GlobalSearchResultItem as hC, type FileListOptions as hD, type DBView as hE, type CreateDBView as hF, type UpdateDBView as hG, type UpsertDBView as hH, type DBWorkflow as hI, type CreateDBWorkflow as hJ, type UpdateDBWorkflow as hK, type DBWorkflowInstance as hL, type CreateDBWorkflowInstance as hM, type UpdateDBWorkflowInstance as hN, type DBWorkflowParticipation as hO, type CreateDBWorkflowParticipation as hP, type UpdateDBWorkflowParticipation as hQ, type OperationResult as hR, type ViewSyncResult as hS, type ViewSyncOptions as hT, syncNativeViews as hU, verifyNativeViewsSync as hV, getViewSyncPreview as hW, type SyncResult as ha, type SyncOptions as hb, syncNativeObjects as hc, verifyNativeObjectsSync as hd, getSyncPreview as he, type FullSyncResult as hf, type FullSyncOptions as hg, syncAll as hh, DEFAULT_LABEL_FALLBACK as hi, renderLabelExpression as hj, isLabelExpression as hk, extractAttributeNames as hl, enrichValuesWithSelectLabels as hm, extractRelationIds as hn, type RelationLabelResolver as ho, computeLabelWithRelations as hp, type DBObject as hq, type CreateDBObject as hr, type UpdateDBObject as hs, type UpsertDBObject as ht, type DBAttribute as hu, type CreateDBAttribute as hv, type UpdateDBAttribute as hw, type UpsertDBAttribute as hx, type CreateObjectRecord as hy, type ListOptions as hz, type MultiRelationAttribute as i, type RelationTarget as j, type RatingAttribute as k, type FormulaAttribute as l, type FormulaReturnType as m, type RollupAttribute as n, type RollupFunction as o, type AttributeType as p, type ObjectDefinition as q, type Field as r, type AttributeGroupField as s, type TableTab as t, type InverseTableTab as u, type ViewDefinition as v, type InstanceStatus as w, type Tab as x, type FilterState as y, type SortRule as z };