@stndrds/schema 1.0.0-alpha.91 → 1.0.0-alpha.93

package/dist/validators-BXWI__2n.d.ts

@@ -0,0 +1,3543 @@
+import { z } from 'zod';
+import { IconName, CountryIso3, CurrencyCode, ColorId, MimeType } from '@stndrds/constants';
+import { Uuid } from './utils.js';
+
+/**
+ * Feature flag levels (resolution priority: user > tenant > global).
+ *
+ * - `global`: Applies to all tenants and users
+ * - `tenant`: Applies to a specific tenant
+ * - `user`: Applies to a specific user within a tenant
+ */
+type FlagLevel = "global" | "tenant" | "user";
+/**
+ * Flag value types supported by the system.
+ */
+type FlagValueType = "boolean" | "string" | "number" | "json";
+/**
+ * Definition of a feature flag.
+ * Created using the flag builders (booleanFlag, stringFlag, etc.)
+ */
+interface FeatureFlagDefinition<T = unknown> {
+    /** Unique identifier for the flag (kebab-case) */
+    name: string;
+    /** Human-readable label */
+    label: string;
+    /** Optional description */
+    description?: string;
+    /** Type of the flag value */
+    valueType: FlagValueType;
+    /** Default value when no override exists */
+    defaultValue: T;
+    /** Levels at which this flag can be overridden */
+    allowedLevels: FlagLevel[];
+    /** Grouping category for UI */
+    category?: string;
+    /** System flag - cannot be modified via API */
+    system?: boolean;
+}
+/**
+ * Stored override for a feature flag.
+ * Represents a row in the feature_flag_overrides table.
+ */
+interface FlagOverride<T = unknown> {
+    /** Name of the flag being overridden */
+    flagName: string;
+    /** Level of the override */
+    level: FlagLevel;
+    /** Target ID (tenantId for tenant-level, userId for user-level) */
+    targetId?: string;
+    /** Override value */
+    value: T;
+    /** Optional expiration date */
+    expiresAt?: Date;
+    /** Who created this override */
+    createdBy?: string;
+    /** When the override was created */
+    createdAt: Date;
+    /** When the override was last updated */
+    updatedAt: Date;
+}
+/**
+ * Resolved flag value with source information.
+ * Result of flag resolution including where the value came from.
+ */
+interface ResolvedFlag<T = unknown> {
+    /** Flag name */
+    name: string;
+    /** Resolved value */
+    value: T;
+    /** Where the value came from */
+    source: FlagLevel | "default";
+    /** ID of the source (tenantId or userId) if not default */
+    sourceId?: string;
+}
+/**
+ * Feature gate configuration for conditional attribute visibility.
+ * Used with the `.featureGate()` builder method.
+ */
+interface FeatureGate {
+    /** Name of the flag to check */
+    flag: string;
+    /**
+     * Expected value for the gate to pass.
+     * For boolean flags, defaults to `true`.
+     * For other types, compares with strict equality.
+     */
+    expectedValue?: unknown;
+    /**
+     * Behavior when the gate fails.
+     * - `hide`: Attribute is completely hidden (default)
+     * - `show`: Attribute is shown regardless (no gating)
+     * - `disable`: Attribute is visible but read-only
+     */
+    fallback?: "hide" | "show" | "disable";
+}
+/**
+ * Repository interface for feature flag overrides storage.
+ * Added to DatabaseAdapter as an optional repository.
+ *
+ * If not provided, only static defaults from module config are used.
+ */
+interface FeatureFlagsRepository {
+    /**
+     * Get all overrides matching the criteria.
+     * Returns overrides from the database (global, tenant, or user level).
+     */
+    getOverrides(options: {
+        /** Filter by level */
+        level?: FlagLevel;
+        /** Filter by target ID (tenantId or userId) */
+        targetId?: string;
+        /** Filter by flag names (for efficient single/batch lookups) */
+        flagNames?: string[];
+    }): Promise<FlagOverride[]>;
+    /**
+     * Create or update an override.
+     * Uses upsert semantics based on (flagName, level, targetId).
+     */
+    setOverride(override: Omit<FlagOverride, "createdAt" | "updatedAt">): Promise<FlagOverride>;
+    /**
+     * Delete an override.
+     */
+    deleteOverride(flagName: string, level: FlagLevel, targetId?: string): Promise<void>;
+}
+/**
+ * Static flag default value for module configuration.
+ */
+interface StaticFlagDefault {
+    /** Flag name */
+    name: string;
+    /** Default value */
+    value: unknown;
+}
+/**
+ * Feature flags configuration for SchemaModule.
+ */
+interface FeatureFlagsConfig {
+    /**
+     * Static default values for flags.
+     * These are always applied and used when no database override exists.
+     *
+     * @example
+     * ```typescript
+     * featureFlags: {
+     *   defaults: [
+     *     { name: "architect-mode", value: false },
+     *     { name: "ai-chat", value: false },
+     *     { name: "tier", value: "free" },
+     *   ],
+     * }
+     * ```
+     */
+    defaults?: StaticFlagDefault[];
+}
+
+/**
+ * Allowed attribute types in .qualifyWith()
+ *
+ * IMPORTANT: Complex types (formula, rollup, relation, file, user, document, richtext)
+ * are NOT supported to avoid duplicating backend behavior.
+ */
+type PropertyType = "text" | "textarea" | "number" | "checkbox" | "date" | "phone" | "currency" | "status" | "select" | "multiselect" | "rating" | "location";
+/**
+ * Forbidden property types that would require complex backend duplication
+ */
+declare const FORBIDDEN_PROPERTY_TYPES: readonly ["formula", "rollup", "relation", "file", "user", "document", "richtext"];
+type ForbiddenPropertyType = (typeof FORBIDDEN_PROPERTY_TYPES)[number];
+/**
+ * Union of attribute types allowed as qualified relation properties.
+ *
+ * These are the same Attribute types used for object attributes,
+ * restricted to simple types that don't require complex backend duplication.
+ */
+type PropertyAttribute = TextAttribute | TextAreaAttribute | NumberAttribute | CheckboxAttribute | DateAttribute | PhoneAttribute | CurrencyAttribute | StatusAttribute | SelectAttribute | MultiselectAttribute | RatingAttribute | LocationAttribute;
+/**
+ * Schema defining properties for a qualified relation.
+ *
+ * Uses the same Attribute types as object attributes, enabling DRY builders:
+ *
+ * @example
+ * ```typescript
+ * relation({ name: "companies", label: "Companies" })
+ *   .to("companies").many()
+ *   .qualifyWith(
+ *     select({ name: "role", label: "Role" }).options([...]).required(),
+ *     number({ name: "shares", label: "Shares" }).min(0),
+ *   )
+ * ```
+ */
+interface PropertySchema {
+    definitions: PropertyAttribute[];
+}
+/**
+ * Property attribute types that have an `options` array.
+ */
+type OptionPropertyAttribute = SelectAttribute | StatusAttribute | MultiselectAttribute;
+/**
+ * Type guard to check if a property attribute has options.
+ *
+ * @param attr - The property attribute to check
+ * @returns true if the attribute is a select, status, or multiselect type with options
+ *
+ * @example
+ * ```typescript
+ * for (const def of definitions) {
+ *   if (hasOptions(def)) {
+ *     // TypeScript knows def.options exists and is Option[]
+ *     for (const option of def.options) {
+ *       console.log(option.value);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare function hasOptions(attr: PropertyAttribute): attr is OptionPropertyAttribute;
+
+type AttributeType = "text" | "textarea" | "richtext" | "number" | "checkbox" | "date" | "phone" | "currency" | "status" | "location" | "select" | "multiselect" | "file" | "user" | "relation" | "rating" | "formula" | "rollup" | "document";
+/**
+ * Status group categorization
+ */
+type StatusGroup = "idle" | "in_progress" | "finished";
+/**
+ * Unified option type for select-like fields
+ */
+interface Option {
+    id: string;
+    label: string;
+    value: string;
+    color?: ColorId;
+    icon?: IconName;
+    description?: string;
+    group?: StatusGroup;
+    /** Value of the inverse option for bilateral relations (e.g. "parent" → "child") */
+    inverse?: string;
+}
+/**
+ * Attribute grouping for UI organization
+ */
+interface AttributeGroup {
+    id: string;
+    label: string;
+    description?: string;
+    attributeIds: string[];
+    collapsible?: boolean;
+    collapsed?: boolean;
+    order?: number;
+}
+interface BaseAttribute<DefaultValueType = unknown> {
+    id: Uuid;
+    name: string;
+    label: string;
+    type: AttributeType;
+    required: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    description?: string;
+    defaultValue?: DefaultValueType;
+    icon?: IconName;
+    order?: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    system?: boolean;
+    /**
+     * Feature gate to conditionally show/hide/disable this attribute.
+     * When the flag condition is not met, the attribute behavior depends on `fallback`:
+     * - "hide" (default): Attribute is completely hidden
+     * - "disable": Attribute is visible but read-only
+     * - "show": No gating (useful for overriding parent settings)
+     */
+    featureGate?: FeatureGate;
+    metadata?: Record<string, unknown>;
+}
+interface TextAttribute extends BaseAttribute<string> {
+    type: "text";
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+}
+type NumberUnit = "integer" | "decimal" | "percentage";
+interface NumberAttribute extends BaseAttribute<number> {
+    type: "number";
+    min?: number;
+    max?: number;
+    unit?: NumberUnit;
+    decimals?: number;
+}
+interface CheckboxAttribute extends BaseAttribute<boolean> {
+    type: "checkbox";
+}
+type DateFormat = "short" | "long" | "full" | "relative";
+type DateValue = string | "today";
+interface DateAttribute extends BaseAttribute<string> {
+    type: "date";
+    dateFormat?: DateFormat;
+    minDate?: DateValue;
+    maxDate?: DateValue;
+}
+interface Phone {
+    countryCode: CountryIso3;
+    phoneNumber: string;
+}
+interface PhoneAttribute extends BaseAttribute<Phone> {
+    type: "phone";
+    defaultCountryCode?: CountryIso3;
+}
+interface Currency {
+    code: CurrencyCode;
+    value: number;
+}
+interface CurrencyAttribute extends BaseAttribute<Currency> {
+    type: "currency";
+    defaultCurrency?: CurrencyCode;
+    allowedCurrencies?: CurrencyCode[];
+}
+/**
+ * StatusAttribute - For workflow states with semantic grouping (idle/in_progress/finished)
+ * Use this for: Task status, Order status, Project phases, Process states
+ * Use SelectAttribute for: Categories, Types, simple choices without workflow
+ */
+interface StatusAttribute extends BaseAttribute<string> {
+    type: "status";
+    options: Option[];
+}
+interface Location {
+    address?: string;
+    address2?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: CountryIso3;
+    latitude?: number;
+    longitude?: number;
+}
+type LocationGranularity = "full" | "address" | "city" | "state" | "country" | "coordinates";
+interface LocationAttribute extends BaseAttribute<Location> {
+    type: "location";
+    granularity: LocationGranularity;
+    enableAutocomplete?: boolean;
+    enableMap?: boolean;
+    defaultCountry?: CountryIso3;
+    allowedCountries?: CountryIso3[];
+    displayFormat?: "single_line" | "multi_line" | "compact";
+}
+/**
+ * SelectAttribute - For simple single-choice selection
+ * Use this for: Categories, Document types, Departments, Priorities
+ * Options can be grouped (e.g., countries by continent) but no workflow logic
+ */
+interface SelectAttribute extends BaseAttribute<string> {
+    type: "select";
+    options: Option[];
+}
+interface MultiselectAttribute extends BaseAttribute<string[]> {
+    type: "multiselect";
+    options: Option[];
+}
+interface FileAttribute extends BaseAttribute<string> {
+    type: "file";
+    maxFiles?: number;
+    maxSize?: number;
+    allowedTypes?: MimeType[] | readonly MimeType[];
+    multiple?: boolean;
+}
+interface UserAttribute extends BaseAttribute<string> {
+    type: "user";
+    allowedRoles?: string[];
+    multiple?: boolean;
+}
+/**
+ * Wildcard marker for universal relations (can link to any object)
+ * Use with `.toAny()` builder method
+ */
+declare const RELATION_TARGET_ANY: "*";
+/**
+ * Configuration for bilateral synchronization (bidirectional relations)
+ */
+interface BilateralConfig {
+    /** Target object containing the inverse attribute */
+    object: string;
+    /** Name of the inverse attribute */
+    attribute: string;
+    /** Optional cardinality override (inferred by default) */
+    cardinality?: "one" | "many";
+    /** When true, this side owns the storage direction for qualified properties.
+     *  Set to false on the inverse side (enriched at read time). */
+    storageOwner?: boolean;
+}
+/**
+ * Target object for a relation - defines which objects can be linked
+ */
+interface RelationTarget {
+    /** Object name (e.g., "companies", "contacts") or "*" for any object */
+    object: string;
+    /**
+     * Display template for the label using mustache-like syntax
+     * @example "{name}" or "{firstName} {lastName} — {email}"
+     */
+    displayTemplate?: string;
+    /**
+     * Optional filter to restrict available records
+     * @example { status: "active" }
+     */
+    filter?: Record<string, unknown>;
+}
+/**
+ * Base properties shared by both single and multi relation attributes
+ *
+ * Note: Deletion behavior is always "restrict" - if a record is referenced
+ * by other records, it cannot be deleted until those references are removed.
+ * This is enforced by RecordService.deleteRecord() which throws
+ * RecordReferencedError when attempting to delete a referenced record.
+ */
+interface RelationAttributeBase extends Omit<BaseAttribute<unknown>, "defaultValue"> {
+    type: "relation";
+    /** Target objects that can be linked */
+    targets: RelationTarget[];
+    /** Optional properties schema for qualified relations */
+    properties?: PropertySchema;
+    /** Configuration for bilateral synchronization (opt-in) */
+    bilateral?: BilateralConfig;
+}
+/**
+ * Single relation attribute (one-to-one or many-to-one)
+ * Stores a single record ID or null
+ */
+interface SingleRelationAttribute extends RelationAttributeBase {
+    cardinality: "one";
+    defaultValue?: string | null;
+}
+/**
+ * Multi relation attribute (one-to-many or many-to-many)
+ * Stores an array of record IDs
+ */
+interface MultiRelationAttribute extends RelationAttributeBase {
+    cardinality: "many";
+    defaultValue?: string[];
+    /** Minimum number of relations required */
+    minItems?: number;
+    /** Maximum number of relations allowed */
+    maxItems?: number;
+}
+/**
+ * RelationAttribute links to other objects/records
+ * Discriminated union by cardinality for type-safe value handling
+ *
+ * @example Single relation (many-to-one)
+ * ```typescript
+ * relation({ name: "company", label: "Company" })
+ *   .to("companies")
+ *   .required()
+ * // → Value: "rec-uuid-123" | null
+ * ```
+ *
+ * @example Multi relation (many-to-many)
+ * ```typescript
+ * relation({ name: "contacts", label: "Contacts" })
+ *   .to("contacts", { displayTemplate: "{firstName} {lastName}" })
+ *   .many()
+ *   .maxItems(5)
+ * // → Value: ["rec-1", "rec-2", ...]
+ * ```
+ *
+ * @example Polymorphic relation (multiple target objects)
+ * ```typescript
+ * relation({ name: "linked", label: "Linked Items" })
+ *   .to("companies")
+ *   .to("contacts")
+ *   .to("deals")
+ *   .many()
+ * // → Can link to records from any of these objects
+ * ```
+ */
+type RelationAttribute = SingleRelationAttribute | MultiRelationAttribute;
+/**
+ * Check if a relation attribute is universal (can link to any object)
+ * Universal relations have `targets: [{ object: "*" }]`
+ */
+declare function isUniversalRelation(attr: RelationAttribute): boolean;
+/**
+ * Check if a relation attribute has bilateral synchronization enabled
+ */
+declare function isBilateralRelation(attr: RelationAttribute): attr is RelationAttribute & {
+    bilateral: BilateralConfig;
+};
+/**
+ * Infer the cardinality of the inverse relation
+ * - one → many (contact.company ↔ company.contacts)
+ * - many → many (contact.tags ↔ tag.contacts)
+ */
+declare function inferInverseCardinality(cardinality: "one" | "many"): "one" | "many";
+interface TextAreaAttribute extends BaseAttribute<string> {
+    type: "textarea";
+}
+/**
+ * Available features for richtext editor
+ */
+type RichtextFeature = "headings" | "bold" | "italic" | "lists" | "links" | "images" | "codeBlocks" | "tables";
+/**
+ * RichtextAttribute - Rich text content using semantic markdown
+ *
+ * Stores content as semantic markdown string (with directives like :::callout).
+ * Parsed at runtime to Tiptap JSON for editing.
+ * Use this for: Notes, articles, descriptions, long-form content.
+ *
+ * @example
+ * ```typescript
+ * richtext({ name: "content", label: "Content" })
+ *   .features(["headings", "bold", "italic", "lists", "links"])
+ *   .required()
+ * ```
+ */
+interface RichtextAttribute extends BaseAttribute<string> {
+    type: "richtext";
+    /** Enabled features. If undefined, all features are enabled. */
+    features?: RichtextFeature[];
+}
+interface RatingAttribute extends BaseAttribute<number> {
+    type: "rating";
+    max?: number;
+    iconType?: "star" | "heart" | "thumbs" | "number";
+}
+/**
+ * Return type for formula expressions
+ */
+type FormulaReturnType = "text" | "number" | "boolean" | "date";
+/**
+ * FormulaAttribute - Computed value based on other attributes
+ *
+ * Formulas are calculated at read-time and are always read-only.
+ * Users cannot directly edit formula values.
+ *
+ * @example Simple calculation
+ * ```typescript
+ * formula({ name: "total", label: "Total" })
+ *   .expression("price * quantity")
+ *   .returns("number")
+ *   .decimals(2)
+ * ```
+ *
+ * @example With functions
+ * ```typescript
+ * formula({ name: "fullName", label: "Full Name" })
+ *   .expression("CONCAT(firstName, ' ', lastName)")
+ *   .returns("text")
+ * ```
+ */
+interface FormulaAttribute extends Omit<BaseAttribute<never>, "defaultValue" | "required"> {
+    type: "formula";
+    /** Expression to evaluate (e.g., "price * quantity") */
+    expression: string;
+    /** Expected return type for formatting */
+    returnType: FormulaReturnType;
+    /** Decimal places for number results */
+    decimals?: number;
+    /** Whether to allow relation references in the expression (e.g., "company.name") */
+    allowRelations?: boolean;
+    /** Formula is always not required (read-only) */
+    required: false;
+}
+/**
+ * Aggregation functions for rollup attributes
+ *
+ * Categories:
+ * - Numeric (sum, avg): Only for number, currency, rating types
+ * - Date (earliest, latest): Only for date type
+ * - Count (count, countValues, countUniqueValues, countEmpty): Universal
+ * - Percent (percentEmpty, percentNotEmpty): Universal
+ * - Lookup (original): Returns all values as array, rendered as target type
+ */
+type RollupFunction = "sum" | "avg" | "earliest" | "latest" | "count" | "countValues" | "countUniqueValues" | "countEmpty" | "percentEmpty" | "percentNotEmpty" | "original";
+/**
+ * RollupAttribute - Aggregates values from related records
+ *
+ * Rollups are calculated and stored (denormalized) for performance.
+ * They are automatically recalculated when related records change.
+ * Users cannot directly edit rollup values.
+ *
+ * @example Sum of related amounts
+ * ```typescript
+ * rollup({ name: "totalOrders", label: "Total Orders" })
+ *   .from("orders")           // relation attribute name
+ *   .aggregate("amount")      // target attribute to sum
+ *   .using("sum")
+ *   .decimals(2)
+ * ```
+ *
+ * @example Count of related records
+ * ```typescript
+ * rollup({ name: "orderCount", label: "Number of Orders" })
+ *   .from("orders")
+ *   .using("count")
+ * ```
+ */
+interface RollupAttribute extends Omit<BaseAttribute<never>, "defaultValue" | "required"> {
+    type: "rollup";
+    /** Name of the relation attribute on this object */
+    relationAttribute: string;
+    /**
+     * Dot notation path for multi-level traversal (Phase 4+)
+     * @example "orders.items" - traverse through orders to items
+     */
+    relationPath?: string;
+    /** Attribute name on the target object to aggregate */
+    targetAttribute: string;
+    /** Aggregation function to apply */
+    function: RollupFunction;
+    /** Decimal places for numeric results */
+    decimals?: number;
+    /** Rollup is always not required (read-only) */
+    required: false;
+    /**
+     * Cached type of the target attribute for display purposes
+     * Used when function="original" to render values as the target type
+     */
+    targetAttributeType?: AttributeType;
+    /**
+     * Cached options from target attribute (for select/status/multiselect display)
+     * Required when function="original" and target is a select-like type
+     */
+    targetAttributeOptions?: Option[];
+}
+/**
+ * DocumentAttribute - References one or multiple documents with templates.
+ *
+ * Unlike FileAttribute which stores raw file references, DocumentAttribute
+ * provides structured document handling with templates, multi-file support,
+ * and automatic processing (OCR, signature, identity verification).
+ *
+ * @example Single document with template choice
+ * ```typescript
+ * document({ name: "identityDocument", label: "Pièce d'identité" })
+ *   .templates(["french_id_card", "passport"])
+ *   .autoProcess()
+ *   .required()
+ * ```
+ *
+ * @example Multiple documents
+ * ```typescript
+ * document({ name: "contracts", label: "Contrats" })
+ *   .multiple()
+ *   .maxDocuments(10)
+ * ```
+ */
+interface DocumentAttribute extends BaseAttribute<string | string[]> {
+    type: "document";
+    /**
+     * Allow multiple documents.
+     * If true, value is string[] (document IDs).
+     * If false/undefined, value is string (single document ID).
+     */
+    multiple?: boolean;
+    /**
+     * Maximum number of documents when multiple: true.
+     */
+    maxDocuments?: number;
+    /**
+     * Automatically trigger processing (OCR, verification) on upload.
+     */
+    autoProcess?: boolean;
+}
+type Attribute = TextAttribute | TextAreaAttribute | RichtextAttribute | NumberAttribute | CheckboxAttribute | DateAttribute | PhoneAttribute | CurrencyAttribute | StatusAttribute | LocationAttribute | SelectAttribute | MultiselectAttribute | FileAttribute | UserAttribute | RelationAttribute | RatingAttribute | FormulaAttribute | RollupAttribute | DocumentAttribute;
+/**
+ * Attribute types that are not sortable by default.
+ * These types have complex/binary values without a meaningful natural order.
+ */
+declare const NON_SORTABLE_TYPES: ReadonlySet<AttributeType>;
+/**
+ * Check if an attribute supports sorting based on its type.
+ */
+declare function isAttributeSortable(attr: {
+    type: AttributeType;
+}): boolean;
+
+/** 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;
+
+/**
+ * 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;
+}
+/**
+ * Source for an assignment value.
+ *
+ * - `expression`: mustache template resolved at execution (text-like attrs only).
+ *   Uses `{{ slotId.attribute }}` dot notation, resolved via `renderLabelExpression`.
+ * - `slot-ref`: reference to a slot's record for relation attributes.
+ *   Resolved at persistence time via `$slot:slotId` placeholder.
+ * - `static`: fixed value set directly.
+ */
+type AssignmentSource = {
+    type: "expression";
+    template: string;
+} | {
+    type: "slot-ref";
+    slotId: string;
+    properties?: Record<string, unknown>;
+} | {
+    type: "static";
+    value: unknown;
+};
+/**
+ * Single assignment: set one attribute on the target slot.
+ */
+interface AssignmentMapping {
+    /** Attribute name on the target slot's object */
+    targetAttribute: string;
+    /** Source of the value */
+    source: AssignmentSource;
+}
+/**
+ * Assign node: set values on a target slot's record.
+ * All assignments target the same slot, selected at the node level.
+ *
+ * @example
+ * ```typescript
+ * const node: AssignNode = {
+ *   type: "assign",
+ *   id: "assign-client-data",
+ *   label: "Set Client Data",
+ *   targetSlotId: "client",
+ *   assignments: [
+ *     { targetAttribute: "company", source: { type: "slot-ref", slotId: "company" } },
+ *     { targetAttribute: "fullName", source: { type: "expression", template: "{{ client.firstName }} {{ client.lastName }}" } },
+ *     { targetAttribute: "status", source: { type: "static", value: "active" } },
+ *   ],
+ *   next: "end"
+ * };
+ * ```
+ */
+interface AssignNode extends BaseNode {
+    type: "assign";
+    label: string;
+    description?: string;
+    /** Single target slot for all assignments */
+    targetSlotId: string;
+    /** List of attribute assignments */
+    assignments: AssignmentMapping[];
+    next?: string | null;
+}
+/**
+ * AI action config — discriminated union for different AI capabilities.
+ *
+ * @example Document generation
+ * ```typescript
+ * const action: AIActionConfig = {
+ *   type: "document-generation",
+ *   templateId: "template-contract-v1",
+ *   inputSlotIds: ["client", "company"],
+ *   targetSlotIds: ["client"],
+ *   outputFormat: "pdf",
+ *   aiInstructions: "Generate a professional contract",
+ * };
+ * ```
+ */
+type AIActionConfig = DocumentGenerationAction | CodeExecutionAction;
+/**
+ * AI action type discriminant
+ */
+type AIActionType = AIActionConfig["type"];
+/**
+ * Generate a document (PDF/DOCX) from a template using an AI agent session.
+ */
+interface DocumentGenerationAction {
+    type: "document-generation";
+    /** File ID of the uploaded DOCX template in storage */
+    templateId: string;
+    /** Slots whose data is context for the AI */
+    inputSlotIds: string[];
+    /** Slots to attach the generated document to */
+    targetSlotIds: string[];
+    /** Output format */
+    outputFormat: "pdf" | "docx";
+    /** Instructions for the AI agent on how to generate content */
+    aiInstructions?: string;
+}
+/**
+ * Execute code in a sandbox without AI (mode "code").
+ */
+interface CodeExecutionAction {
+    type: "code-execution";
+    /** Code to execute (may contain Mustache expressions resolved from slots) */
+    code: string;
+    language: "javascript" | "typescript" | "python";
+    /** Slots injected as JSON environment variables */
+    inputSlotIds?: string[];
+    /** Variable name to capture stdout into the execution context */
+    outputVariable?: string;
+    /** Packages to install before execution */
+    packages?: string[];
+}
+/**
+ * AI node — runs an AI action (document generation, code execution, etc.)
+ *
+ * @example
+ * ```typescript
+ * const node: AINode = {
+ *   type: "ai",
+ *   id: "generate-contract",
+ *   label: "Generate Contract",
+ *   action: {
+ *     type: "document-generation",
+ *     templateId: "template-contract-v1",
+ *     inputSlotIds: ["client", "company"],
+ *     targetSlotIds: ["client"],
+ *     outputFormat: "pdf",
+ *   },
+ *   next: "end-success",
+ * };
+ * ```
+ */
+interface AINode extends BaseNode {
+    type: "ai";
+    label: string;
+    description?: string;
+    action: AIActionConfig;
+    /** Timeout in milliseconds (default: 120_000) */
+    timeoutMs?: number;
+    next?: 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 | AssignNode | AINode | 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 AssignNode
+ */
+declare function isAssignNode(node: WorkflowNode): node is AssignNode;
+/**
+ * Check if a node is an AINode
+ */
+declare function isAINode(node: WorkflowNode): node is AINode;
+/**
+ * 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];
+
+/**
+ * Format Zod validation errors into a consistent structure.
+ * This eliminates code duplication across multiple validation functions.
+ */
+declare function formatZodErrors(error: z.ZodError): Array<{
+    path: string[];
+    message: string;
+}>;
+/**
+ * Validation messages for Zod validators.
+ * All functions receive the full Attribute to access label, type, etc.
+ * Can be customized for i18n support.
+ */
+interface ValidationMessages {
+    required: (attr: Attribute) => string;
+    invalidType: (attr: Attribute, expected: string) => string;
+    minLength: (attr: Attribute, min: number) => string;
+    maxLength: (attr: Attribute, max: number) => string;
+    invalidPattern: (attr: Attribute) => string;
+    minValue: (attr: Attribute, min: number) => string;
+    maxValue: (attr: Attribute, max: number) => string;
+    mustBeInteger: (attr: Attribute) => string;
+    invalidDate: (attr: Attribute) => string;
+    invalidOption: (attr: Attribute, options: string[]) => string;
+    invalidId: (attr: Attribute) => string;
+    minItems: (attr: Attribute, min: number) => string;
+    maxItems: (attr: Attribute, max: number) => string;
+    invalidRichtext: (attr: Attribute) => string;
+    invalidPhone: (attr: Attribute) => string;
+    invalidCurrency: (attr: Attribute) => string;
+    invalidLocation: (attr: Attribute) => string;
+}
+declare const DEFAULT_VALIDATION_MESSAGES: ValidationMessages;
+/**
+ * Text attribute config schema
+ */
+declare const textConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    pattern: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Textarea attribute config schema
+ */
+declare const textareaConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Richtext attribute config schema
+ */
+declare const richtextConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    features: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        headings: "headings";
+        bold: "bold";
+        italic: "italic";
+        lists: "lists";
+        links: "links";
+        images: "images";
+        codeBlocks: "codeBlocks";
+        tables: "tables";
+    }>>>;
+}, z.core.$strip>;
+/**
+ * Number attribute config schema
+ */
+declare const numberConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodOptional<z.ZodEnum<{
+        percentage: "percentage";
+        integer: "integer";
+        decimal: "decimal";
+    }>>;
+    decimals: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Checkbox attribute config schema
+ */
+declare const checkboxConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Date attribute config schema
+ */
+declare const dateConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dateFormat: z.ZodOptional<z.ZodEnum<{
+        short: "short";
+        long: "long";
+        full: "full";
+        relative: "relative";
+    }>>;
+    minDate: z.ZodOptional<z.ZodString>;
+    maxDate: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Phone attribute config schema
+ */
+declare const phoneConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    defaultCountryCode: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Currency attribute config schema
+ */
+declare const currencyConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    defaultCurrency: z.ZodOptional<z.ZodString>;
+    allowedCurrencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Status attribute config schema
+ */
+declare const statusConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodEnum<{
+            idle: "idle";
+            in_progress: "in_progress";
+            finished: "finished";
+        }>>;
+        inverse: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Location attribute config schema
+ */
+declare const locationConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    granularity: z.ZodEnum<{
+        full: "full";
+        address: "address";
+        city: "city";
+        state: "state";
+        country: "country";
+        coordinates: "coordinates";
+    }>;
+    enableAutocomplete: z.ZodOptional<z.ZodBoolean>;
+    enableMap: z.ZodOptional<z.ZodBoolean>;
+    defaultCountry: z.ZodOptional<z.ZodString>;
+    allowedCountries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    displayFormat: z.ZodOptional<z.ZodEnum<{
+        single_line: "single_line";
+        multi_line: "multi_line";
+        compact: "compact";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Select attribute config schema
+ */
+declare const selectConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodEnum<{
+            idle: "idle";
+            in_progress: "in_progress";
+            finished: "finished";
+        }>>;
+        inverse: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Multiselect attribute config schema
+ */
+declare const multiselectConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodEnum<{
+            idle: "idle";
+            in_progress: "in_progress";
+            finished: "finished";
+        }>>;
+        inverse: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * File attribute config schema
+ */
+declare const fileConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    maxFiles: z.ZodOptional<z.ZodNumber>;
+    maxSize: z.ZodOptional<z.ZodNumber>;
+    allowedTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    multiple: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * User attribute config schema
+ */
+declare const userConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    allowedRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    multiple: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Relation attribute config schema
+ */
+declare const relationConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    targets: z.ZodArray<z.ZodObject<{
+        object: z.ZodString;
+        displayTemplate: z.ZodOptional<z.ZodString>;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    minItems: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Rating attribute config schema
+ */
+declare const ratingConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    max: z.ZodOptional<z.ZodNumber>;
+    iconType: z.ZodOptional<z.ZodEnum<{
+        number: "number";
+        heart: "heart";
+        star: "star";
+        thumbs: "thumbs";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Formula attribute config schema
+ */
+declare const formulaConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    expression: z.ZodString;
+    returnType: z.ZodEnum<{
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+    }>;
+    decimals: z.ZodOptional<z.ZodNumber>;
+    allowRelations: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Rollup attribute config schema
+ */
+declare const rollupConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    relationAttribute: z.ZodOptional<z.ZodString>;
+    relationPath: z.ZodOptional<z.ZodString>;
+    targetAttribute: z.ZodString;
+    function: z.ZodEnum<{
+        sum: "sum";
+        avg: "avg";
+        earliest: "earliest";
+        latest: "latest";
+        count: "count";
+        countValues: "countValues";
+        countUniqueValues: "countUniqueValues";
+        countEmpty: "countEmpty";
+        percentEmpty: "percentEmpty";
+        percentNotEmpty: "percentNotEmpty";
+        original: "original";
+    }>;
+    decimals: z.ZodOptional<z.ZodNumber>;
+    targetAttributeType: z.ZodOptional<z.ZodString>;
+    targetAttributeOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodEnum<{
+            idle: "idle";
+            in_progress: "in_progress";
+            finished: "finished";
+        }>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * Document attribute config schema
+ */
+declare const documentConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    multiple: z.ZodOptional<z.ZodBoolean>;
+    maxDocuments: z.ZodOptional<z.ZodNumber>;
+    autoProcess: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Map of attribute type to config schema
+ */
+declare const attributeConfigSchemas: Record<AttributeType, z.ZodObject<z.ZodRawShape>>;
+/**
+ * Get the config schema for a specific attribute type
+ */
+declare function getAttributeConfigSchema(type: AttributeType): z.ZodObject<z.ZodRawShape>;
+/**
+ * Validate attribute config for a specific type
+ * Returns the validated config with only allowed properties
+ */
+declare function validateAttributeConfig(type: AttributeType, config: Record<string, unknown>): {
+    success: true;
+    data: Record<string, unknown>;
+} | {
+    success: false;
+    errors: string[];
+};
+/**
+ * Validate and strip unknown properties from attribute config
+ * This ensures only allowed properties are stored in the database
+ */
+declare function parseAttributeConfig(type: AttributeType, config: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Safely parse attribute config, returning undefined for invalid configs
+ */
+declare function safeParseAttributeConfig(type: AttributeType, config: Record<string, unknown>): Record<string, unknown> | undefined;
+/**
+ * Create a Zod schema for a text attribute
+ */
+declare function createTextValidator(attr: TextAttribute, messages?: ValidationMessages): z.ZodString;
+/**
+ * Create a Zod schema for a number attribute
+ */
+declare function createNumberValidator(attr: NumberAttribute, messages?: ValidationMessages): z.ZodNumber;
+/**
+ * Create a Zod schema for a checkbox attribute
+ */
+declare function createCheckboxValidator(_attr: CheckboxAttribute, _messages?: ValidationMessages): z.ZodBoolean;
+/**
+ * Create a Zod schema for a date attribute
+ */
+declare function createDateValidator(attr: DateAttribute, messages?: ValidationMessages): z.ZodTypeAny;
+/**
+ * Create a Zod schema for a phone attribute.
+ *
+ * Validates:
+ * - countryCode is a valid ISO3 country code
+ * - phoneNumber contains valid digits for the given country
+ *
+ * Transforms:
+ * - Normalizes phoneNumber to national digits without trunk prefix
+ */
+declare function createPhoneValidator(attr: PhoneAttribute, messages?: ValidationMessages): z.ZodType<{
+    countryCode: string;
+    phoneNumber: string;
+}>;
+/**
+ * Create a Zod schema for a currency attribute
+ */
+declare function createCurrencyValidator(attr: CurrencyAttribute, messages?: ValidationMessages): z.ZodType<{
+    code: string;
+    value: number;
+}>;
+/**
+ * Create a Zod schema for a status attribute
+ */
+declare function createStatusValidator(attr: StatusAttribute, messages?: ValidationMessages): z.ZodEnum<Readonly<Record<string, string>>>;
+/**
+ * Create a Zod schema for a select attribute
+ */
+declare function createSelectValidator(attr: SelectAttribute, messages?: ValidationMessages): z.ZodEnum<Readonly<Record<string, string>>>;
+/**
+ * Create a Zod schema for a multiselect attribute
+ */
+declare function createMultiselectValidator(attr: MultiselectAttribute, messages?: ValidationMessages): z.ZodArray<z.ZodEnum<Readonly<Record<string, string>>>>;
+/**
+ * Create a Zod schema for a location attribute
+ */
+type LocationShape = {
+    address?: string;
+    address2?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    latitude?: number;
+    longitude?: number;
+};
+declare function createLocationValidator(attr: LocationAttribute, messages?: ValidationMessages): z.ZodType<LocationShape>;
+/**
+ * Create a Zod schema for a file attribute
+ * Supports both single file (UUID) and multiple files (array of UUIDs)
+ */
+declare function createFileValidator(attr: FileAttribute, messages?: ValidationMessages): z.ZodTypeAny;
+/**
+ * Create a Zod schema for a user attribute
+ * Supports both single user (UUID) and multiple users (array of UUIDs)
+ */
+declare function createUserValidator(attr: UserAttribute, messages?: ValidationMessages): z.ZodTypeAny;
+/**
+ * Create a Zod schema for a single relation attribute (cardinality: "one")
+ * Supports hybrid format `{ id, props }` from qualified relations.
+ * IMPORTANT: Validates the ID but preserves the original format (keeps props).
+ */
+declare function createSingleRelationValidator(attr: SingleRelationAttribute, messages?: ValidationMessages): z.ZodTypeAny;
+/**
+ * Create a Zod schema for a multi relation attribute (cardinality: "many")
+ * Supports hybrid format arrays with `{ id, props }` items from qualified relations.
+ * IMPORTANT: Validates the IDs but preserves the original format (keeps props).
+ */
+declare function createMultiRelationValidator(attr: MultiRelationAttribute, messages?: ValidationMessages): z.ZodTypeAny;
+/**
+ * Create a Zod schema for a relation attribute
+ * Dispatches to single or multi validator based on cardinality
+ */
+declare function createRelationValidator(attr: RelationAttribute, messages?: ValidationMessages): z.ZodTypeAny;
+/**
+ * Create a Zod schema for a rating attribute
+ */
+declare function createRatingValidator(attr: RatingAttribute, messages?: ValidationMessages): z.ZodNumber;
+/**
+ * Create a Zod schema for a formula attribute.
+ * Formula attributes are read-only (computed at runtime).
+ * They accept any value during validation but are ignored during record creation/update.
+ */
+declare function createFormulaValidator(_attr: FormulaAttribute, _messages?: ValidationMessages): z.ZodUnknown;
+/**
+ * Create a Zod schema for a rollup attribute.
+ * Rollup attributes are read-only (computed from related records).
+ * They accept any value during validation but are ignored during record creation/update.
+ */
+declare function createRollupValidator(_attr: RollupAttribute, _messages?: ValidationMessages): z.ZodUnknown;
+/**
+ * Create a Zod schema for a textarea attribute.
+ * Validates that the value is a string.
+ */
+declare function createTextAreaValidator(_attr: TextAreaAttribute, _messages?: ValidationMessages): z.ZodString;
+/**
+ * Create a Zod schema for a richtext attribute.
+ * Validates semantic markdown content as a string.
+ *
+ * @example Valid richtext content (semantic markdown)
+ * ```typescript
+ * `# Heading
+ *
+ * Some paragraph text.
+ *
+ * :::callout{variant="info"}
+ * This is a callout block
+ * :::
+ * `
+ * ```
+ */
+declare function createRichtextValidator(attr: RichtextAttribute, messages?: ValidationMessages): z.ZodTypeAny;
+/**
+ * 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>>;
+/**
+ * Validation result
+ */
+interface ValidationResult {
+    success: boolean;
+    data?: Record<string, unknown>;
+    errors?: Array<{
+        path: string[];
+        message: string;
+    }>;
+}
+/**
+ * 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>;
+/**
+ * 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 in draft mode.
+ * - All attributes are treated as optional (no required validation)
+ * - Provided values are still validated for format/type correctness
+ *
+ * Use this when creating records that may be incomplete (drafts).
+ *
+ * @example
+ * ```typescript
+ * const result = validateDraft(PRODUCT, { name: "Draft" });
+ * // → success even if "price" is required but missing
+ *
+ * const result2 = validateDraft(PRODUCT, { price: -10 });
+ * // → fails because price must be >= 0 (format validation still applies)
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```typescript
+ * const missing = getMissingRequiredAttributes(PRODUCT, { name: "Test" });
+ * // → [priceAttribute, statusAttribute] if price and status are required but missing
+ * ```
+ */
+declare function getMissingRequiredAttributes(objectDef: ObjectDefinition, data: Record<string, unknown>): Attribute[];
+/**
+ * Check if a record is complete (all required attributes have valid values).
+ *
+ * @returns `true` if all required values are present and valid, `false` otherwise
+ */
+declare function isRecordComplete(objectDef: ObjectDefinition, data: Record<string, unknown>): boolean;
+/**
+ * Compute the completion status of a record based on its data.
+ *
+ * - `"complete"`: All required values are present and valid
+ * - `"draft"`: One or more required values are missing or invalid
+ *
+ * This function is used to dynamically determine the status when
+ * creating or updating records.
+ *
+ * @example
+ * ```typescript
+ * const status = computeRecordStatus(PRODUCT, {
+ *   name: "Nike Air Max",
+ *   price: 129.99,
+ *   status: "active"
+ * });
+ * // → "complete"
+ *
+ * const status2 = computeRecordStatus(PRODUCT, { name: "Draft Product" });
+ * // → "draft" (missing required fields)
+ * ```
+ */
+declare function computeRecordStatus(objectDef: ObjectDefinition, data: Record<string, unknown>): CompletionStatus;
+
+export { type RelationAttribute as $, type Attribute as A, type FeatureGate as B, type ConfigOverrides as C, type DateAttribute as D, type TextAttribute as E, type FilterState as F, type TextAreaAttribute as G, type RichtextAttribute as H, type InstanceStatus as I, type RichtextFeature as J, type CheckboxAttribute as K, type LocationGranularity as L, type MultiselectAttribute as M, type NumberAttribute as N, type ObjectRecord as O, type PendingAction as P, type PhoneAttribute as Q, type RelationFieldConfig as R, type SortRule as S, type Timestamps as T, type UserAttribute as U, type ViewType as V, type WorkflowNode as W, type CurrencyAttribute as X, type Option as Y, type LocationAttribute as Z, type FileAttribute as _, type FormNode as a, type DocumentGenerationAction as a$, type RatingAttribute as a0, type BilateralConfig as a1, type SingleRelationAttribute as a2, type MultiRelationAttribute as a3, type RelationTarget as a4, type FormulaReturnType as a5, type RollupFunction as a6, type MigrationDefinition as a7, type ObjectDefinition as a8, type DetailViewLayout as a9, type AINode as aA, type ActivityTab as aB, type AdvancedFilterState as aC, type AssignNode as aD, type AssignmentMapping as aE, type AssignmentSource as aF, type AttributeGroup as aG, type BaseAttribute as aH, type BufferedRecord as aI, type BuiltInTransform as aJ, type CalendarViewConfig as aK, type CalendarViewDefinition as aL, type CanvasViewport as aM, type CheckboxFilterOperator as aN, type CodeExecutionAction as aO, type ConditionNode as aP, type ConditionOperator as aQ, type CurrencyFilterValue as aR, type CustomTab as aS, DEFAULT_RETENTION_POLICY as aT, DEFAULT_THEME as aU, DEFAULT_VALIDATION_MESSAGES as aV, type DateFilterOperator as aW, type DateFormat as aX, type DateValue as aY, type DetailViewConfig as aZ, type DisplayRecord as a_, type SidePanelConfig as aa, type Field as ab, type AttributeGroupField as ac, type FieldGroup as ad, type RelationGroup as ae, type Group as af, type TableTab as ag, type CreateMode as ah, type DetailViewDefinition as ai, type Tab as aj, type ListViewDefinition as ak, type SlotMode as al, type FlowFieldsRow as am, type ConditionGroup as an, type ConditionRule as ao, type FlagValueType as ap, type FeatureFlagDefinition as aq, type FlagLevel as ar, type FeatureFlagsRepository as as, type StaticFlagDefault as at, type ResolvedFlag as au, type ViewDefinition as av, type ListViewConfig as aw, type ListViewTab as ax, type AIActionConfig as ay, type AIActionType as az, type WorkflowNodeType as b, type StatusGroup as b$, type DocumentsTab as b0, type EndNode as b1, type ExtendedFilterRule as b2, FORBIDDEN_PROPERTY_TYPES as b3, type FeatureFlagsConfig as b4, type FilterCombinator as b5, type FilterGroup as b6, type FilterOperator as b7, type FilterRule as b8, type FilterValue as b9, type NumberFilterOperator as bA, type NumberUnit as bB, OPERATORS_BY_TYPE as bC, type ObjectAttribute as bD, type OptionPropertyAttribute as bE, type PhoneFilterValue as bF, type PropertyAttribute as bG, type PropertySchema as bH, type PropertyType as bI, type QueryState as bJ, RELATION_TARGET_ANY as bK, RESERVED_ATTRIBUTE_NAMES as bL, type RecordPatch as bM, type RelationBuffer as bN, type RelationFilterOperator as bO, type RelationQualifierPatch as bP, type RelationSource as bQ, type RelativeDateValue as bR, type ReservedAttributeName as bS, type RetentionPolicy as bT, type RichtextTab as bU, SYSTEM_FIELD_NAMES as bV, type SchemaOperation as bW, type SchemaTransform as bX, type SelectFilterOperator as bY, type SortDirection as bZ, type StartNode as b_, type FlagOverride as ba, type FlowDefinition as bb, type FlowPage as bc, type FlowRelation as bd, type FlowRow as be, type FlowRowField as bf, type FlowRowType as bg, type FlowSlot as bh, type FlowStatus as bi, type FlowsTab as bj, type ForbiddenPropertyType as bk, type FormDensity as bl, type FormFieldRef as bm, type FormTab as bn, type GalleryViewConfig as bo, type GalleryViewDefinition as bp, type GeneratedDocument as bq, type InverseSource as br, type ListViewLayout as bs, type MigrationError as bt, type MigrationPreview as bu, type MultiselectFilterOperator as bv, NON_SORTABLE_TYPES as bw, NO_VALUE_OPERATORS as bx, type NoValueOperator as by, type NodePosition as bz, type FlowHeadingRow as c, isAINode as c$, type SystemFieldName as c0, type TabType as c1, type TableSource as c2, type TextFilterOperator as c3, type ThemeColors as c4, type ThemeLogo as c5, type ThemeTypography as c6, type TimelineViewConfig as c7, type TimelineViewDefinition as c8, type TransformSource as c9, createPhoneValidator as cA, createRatingValidator as cB, createRelationValidator as cC, createRichtextValidator as cD, createRollupValidator as cE, createSelectValidator as cF, createSingleRelationValidator as cG, createStartTransition as cH, createStatusValidator as cI, createTextAreaValidator as cJ, createTextValidator as cK, createUserValidator as cL, currencyConfigSchema as cM, dateConfigSchema as cN, documentConfigSchema as cO, eq as cP, fileConfigSchema as cQ, formatZodErrors as cR, formulaConfigSchema as cS, generateCssVariables as cT, getAttributeConfigSchema as cU, getContextValue as cV, getMissingRequiredAttributes as cW, getRollupFilterOperators as cX, hasOptions as cY, inValues as cZ, inferInverseCardinality as c_, type ValidationMessages as ca, type ValidationResult as cb, type ViewOperation as cc, type ViewOverlay as cd, type ViewTransform as ce, type WorkflowError as cf, type WorkflowInstance as cg, and as ch, attributeConfigSchemas as ci, canResumeInstance as cj, checkboxConfigSchema as ck, computeRecordStatus as cl, createAttributeValidator as cm, createCheckboxValidator as cn, createCurrencyValidator as co, createDateValidator as cp, createDraftValidator as cq, createEmptyContext as cr, createFileValidator as cs, createFormAttributeValidator as ct, createFormulaValidator as cu, createLocationValidator as cv, createMultiRelationValidator as cw, createMultiselectValidator as cx, createNumberValidator as cy, createObjectValidator as cz, type FlowSeparatorRow as d, validateDraft as d$, isActivityTab as d0, isAdvancedFormNode as d1, isAssignNode as d2, isAttributeSortable as d3, isBilateralRelation as d4, isCalendarView as d5, isConditionGroup as d6, isConditionNode as d7, isConditionRule as d8, isCustomTab as d9, isSystemWorkflow as dA, isTableTab as dB, isTimelineView as dC, isUniversalRelation as dD, isWorkflowDefinition as dE, isWorkflowPublished as dF, locationConfigSchema as dG, mergeWithDefaults as dH, multiselectConfigSchema as dI, neq as dJ, numberConfigSchema as dK, or as dL, parseAttributeConfig as dM, phoneConfigSchema as dN, ratingConfigSchema as dO, relationConfigSchema as dP, richtextConfigSchema as dQ, rollupConfigSchema as dR, safeParseAttributeConfig as dS, selectConfigSchema as dT, setContextValue as dU, statusConfigSchema as dV, textConfigSchema as dW, textareaConfigSchema as dX, userConfigSchema as dY, validateAttribute as dZ, validateAttributeConfig as d_, isDetailView as da, isDocumentsTab as db, isEndNode as dc, isFieldGroup as dd, isFlowDefinition as de, isFlowFieldsRow as df, isFlowPublished as dg, isFlowRelationListRow as dh, isFlowsTab as di, isFormNode as dj, isFormTab as dk, isGalleryView as dl, isInstanceTerminal as dm, isInstanceWaiting as dn, isInverseSourceTab as dp, isLayoutRow as dq, isListView as dr, isNoValueOperator as ds, isRecordComplete as dt, isRelationGroup as du, isRelationSourceTab as dv, isRichtextTab as dw, isSimpleFormNode as dx, isStartNode as dy, isSystemFlow as dz, type FlowTextRow as e, validateDraftOrThrow as e0, validateObject as e1, validateObjectOrThrow as e2, type FlowRelationListRow as f, type WorkflowSlot as g, type WorkflowTheme as h, type RelationBufferMap as i, type AttributeType as j, type ViewConfig as k, type WorkflowStatus as l, type WorkflowLayout as m, type WorkflowConfig as n, type WorkflowDefinition as o, type WorkflowExecutionContext as p, type WorkflowTransition as q, type Location as r, type FormulaAttribute as s, type RollupAttribute as t, type CompletionStatus as u, type StatusAttribute as v, type SelectAttribute as w, type Phone as x, type Currency as y, type DocumentAttribute as z };