@stndrds/schema 0.1.0-alpha.66 → 1.0.0-alpha.100

package/dist/index-Dh_XiNFt.d.ts

@@ -0,0 +1,2053 @@
+import { z } from 'zod';
+import { A as Attribute, j as AttributeType, f as RollupAttribute } from './attributes-dw-jLtYS.js';
+import { V as ValidationMessages, a as ValidationResult } from './types-D-0QbsA9.js';
+import { IconName, ColorId } from '@stndrds/constants';
+import { Uuid } from './utils.js';
+
+/** Operators for text-based attributes */
+type TextFilterOperator = "is" | "is_not" | "contains" | "not_contains" | "starts_with" | "ends_with" | "is_empty" | "is_not_empty";
+/** Operators for number-based attributes */
+type NumberFilterOperator = "eq" | "neq" | "lt" | "gt" | "lte" | "gte" | "is_empty" | "is_not_empty";
+/** Operators for checkbox */
+type CheckboxFilterOperator = "is_checked" | "is_not_checked";
+/** Operators for date-based attributes */
+type DateFilterOperator = "is" | "is_not" | "before" | "after" | "on_or_before" | "on_or_after" | "is_within" | "is_empty" | "is_not_empty";
+/** Operators for select-based attributes (supports single or multi-value filtering) */
+type SelectFilterOperator = "is" | "is_not" | "any_of" | "none_of" | "is_empty" | "is_not_empty";
+/** Operators for multiselect-based attributes */
+type MultiselectFilterOperator = "contains" | "not_contains" | "is_empty" | "is_not_empty";
+/** Operators for relation-based attributes (supports single or multi-value filtering) */
+type RelationFilterOperator = "any_of" | "none_of" | "contains" | "not_contains" | "is_empty" | "is_not_empty";
+/** All possible filter operators */
+type FilterOperator = TextFilterOperator | NumberFilterOperator | CheckboxFilterOperator | DateFilterOperator | SelectFilterOperator | MultiselectFilterOperator | RelationFilterOperator;
+/** Relative date value for "is_within" operator */
+interface RelativeDateValue {
+    amount: number;
+    unit: "days" | "weeks" | "months" | "years";
+    direction: "past" | "future";
+}
+/** Currency filter value with amount and optional currency codes
+ * - code: undefined or [] = any currency
+ * - code: string[] = filter by specific currencies
+ */
+interface CurrencyFilterValue {
+    value: number | null;
+    code?: string[];
+}
+/** Phone filter value with number and optional country code */
+interface PhoneFilterValue {
+    phoneNumber: string | null;
+    countryCode?: string;
+}
+/** Filter value can be various types depending on the attribute */
+type FilterValue = string | number | boolean | string[] | RelativeDateValue | CurrencyFilterValue | PhoneFilterValue | null;
+/** A single filter rule */
+interface FilterRule {
+    /** Attribute name to filter on */
+    attribute: string;
+    /** Filter operator */
+    operator: FilterOperator;
+    /** Filter value (null for operators like is_empty) */
+    value: FilterValue;
+}
+/**
+ * Extended filter rule with optional attribute definition.
+ * When provided, enables smarter type-aware filtering (e.g., array operators for multiselect).
+ */
+interface ExtendedFilterRule extends FilterRule {
+    /** Full attribute definition for type-aware filtering */
+    attributeDef?: Attribute;
+}
+/** Combinator for filter rules */
+type FilterCombinator = "and" | "or";
+/** Complete filter state (simple mode) */
+interface FilterState {
+    /** How to combine rules */
+    combinator: FilterCombinator;
+    /** List of filter rules */
+    rules: FilterRule[];
+}
+/**
+ * A filter group containing rules (used in advanced mode)
+ * Groups can be nested up to 2 levels deep
+ */
+interface FilterGroup {
+    /** Unique identifier for this group */
+    id: string;
+    /** How to combine rules within this group */
+    combinator: FilterCombinator;
+    /** List of filter rules in this group */
+    rules: FilterRule[];
+}
+/**
+ * Advanced filter state with nested groups
+ * Structure: AdvancedFilterState -> FilterGroup[] -> FilterRule[]
+ * Maximum 2 levels of nesting
+ */
+interface AdvancedFilterState {
+    /** How to combine groups at the top level */
+    combinator: FilterCombinator;
+    /** List of filter groups */
+    groups: FilterGroup[];
+}
+/** Sort direction */
+type SortDirection = "asc" | "desc";
+/** A single sort rule */
+interface SortRule {
+    /** Attribute name to sort by */
+    attribute: string;
+    /** Sort direction */
+    direction: SortDirection;
+}
+/** Complete query state with search, filters, sorts, and pagination */
+interface QueryState {
+    /** Full-text search query */
+    search?: string;
+    /** Filter configuration (simple mode) */
+    filters?: FilterState;
+    /** Advanced filter configuration (grouped mode) */
+    advancedFilters?: AdvancedFilterState;
+    /** Sort configuration (multiple sorts supported) */
+    sorts?: SortRule[];
+    /** Pagination */
+    limit?: number;
+    offset?: number;
+}
+/** Mapping of attribute types to their valid operators */
+declare const OPERATORS_BY_TYPE: Record<AttributeType, readonly FilterOperator[]>;
+/** Check if an operator requires a value */
+type NoValueOperator = "is_empty" | "is_not_empty" | "is_checked" | "is_not_checked";
+/** Operators that don't require a value */
+declare const NO_VALUE_OPERATORS: readonly NoValueOperator[];
+/**
+ * Check if an operator requires a value
+ */
+declare function isNoValueOperator(operator: FilterOperator): operator is NoValueOperator;
+/**
+ * Get the filter operators for a rollup attribute based on its aggregation function and target type.
+ *
+ * - earliest / latest → date operators
+ * - original → operators matching targetAttributeType (falls back to numeric if unknown)
+ * - all other functions → numeric operators (sum, avg, count, percent, etc.)
+ */
+declare function getRollupFilterOperators(attr: RollupAttribute): readonly FilterOperator[];
+
+interface BufferedRecord {
+    id: string;
+    objectName: string;
+    values: Record<string, unknown>;
+}
+interface RecordPatch {
+    values: Record<string, unknown>;
+}
+type RelationQualifierPatch = Record<string, unknown>;
+interface RelationBuffer {
+    preloaded: BufferedRecord[];
+    added: BufferedRecord[];
+    modified: Record<string, RecordPatch>;
+    removed: string[];
+    qualifiers: Record<string, RelationQualifierPatch>;
+}
+type RelationBufferMap = Record<string, RelationBuffer>;
+interface DisplayRecord {
+    id: string;
+    objectName: string;
+    values: Record<string, unknown>;
+    qualifiers: Record<string, unknown>;
+    status: "existing" | "added" | "modified";
+}
+
+/**
+ * Document generated during workflow execution
+ */
+interface GeneratedDocument {
+    /** Document ID (file ID) */
+    id: string;
+    /** 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>;
+    /** IDs of Document records created (one per target slot) */
+    attachedDocumentIds?: string[];
+}
+/**
+ * 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 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>;
+    /**
+     * Relation buffers for pending relation changes, indexed by slot ID then relation attribute name.
+     */
+    relationBuffers: Record<string, RelationBufferMap>;
+}
+/**
+ * Create an empty execution context
+ */
+declare function createEmptyContext(): WorkflowExecutionContext;
+/**
+ * Get a value from the context using dot notation path.
+ *
+ * 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
+ * const email = getContextValue(context, "slots.client.email");
+ * const amount = getContextValue(context, "forms.quote.amount");
+ * ```
+ */
+declare function getContextValue(context: WorkflowExecutionContext, path: string): unknown;
+/**
+ * Set a value in the context using dot notation path.
+ *
+ * @param context - The execution context (mutated in place)
+ * @param path - Dot notation path to set
+ * @param value - Value to set
+ *
+ * @example
+ * ```typescript
+ * setContextValue(context, "variables.computed", 42);
+ * setContextValue(context, "slots.client.status", "active");
+ * ```
+ */
+declare function setContextValue(context: WorkflowExecutionContext, path: string, value: unknown): void;
+
+/**
+ * Represents a "slot" for an object to be created in the flow
+ * 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") */
+    id: string;
+    /** Name of the object to create (ex: "contacts", "companies") */
+    objectName: string;
+    /** Display label (ex: "Monsieur", "Madame") */
+    label: string;
+    /** Color to visually distinguish in the builder (from COLORS palette) */
+    color?: ColorId;
+    /** Optional icon */
+    icon?: IconName;
+}
+/**
+ * Configuration for relation fields in workflow/flow forms.
+ * Controls which qualified properties are visible and whether
+ * inline record creation is allowed.
+ */
+interface RelationFieldConfig {
+    /** Which qualified properties to display (all if omitted) */
+    visibleProperties?: string[];
+    /** Allow creating new target records inline (default: true) */
+    allowCreate?: boolean;
+}
+/**
+ * Field within a row (simplified - no span, auto-calculated)
+ */
+interface FlowRowField {
+    /** Unique field ID */
+    id: string;
+    /** Reference to FlowSlot.id */
+    slotId: string;
+    /** Attribute name on the object */
+    attribute: string;
+    /** Override label for this flow */
+    label?: string;
+    /** Override tooltip/description for this flow */
+    tooltip?: string;
+    /** Override required */
+    required?: boolean;
+    /** Relation-specific configuration (only for relation attributes) */
+    relationConfig?: RelationFieldConfig;
+}
+/**
+ * Row type discriminator.
+ * - "fields" (or undefined): standard row with data fields
+ * - "heading": section heading
+ * - "separator": visual divider
+ * - "text": static descriptive text
+ */
+type FlowRowType = "fields" | "heading" | "separator" | "text" | "relationList";
+/**
+ * Standard row containing data fields
+ */
+interface FlowFieldsRow {
+    /** Unique row ID */
+    id: string;
+    /** Display order within the page */
+    order: number;
+    /** Row type (optional for backward compat — defaults to "fields") */
+    type?: "fields";
+    /** Fields in this row (auto-distribute width) */
+    fields: FlowRowField[];
+}
+/**
+ * Heading row — renders a section title in the form
+ */
+interface FlowHeadingRow {
+    id: string;
+    order: number;
+    type: "heading";
+    /** Heading text */
+    content: string;
+    /** Heading level (1 = large, 2 = medium, 3 = small) */
+    level?: 1 | 2 | 3;
+}
+/**
+ * Separator row — renders a visual divider
+ */
+interface FlowSeparatorRow {
+    id: string;
+    order: number;
+    type: "separator";
+}
+/**
+ * Static text row — renders descriptive/instructional text
+ */
+interface FlowTextRow {
+    id: string;
+    order: number;
+    type: "text";
+    /** Text content (supports basic markdown) */
+    content: string;
+}
+/**
+ * Relation list row — renders an editable list of related records with preloading
+ */
+interface FlowRelationListRow {
+    id: string;
+    order: number;
+    type: "relationList";
+    slotId: string;
+    relationName: string;
+    preload: boolean;
+    columns: string[];
+    qualifiersInline: boolean;
+    modalFields: "all" | string[];
+    label?: string;
+}
+/**
+ * Union of all row types.
+ * Use `isFlowFieldsRow()` / `isLayoutRow()` type guards for narrowing.
+ */
+type FlowRow = FlowFieldsRow | FlowHeadingRow | FlowSeparatorRow | FlowTextRow | FlowRelationListRow;
+/** Check if a row is a standard fields row */
+declare function isFlowFieldsRow(row: FlowRow): row is FlowFieldsRow;
+/** Check if a row is a layout row (heading, separator, or text) */
+declare function isLayoutRow(row: FlowRow): row is FlowHeadingRow | FlowSeparatorRow | FlowTextRow;
+/** Check if a row is a relation list row */
+declare function isFlowRelationListRow(row: FlowRow): row is FlowRelationListRow;
+/**
+ * Page/step in a flow
+ */
+interface FlowPage {
+    /** Unique page ID */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Optional description */
+    description?: string;
+    /** Display order */
+    order: number;
+    /** Rows in this page */
+    rows: FlowRow[];
+}
+/**
+ * Defines how to link slots after creation
+ * Ex: Link "mr" and "mme" to "company" via their "company" attribute
+ */
+interface FlowRelation {
+    /** Unique relation ID */
+    id: string;
+    /** Source slot that has the relation attribute */
+    sourceSlotId: string;
+    /** Relation attribute on the source slot */
+    sourceAttribute: string;
+    /** Target slot created in the same flow */
+    targetSlotId: string;
+}
+/** Flow lifecycle status */
+type FlowStatus = "draft" | "published" | "archived";
+/**
+ * Complete flow definition for multi-object creation
+ *
+ * @example
+ * ```typescript
+ * const coupleFlow: FlowDefinition = {
+ *   name: "couple-creation",
+ *   label: "Création Couple",
+ *   status: "published",
+ *   version: 1,
+ *   slots: [
+ *     { id: "mr", objectName: "contacts", label: "Monsieur" },
+ *     { id: "mme", objectName: "contacts", label: "Madame" },
+ *     { id: "company", objectName: "companies", label: "Entreprise" },
+ *   ],
+ *   pages: [...],
+ *   relations: [
+ *     { id: "mr-company", sourceSlotId: "mr", sourceAttribute: "company", targetSlotId: "company" },
+ *   ],
+ *   system: true,
+ * };
+ * ```
+ */
+interface FlowDefinition {
+    /** Database ID */
+    id?: Uuid;
+    /** Technical name (kebab-case) */
+    name: string;
+    /** Display label */
+    label: string;
+    /** Optional description */
+    description?: string;
+    /** Optional icon */
+    icon?: IconName;
+    /** Flow status */
+    status: FlowStatus;
+    /** Version for tracking modifications */
+    version: number;
+    /** Slots (objects) to create in this flow */
+    slots: FlowSlot[];
+    /** Pages/steps of the flow */
+    pages: FlowPage[];
+    /** Relations between created slots */
+    relations: FlowRelation[];
+    /** If true, defined in code (protected) */
+    system?: boolean;
+    /** Tenant ID for multi-tenant (optional if single-tenant) */
+    tenantId?: string;
+    /** Extensible metadata */
+    metadata?: Record<string, unknown>;
+    /** Timestamps */
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/**
+ * Check if an object is a FlowDefinition
+ */
+declare function isFlowDefinition(obj: unknown): obj is FlowDefinition;
+/**
+ * Check if a flow is published and available for use
+ */
+declare function isFlowPublished(flow: FlowDefinition): boolean;
+/**
+ * Check if a flow is a system flow (defined in code)
+ */
+declare function isSystemFlow(flow: FlowDefinition): boolean;
+
+/**
+ * All supported comparison operators for condition rules
+ */
+type ConditionOperator = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "contains" | "startsWith" | "endsWith" | "isEmpty" | "isNotEmpty" | "in" | "notIn";
+/**
+ * A single condition rule that compares a field value against a target value.
+ *
+ * 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
+ * const rule: ConditionRule = {
+ *   field: "slots.client.type",
+ *   operator: "eq",
+ *   value: "vip"
+ * };
+ * ```
+ */
+interface ConditionRule {
+    /** Field path to evaluate (dot notation) */
+    field: string;
+    /** Comparison operator */
+    operator: ConditionOperator;
+    /** Value to compare against (type depends on operator) */
+    value: unknown;
+}
+/**
+ * A group of conditions combined with AND/OR logic.
+ * Groups can be nested for complex conditions.
+ *
+ * @example Simple AND condition
+ * ```typescript
+ * 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 ConditionGroup {
+    /** Logical operator to combine rules */
+    operator: "and" | "or";
+    /** Array of rules or nested groups */
+    rules: Array<ConditionRule | ConditionGroup>;
+}
+/**
+ * Check if an item is a ConditionRule (not a ConditionGroup)
+ */
+declare function isConditionRule(item: ConditionRule | ConditionGroup): item is ConditionRule;
+/**
+ * Check if an item is a ConditionGroup
+ */
+declare function isConditionGroup(item: ConditionRule | ConditionGroup): item is ConditionGroup;
+/**
+ * Create a simple equality condition
+ */
+declare function eq(field: string, value: unknown): ConditionRule;
+/**
+ * Create a simple inequality condition
+ */
+declare function neq(field: string, value: unknown): ConditionRule;
+/**
+ * Create an AND condition group
+ */
+declare function and(...rules: Array<ConditionRule | ConditionGroup>): ConditionGroup;
+/**
+ * Create an OR condition group
+ */
+declare function or(...rules: Array<ConditionRule | ConditionGroup>): ConditionGroup;
+/**
+ * Create an "in" condition (value in array)
+ */
+declare function inValues(field: string, values: unknown[]): ConditionRule;
+/**
+ * Create an isEmpty condition
+ */
+declare function isEmpty(field: string): ConditionRule;
+
+/**
+ * Base properties shared by all workflow nodes
+ */
+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;
+    /** Relation-specific config (only for relation attributes) */
+    relationConfig?: RelationFieldConfig;
+}
+/**
+ * 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;
+
+/**
+ * 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" | "create_if_not_empty";
+/**
+ * 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;
+    /** Resolved object label (set by the backend in form context responses) */
+    objectLabel?: string;
+}
+/**
+ * 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;
+}
+/**
+ * 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"
+ * };
+ * ```
+ */
+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 (optional, used by legacy canvas) */
+    layout?: WorkflowLayout;
+    /** 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;
+
+/**
+ * Type of view - determines the config structure
+ */
+type ViewType = "detail" | "list" | "calendar" | "timeline" | "gallery";
+/**
+ * Creation behavior when clicking the "+" button
+ * - `redirect`: Create the record then navigate to its detail page
+ * - `inline`: Insert an empty row in the table (no navigation)
+ * - `modal`: Open a stacked modal for creation
+ */
+type CreateMode = "redirect" | "inline" | "modal";
+/**
+ * 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;
+}
+/**
+ * Base properties shared by all group types
+ */
+interface BaseGroup {
+    id: string;
+    label: string;
+    description?: string;
+    collapsible?: boolean;
+    collapsed?: boolean;
+    order?: number;
+}
+/**
+ * Group of fields for organizing forms (default group type)
+ */
+interface FieldGroup extends BaseGroup {
+    /** Discriminant — optional for backward compatibility with existing data */
+    type?: "fields";
+    fields: Field[];
+}
+/**
+ * Group that displays related records for a relation attribute
+ */
+interface RelationGroup extends BaseGroup {
+    type: "relation";
+    /** Relation attribute name on the source object */
+    attribute: string;
+    /** Columns to display (auto-detected from target object if empty) */
+    columns?: string[];
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Allow creating new related records */
+    allowCreate?: boolean;
+    /**
+     * Two-level traversal — display records from the target's relation.
+     * When set, parent rows become grouping headers and the sub-rows
+     * (from `through.attribute`) are the primary display.
+     *
+     * @example attribute = "members", through.attribute = "companies"
+     *          → displays companies of each member
+     */
+    through?: {
+        /** Relation attribute on the first-level target object */
+        attribute: string;
+    };
+}
+/**
+ * Discriminated union of all group types
+ */
+type Group = FieldGroup | RelationGroup;
+type TabType = "form" | "table" | "custom" | "activity" | "richtext" | "flows" | "documents";
+/**
+ * Base properties shared by all tab types
+ */
+interface BaseTab {
+    id: string;
+    name: string;
+    label: string;
+    icon?: IconName;
+    order?: number;
+}
+/**
+ * Form layout density
+ */
+type FormDensity = "compact" | "comfortable" | "spacious";
+/**
+ * Form tab - displays attributes organized in groups
+ */
+interface FormTab extends BaseTab {
+    type: "form";
+    groups: Group[];
+    /** Number of grid columns (1, 2, or 3). Default: 2 */
+    formColumns?: 1 | 2 | 3;
+    /** Layout density. Default: "comfortable" */
+    density?: FormDensity;
+}
+/**
+ * Direct relation on the current object
+ *
+ * @example Contact.companies → shows Companies linked via the "companies" relation
+ */
+interface RelationSource {
+    type: "relation";
+    /** Relation attribute name on the current object */
+    attribute: string;
+}
+/**
+ * Inverse lookup — records from another object that point to us
+ *
+ * @example On Company, show Contacts where Contact.company = this Company
+ */
+interface InverseSource {
+    type: "inverse";
+    /** Object name that has the relation to us */
+    object: string;
+    /** Relation attribute name on the source object that points to us */
+    attribute: string;
+}
+/**
+ * Where table data comes from — either a direct relation or an inverse lookup
+ */
+type TableSource = RelationSource | InverseSource;
+/**
+ * Table tab - displays related records in a table
+ *
+ * The `source` field determines where data comes from.
+ *
+ * @example Direct: source = { type: "relation", attribute: "members" }
+ * @example Inverse: source = { type: "inverse", object: "contacts", attribute: "company" }
+ */
+interface TableTab extends BaseTab {
+    type: "table";
+    /** Where the data comes from */
+    source: TableSource;
+    /** Columns to display (attribute names from the resolved target object) */
+    columns: string[];
+    /**
+     * Traverse a 2nd-level relation to display nested data.
+     * When active, `columns` stores the 2nd-level object's attribute names.
+     *
+     * @example source.attribute = "members", through.attribute = "companies"
+     *          → displays companies of each member
+     */
+    through?: {
+        /** Relation attribute on the first-level target object */
+        attribute: string;
+        /** Show _source and _target columns */
+        showSourceTarget?: boolean;
+    };
+    /** Allow creating new records */
+    allowCreate?: boolean;
+    /** Creation behavior when allowCreate is true. Default: "redirect" */
+    createMode?: CreateMode;
+    /** Allow inline editing */
+    allowEdit?: boolean;
+    /** Allow deleting records */
+    allowDelete?: boolean;
+    /** Default filters applied to the table */
+    filters?: FilterState;
+    /** Default sort rules */
+    sorts?: SortRule[];
+}
+/**
+ * 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";
+    limit?: number;
+}
+/**
+ * Richtext tab - displays a block editor for a richtext attribute
+ */
+interface RichtextTab extends BaseTab {
+    type: "richtext";
+    /** Richtext attribute to display in the BlockEditor */
+    attribute: string;
+    /** Optional text attribute for an editable title input above the editor */
+    titleAttribute?: string;
+}
+/**
+ * Flows tab - displays workflow instances linked to the current record
+ */
+interface FlowsTab extends BaseTab {
+    type: "flows";
+    allowStart?: boolean;
+    allowCancel?: boolean;
+    statusFilter?: InstanceStatus[];
+    columns?: ("workflow" | "status" | "startedBy" | "createdAt" | "updatedAt")[];
+}
+/**
+ * Documents tab - displays all documents attached to the record
+ */
+interface DocumentsTab extends BaseTab {
+    type: "documents";
+    allowUpload?: boolean;
+    allowRemove?: boolean;
+    showProcessing?: boolean;
+    showRequiredWarnings?: boolean;
+    hideAttachments?: boolean;
+}
+/**
+ * Union of all tab types (for detail views)
+ */
+type Tab = FormTab | TableTab | CustomTab | ActivityTab | RichtextTab | FlowsTab | DocumentsTab;
+/**
+ * Detail view layout mode
+ * - `page`: Full view with multiple tabs
+ * - `modal`: Simplified view for modals (single FormTab, no tabs UI)
+ */
+type DetailViewLayout = "page" | "modal";
+/**
+ * List view layout mode
+ * - `table`: Table/grid layout
+ * - `kanban`: Kanban board layout (grouped by attribute)
+ */
+type ListViewLayout = "table" | "kanban";
+/**
+ * Tab within a list view — each tab carries its own full display configuration.
+ *
+ * @example
+ * ```typescript
+ * const tabs: ListViewTab[] = [
+ *   { id: "all", label: "All Contacts", default: true, layout: "table", columns: ["name", "email", "status"] },
+ *   { id: "active", label: "Active", layout: "table", columns: ["name", "email"], filters: activeFilter },
+ *   { id: "pipeline", label: "Pipeline", layout: "kanban", columns: ["name", "amount"], groupByAttribute: "stage" },
+ * ];
+ * ```
+ */
+interface ListViewTab {
+    /** Unique identifier */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Icon */
+    icon?: IconName;
+    /** Default tab (shown on load) */
+    default?: boolean;
+    /** Layout mode */
+    layout: ListViewLayout;
+    /** Attribute names to display as columns */
+    columns: string[];
+    /** Column widths in pixels */
+    columnSizing?: Record<string, number>;
+    /** Filters applied to this tab */
+    filters?: FilterGroup;
+    /** Sort rules for this tab */
+    sorts?: SortRule[];
+    /** Attribute to group by (required when layout is "kanban") */
+    groupByAttribute?: string;
+    /** When true, the tab is read-only: no cell editing, no create, no delete */
+    readOnly?: boolean;
+    /** Creation behavior when clicking "+". Default: "redirect" */
+    createMode?: CreateMode;
+    /** User attribute to display on kanban cards (bottom-left) */
+    cardUserAttribute?: string;
+    /** Date attribute to display on kanban cards (bottom-right) */
+    cardDateAttribute?: string;
+    /** Order of kanban columns (by option value) - for kanban layout only */
+    kanbanColumnOrder?: string[];
+    /** Visibility of kanban columns (by option value) - for kanban layout only */
+    kanbanColumnVisibility?: Record<string, boolean>;
+    /** Pinned kanban columns (by option value) - for kanban layout only */
+    kanbanPinnedColumns?: string[];
+}
+/**
+ * Configuration for the side panel displayed alongside tab content.
+ * When present, a right-side panel shows the configured attributes as flat fields.
+ */
+interface SidePanelConfig {
+    /** Attribute names to display as flat fields in the panel */
+    attributes: string[];
+    /** Width in pixels. @default 320 */
+    width?: number;
+}
+/**
+ * Configuration for detail views (RecordEditView)
+ */
+interface DetailViewConfig {
+    /** Layout mode */
+    layout: DetailViewLayout;
+    /** Tabs in this view */
+    tabs: Tab[];
+    /** Optional side panel with flat attribute fields (not available for modal layout) */
+    sidePanel?: SidePanelConfig;
+}
+/**
+ * Configuration for list views (RecordsView)
+ *
+ * Each tab carries its own full config (layout, columns, filters, sorts, groupBy).
+ * The view only holds shared base filters applied to ALL tabs.
+ */
+interface ListViewConfig {
+    /** Base filters applied to ALL tabs (scoping, tenant, etc.) */
+    defaultFilters?: FilterGroup;
+    /** Tabs — at least one required. Each carries its own full config. */
+    tabs: ListViewTab[];
+}
+/**
+ * Configuration for calendar views (future)
+ */
+interface CalendarViewConfig {
+    /** Date attribute for positioning events */
+    dateAttribute: string;
+    /** End date attribute (for range events) */
+    endDateAttribute?: string;
+    /** Title attribute for event display */
+    titleAttribute: string;
+    /** Color attribute (status/select) */
+    colorAttribute?: string;
+}
+/**
+ * Configuration for timeline views (future)
+ */
+interface TimelineViewConfig {
+    /** Date attribute for timeline positioning */
+    dateAttribute: string;
+    /** Group by attribute */
+    groupByAttribute?: string;
+}
+/**
+ * Configuration for gallery views (future)
+ */
+interface GalleryViewConfig {
+    /** Image attribute to display */
+    imageAttribute: string;
+    /** Title attribute */
+    titleAttribute?: string;
+    /** Columns per row */
+    columnsPerRow?: number;
+}
+/**
+ * Union of all view configs
+ */
+type ViewConfig = DetailViewConfig | ListViewConfig | CalendarViewConfig | TimelineViewConfig | GalleryViewConfig;
+/**
+ * Base view properties shared by all view types
+ */
+interface BaseViewDefinition {
+    /** Unique identifier (UUID, assigned by database) */
+    id?: string;
+    /** 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;
+    /** Default view for this object+type combination */
+    default?: boolean;
+    /** Extensible metadata */
+    metadata?: Record<string, unknown>;
+    /** Current schema version of this view definition */
+    schema_version: number;
+}
+/**
+ * Detail view definition
+ */
+interface DetailViewDefinition extends BaseViewDefinition {
+    type: "detail";
+    config: DetailViewConfig;
+}
+/**
+ * List view definition
+ */
+interface ListViewDefinition extends BaseViewDefinition {
+    type: "list";
+    config: ListViewConfig;
+}
+/**
+ * Calendar view definition (future)
+ */
+interface CalendarViewDefinition extends BaseViewDefinition {
+    type: "calendar";
+    config: CalendarViewConfig;
+}
+/**
+ * Timeline view definition (future)
+ */
+interface TimelineViewDefinition extends BaseViewDefinition {
+    type: "timeline";
+    config: TimelineViewConfig;
+}
+/**
+ * Gallery view definition (future)
+ */
+interface GalleryViewDefinition extends BaseViewDefinition {
+    type: "gallery";
+    config: GalleryViewConfig;
+}
+/**
+ * Unified view definition - discriminated union by type
+ */
+type ViewDefinition = DetailViewDefinition | ListViewDefinition | CalendarViewDefinition | TimelineViewDefinition | GalleryViewDefinition;
+/**
+ * Configuration overrides for user customizations
+ * Only stores the delta from the source view
+ */
+interface ConfigOverrides {
+    tabs?: ListViewTab[];
+    hiddenTabIds?: string[];
+    detailTabs?: Tab[];
+    hiddenDetailTabIds?: string[];
+}
+/**
+ * User customization overlay for a view
+ * Stored per user, merged at runtime with the source view
+ */
+interface ViewOverlay {
+    /** Unique identifier */
+    id: string;
+    /** View ID this overlay applies to (UUID or virtual ID) */
+    viewId: string;
+    /** User ID who owns this overlay */
+    userId: string;
+    /** Configuration overrides (delta only) */
+    configOverrides: ConfigOverrides;
+    /** User's default view for this object (stored in overlay) */
+    isUserDefault?: boolean;
+    /** Created timestamp */
+    createdAt: Date;
+    /** Updated timestamp */
+    updatedAt: Date;
+}
+/**
+ * Check if a view is a detail view
+ */
+declare function isDetailView(view: ViewDefinition): view is DetailViewDefinition;
+/**
+ * Check if a view is a list view
+ */
+declare function isListView(view: ViewDefinition): view is ListViewDefinition;
+/**
+ * Check if a view is a calendar view
+ */
+declare function isCalendarView(view: ViewDefinition): view is CalendarViewDefinition;
+/**
+ * Check if a view is a timeline view
+ */
+declare function isTimelineView(view: ViewDefinition): view is TimelineViewDefinition;
+/**
+ * Check if a view is a gallery view
+ */
+declare function isGalleryView(view: ViewDefinition): view is GalleryViewDefinition;
+/**
+ * Check if a group is a field group (default type)
+ */
+declare function isFieldGroup(group: Group): group is FieldGroup;
+/**
+ * Check if a group is a relation group
+ */
+declare function isRelationGroup(group: Group): group is RelationGroup;
+/**
+ * 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 uses a direct relation source
+ */
+declare function isRelationSourceTab(tab: Tab): tab is TableTab & {
+    source: RelationSource;
+};
+/**
+ * Check if a table tab uses an inverse source
+ */
+declare function isInverseSourceTab(tab: Tab): tab is TableTab & {
+    source: InverseSource;
+};
+/**
+ * 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 richtext tab
+ */
+declare function isRichtextTab(tab: Tab): tab is RichtextTab;
+/**
+ * Check if a tab is a flows tab
+ */
+declare function isFlowsTab(tab: Tab): tab is FlowsTab;
+/**
+ * Check if a tab is a documents tab
+ */
+declare function isDocumentsTab(tab: Tab): tab is DocumentsTab;
+
+type TransformSource = "system" | "runtime" | "rollback" | "seed";
+type BuiltInTransform = "toString" | "toNumber" | "toDate" | "toBoolean" | "toISOString";
+type SchemaOperation = {
+    type: "add_attribute";
+    attribute: Attribute;
+} | {
+    type: "remove_attribute";
+    name: string;
+    backup_config: Attribute;
+} | {
+    type: "rename_attribute";
+    from: string;
+    to: string;
+} | {
+    type: "change_type";
+    name: string;
+    from: AttributeType;
+    to: AttributeType;
+    transform?: BuiltInTransform;
+} | {
+    type: "update_config";
+    name: string;
+    from: Partial<Record<string, unknown>>;
+    to: Partial<Record<string, unknown>>;
+} | {
+    type: "remove_object";
+    backup: Record<string, unknown>;
+} | {
+    type: "rename_object";
+    from: string;
+    to: string;
+};
+type ViewOperation = {
+    type: "update_config";
+    from: ViewConfig;
+    to: ViewConfig;
+} | {
+    type: "update_tabs";
+    from: (ListViewTab | Tab)[];
+    to: (ListViewTab | Tab)[];
+} | {
+    type: "force_reset";
+    config: ViewConfig;
+} | {
+    type: "remove_view";
+    backup: Record<string, unknown>;
+};
+interface MigrationDefinition {
+    version: number;
+    operations: SchemaOperation[];
+    reverse_operations: SchemaOperation[];
+}
+interface SchemaTransform {
+    id: string;
+    tenantId: string;
+    objectId: string;
+    fromVersion: number;
+    toVersion: number;
+    operations: SchemaOperation[];
+    reverseOperations: SchemaOperation[];
+    source: TransformSource;
+    appliedAt: Date;
+    fullyMigrated: boolean;
+}
+interface ViewTransform {
+    id: string;
+    tenantId: string;
+    viewId: string;
+    fromVersion: number;
+    toVersion: number;
+    operations: ViewOperation[];
+    reverseOperations: ViewOperation[];
+    source: TransformSource;
+    appliedAt: Date;
+}
+interface MigrationError {
+    id: string;
+    tenantId: string;
+    transformId: string;
+    recordId: string;
+    attributeName: string;
+    originalValue: unknown;
+    error: string;
+    resolvedAt: Date | null;
+    resolvedValue: unknown | null;
+}
+interface RetentionPolicy {
+    attributeData: number;
+    deletedObjects: number;
+    transforms: number;
+    migrationErrors: number;
+}
+declare const DEFAULT_RETENTION_POLICY: RetentionPolicy;
+interface MigrationPreview {
+    affectedRecords: number;
+    potentialErrors: number;
+    reversible: boolean;
+    estimatedDuration: string;
+    sampleErrors: Array<{
+        recordId: string;
+        attribute: string;
+        value: unknown;
+        reason: string;
+    }>;
+}
+
+/**
+ * Timestamps for tracking creation and updates
+ */
+interface Timestamps {
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Object definition - Represents a database table/entity
+ */
+interface ObjectDefinition {
+    id?: Uuid;
+    name: string;
+    label: string;
+    pluralLabel?: string;
+    description?: string;
+    icon?: IconName;
+    /**
+     * Template expression used to compute the object's display label.
+     * Supports variable interpolation and pipes for formatting.
+     *
+     * @example
+     * ```typescript
+     * // Simple attribute reference
+     * labelExpression: "{{ name }}"
+     *
+     * // Multiple attributes
+     * labelExpression: "{{ firstName }} {{ lastName }}"
+     *
+     * // With pipes for formatting
+     * labelExpression: "{{ code | UPPER }} - {{ name | capitalize }}"
+     * ```
+     *
+     * Available pipes: UPPER, LOWER, capitalize, trim
+     */
+    labelExpression: string;
+    attributes: Attribute[];
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+    /** Current schema version (incremented with each migration) */
+    schema_version: number;
+    /** Ordered list of migrations applied to this object's schema */
+    migrations: MigrationDefinition[];
+}
+/**
+ * Links an attribute to an object
+ */
+interface ObjectAttribute {
+    objectId: Uuid;
+    attributeId: Uuid;
+    order?: number;
+    required?: boolean;
+}
+/**
+ * Completion status of a record based on data completeness.
+ *
+ * - `draft`: Record is missing one or more required attribute values.
+ *   Can be saved but is considered incomplete.
+ * - `complete`: All required attribute values are present and valid.
+ *   Record is ready for use.
+ *
+ * This is different from workflow status (e.g., "pending", "approved").
+ * Completion status is computed dynamically based on the object schema.
+ */
+type CompletionStatus = "draft" | "complete";
+/**
+ * Record - Instance of an Object (a row in the database)
+ */
+interface ObjectRecord extends Timestamps {
+    id: Uuid;
+    objectId: Uuid;
+    /**
+     * Display label computed from the object's labelExpression.
+     * Computed dynamically based on record values.
+     *
+     * @example "John Doe" (from "{{ firstName }} {{ lastName }}")
+     */
+    label: string;
+    /**
+     * Completion status of the record.
+     * - `draft`: Missing required values, record is incomplete
+     * - `complete`: All required values present and valid
+     *
+     * Computed dynamically based on the object's schema.
+     */
+    completionStatus: CompletionStatus;
+    values: Record<string, unknown>;
+    /**
+     * Custom metadata for the record.
+     * Use this for UI/UX state, feature flags, or any application-specific data.
+     * Unlike system fields (id, createdAt, updatedAt), metadata can be updated.
+     */
+    metadata?: Record<string, unknown>;
+    /**
+     * Soft delete timestamp.
+     * If set, the record is considered deleted but can be restored.
+     * Queries exclude soft-deleted records by default.
+     */
+    deletedAt?: Date | null;
+    /**
+     * User ID who created this record.
+     * Automatically set by RecordService when userId is configured.
+     * Optional for backward compatibility with existing records.
+     */
+    createdBy?: string;
+    /**
+     * User ID who last updated this record.
+     * Automatically set by RecordService when userId is configured.
+     * Optional for backward compatibility with existing records.
+     */
+    lastUpdatedBy?: string;
+    /** Schema version at the time this record was last migrated */
+    schemaVersion: number;
+    /**
+     * Values archived during attribute removal or type changes.
+     * Retained according to the retention policy before permanent deletion.
+     */
+    archivedValues?: Record<string, unknown>;
+}
+/**
+ * System-managed field names on ObjectRecord.
+ * These are stored as SQL columns (not in JSONB `values`).
+ *
+ * Use this in adapters to determine if a filter/sort attribute is a table column
+ * vs. a JSONB value field.
+ *
+ * @example
+ * ```typescript
+ * if (SYSTEM_FIELD_NAMES.includes(filter.attribute)) {
+ *   // Filter on SQL column (e.g., WHERE created_at > ...)
+ * } else {
+ *   // Filter on JSONB field (e.g., WHERE values->>'name' = ...)
+ * }
+ * ```
+ */
+declare const SYSTEM_FIELD_NAMES: readonly ["id", "createdAt", "updatedAt", "createdBy", "lastUpdatedBy"];
+/**
+ * Type for system field names
+ */
+type SystemFieldName = (typeof SYSTEM_FIELD_NAMES)[number];
+/**
+ * Reserved attribute names that cannot be used for custom attributes.
+ * These names conflict with ObjectRecord properties.
+ *
+ * Includes:
+ * - System fields (id, createdAt, updatedAt, createdBy, lastUpdatedBy)
+ * - Other ObjectRecord properties (objectId, label, completionStatus, values, metadata, deletedAt)
+ *
+ * @example
+ * ```typescript
+ * if (RESERVED_ATTRIBUTE_NAMES.includes(attributeName)) {
+ *   throw new Error(`"${attributeName}" is a reserved name`);
+ * }
+ * ```
+ */
+declare const RESERVED_ATTRIBUTE_NAMES: readonly ["id", "createdAt", "updatedAt", "createdBy", "lastUpdatedBy", "objectId", "label", "completionStatus", "values", "metadata", "deletedAt", "schemaVersion", "archivedValues"];
+/**
+ * Type for reserved attribute names
+ */
+type ReservedAttributeName = (typeof RESERVED_ATTRIBUTE_NAMES)[number];
+
+/**
+ * Create a Zod schema for any attribute type.
+ * Returns a strict validator that does NOT handle optional fields.
+ * Use createFormAttributeValidator for form validation with optional support.
+ *
+ * @param attr - The attribute to create a validator for
+ * @param messages - Custom validation messages for i18n support
+ */
+declare function createAttributeValidator(attr: Attribute, messages?: ValidationMessages): z.ZodTypeAny;
+/**
+ * Create a Zod schema for form validation.
+ * - Normalizes empty values (empty strings, empty objects) to null for optional fields
+ * - Accepts custom messages for i18n support
+ *
+ * Use this in UI forms where optional fields may have null/undefined values.
+ *
+ * @param attr - The attribute to create a validator for
+ * @param messages - Custom validation messages for i18n support
+ */
+declare function createFormAttributeValidator(attr: Attribute, messages?: ValidationMessages): z.ZodTypeAny;
+
+/**
+ * Create a Zod schema for an entire object
+ *
+ * Uses passthrough mode to allow computed fields (formula, rollup) that may be
+ * present in record data but are not part of the mutable schema.
+ */
+declare function createObjectValidator(objectDef: ObjectDefinition): z.ZodType<Record<string, unknown>>;
+/**
+ * Create a Zod schema for draft validation.
+ * All attributes become optional, but provided values are still validated.
+ *
+ * Uses passthrough mode to allow computed fields (formula, rollup) that may be
+ * present in record data but are not part of the mutable schema.
+ */
+declare function createDraftValidator(objectDef: ObjectDefinition): z.ZodType<Record<string, unknown>>;
+
+/**
+ * Validate data against an attribute schema
+ */
+declare function validateAttribute(attr: Attribute, value: unknown): ValidationResult;
+/**
+ * Validate data against an object schema
+ */
+declare function validateObject(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
+/**
+ * Validate and throw if invalid
+ */
+declare function validateObjectOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Validate data in draft mode.
+ * - All attributes are treated as optional (no required validation)
+ * - Provided values are still validated for format/type correctness
+ */
+declare function validateDraft(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
+/**
+ * Validate draft data and throw if format validation fails.
+ */
+declare function validateDraftOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Get the list of required attributes that are missing values.
+ */
+declare function getMissingRequiredAttributes(objectDef: ObjectDefinition, data: Record<string, unknown>): Attribute[];
+/**
+ * Check if a record is complete (all required attributes have valid values).
+ */
+declare function isRecordComplete(objectDef: ObjectDefinition, data: Record<string, unknown>): boolean;
+/**
+ * Compute the completion status of a record based on its data.
+ */
+declare function computeRecordStatus(objectDef: ObjectDefinition, data: Record<string, unknown>): CompletionStatus;
+
+export { type ListViewConfig as $, type WorkflowExecutionContext as A, type WorkflowTransition as B, type ConfigOverrides as C, type CompletionStatus as D, type ObjectDefinition as E, type FilterState as F, type DetailViewConfig as G, type DetailViewDefinition as H, type InstanceStatus as I, type DetailViewLayout as J, type SidePanelConfig as K, type Field as L, type MigrationDefinition as M, type AttributeGroupField as N, type ObjectRecord as O, type PendingAction as P, type FieldGroup as Q, type RelationFieldConfig as R, type SortRule as S, type Timestamps as T, type RelationGroup as U, type ViewType as V, type WorkflowNode as W, type Group as X, type TableTab as Y, type CreateMode as Z, type Tab as _, createAttributeValidator as a, type RelationQualifierPatch as a$, type ListViewDefinition as a0, type SlotMode as a1, type FlowFieldsRow as a2, type ConditionGroup as a3, type ConditionRule as a4, type ViewDefinition as a5, type ListViewTab as a6, type ActivityTab as a7, type AdvancedFilterState as a8, type BufferedRecord as a9, type FlowRowType as aA, type FlowSlot as aB, type FlowStatus as aC, type FlowsTab as aD, type FormDensity as aE, type FormFieldRef as aF, type FormTab as aG, type GalleryViewConfig as aH, type GalleryViewDefinition as aI, type GeneratedDocument as aJ, type InverseSource as aK, type ListViewLayout as aL, type MigrationError as aM, type MigrationPreview as aN, type MultiselectFilterOperator as aO, NO_VALUE_OPERATORS as aP, type NoValueOperator as aQ, type NodePosition as aR, type NumberFilterOperator as aS, OPERATORS_BY_TYPE as aT, type ObjectAttribute as aU, type PhoneFilterValue as aV, type QueryState as aW, RESERVED_ATTRIBUTE_NAMES as aX, type RecordPatch as aY, type RelationBuffer as aZ, type RelationFilterOperator as a_, type BuiltInTransform as aa, type CalendarViewConfig as ab, type CalendarViewDefinition as ac, type CanvasViewport as ad, type CheckboxFilterOperator as ae, type ConditionNode as af, type ConditionOperator as ag, type CurrencyFilterValue as ah, type CustomTab as ai, DEFAULT_RETENTION_POLICY as aj, DEFAULT_THEME as ak, type DateFilterOperator as al, type DisplayRecord as am, type DocumentsTab as an, type EndNode as ao, type ExtendedFilterRule as ap, type FilterCombinator as aq, type FilterGroup as ar, type FilterOperator as as, type FilterRule as at, type FilterValue as au, type FlowDefinition as av, type FlowPage as aw, type FlowRelation as ax, type FlowRow as ay, type FlowRowField as az, createDraftValidator as b, isRichtextTab as b$, type RelationSource as b0, type RelativeDateValue as b1, type ReservedAttributeName as b2, type RetentionPolicy as b3, type RichtextTab as b4, SYSTEM_FIELD_NAMES as b5, type SchemaOperation as b6, type SchemaTransform as b7, type SelectFilterOperator as b8, type SortDirection as b9, isAdvancedFormNode as bA, isCalendarView as bB, isConditionGroup as bC, isConditionNode as bD, isConditionRule as bE, isCustomTab as bF, isDetailView as bG, isDocumentsTab as bH, isEmpty as bI, isEndNode as bJ, isFieldGroup as bK, isFlowDefinition as bL, isFlowFieldsRow as bM, isFlowPublished as bN, isFlowRelationListRow as bO, isFlowsTab as bP, isFormNode as bQ, isFormTab as bR, isGalleryView as bS, isInstanceTerminal as bT, isInstanceWaiting as bU, isInverseSourceTab as bV, isLayoutRow as bW, isListView as bX, isNoValueOperator as bY, isRelationGroup as bZ, isRelationSourceTab as b_, type StartNode as ba, type SystemFieldName as bb, type TabType as bc, type TableSource as bd, type TextFilterOperator as be, type ThemeColors as bf, type ThemeLogo as bg, type ThemeTypography as bh, type TimelineViewConfig as bi, type TimelineViewDefinition as bj, type TransformSource as bk, type ViewOperation as bl, type ViewOverlay as bm, type ViewTransform as bn, type WorkflowError as bo, type WorkflowInstance as bp, and as bq, canResumeInstance as br, createEmptyContext as bs, createStartTransition as bt, eq as bu, generateCssVariables as bv, getContextValue as bw, getRollupFilterOperators as bx, inValues as by, isActivityTab as bz, computeRecordStatus as c, isSimpleFormNode as c0, isStartNode as c1, isSystemFlow as c2, isSystemWorkflow as c3, isTableTab as c4, isTimelineView as c5, isWorkflowDefinition as c6, isWorkflowPublished as c7, mergeWithDefaults as c8, neq as c9, or as ca, setContextValue as cb, createFormAttributeValidator as d, createObjectValidator as e, validateDraft as f, getMissingRequiredAttributes as g, validateDraftOrThrow as h, isRecordComplete as i, validateObject as j, validateObjectOrThrow as k, type FormNode as l, type WorkflowNodeType as m, type FlowHeadingRow as n, type FlowSeparatorRow as o, type FlowTextRow as p, type FlowRelationListRow as q, type WorkflowSlot as r, type WorkflowTheme as s, type RelationBufferMap as t, type ViewConfig as u, validateAttribute as v, type WorkflowStatus as w, type WorkflowLayout as x, type WorkflowConfig as y, type WorkflowDefinition as z };