@stndrds/schema 1.0.0-alpha.294 → 1.0.0-alpha.69

package/dist/validators-B6L_hVBw.d.ts

@@ -0,0 +1,1564 @@
+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;
+    }): 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[];
+}
+
+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;
+}
+/**
+ * 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 with fixed template
+ * ```typescript
+ * document({ name: "contracts", label: "Contrats" })
+ *   .template("signable_contract")
+ *   .multiple()
+ *   .maxDocuments(10)
+ * ```
+ */
+interface DocumentAttribute extends BaseAttribute<string | string[]> {
+    type: "document";
+    /**
+     * Single template ID (strict mode).
+     * If set, only documents using this template can be attached.
+     */
+    templateId?: string;
+    /**
+     * Multiple allowed template IDs.
+     * User can choose which template to use when uploading.
+     */
+    allowedTemplates?: string[];
+    /**
+     * 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;
+
+/**
+ * Timestamps for tracking creation and updates
+ */
+interface Timestamps {
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Sharing mode for multi-tenant object access.
+ *
+ * - `private`: Object is only visible to its owner tenant (default)
+ * - `shared`: Object is readable by all tenants, but only writable by the owner tenant
+ *
+ * Records inherit the sharing mode of their parent object.
+ */
+type SharingMode = "private" | "shared";
+/**
+ * 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;
+    /**
+     * Sharing mode for multi-tenant access.
+     * - `private`: Only visible to the owner tenant (default)
+     * - `shared`: Readable by all tenants, writable only by the owner
+     *
+     * Records inherit the sharing mode of their parent object.
+     * @default "private"
+     */
+    sharingMode?: SharingMode;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * 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;
+}
+/**
+ * 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"];
+/**
+ * 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<{
+            in_progress: "in_progress";
+            idle: "idle";
+            finished: "finished";
+        }>>;
+    }, 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<{
+            in_progress: "in_progress";
+            idle: "idle";
+            finished: "finished";
+        }>>;
+    }, 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<{
+            in_progress: "in_progress";
+            idle: "idle";
+            finished: "finished";
+        }>>;
+    }, 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<{
+            in_progress: "in_progress";
+            idle: "idle";
+            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>>;
+    templateId: z.ZodOptional<z.ZodString>;
+    allowedTemplates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    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.
+ */
+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.
+ */
+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 { RESERVED_ATTRIBUTE_NAMES as $, type Attribute as A, type BilateralConfig as B, type CheckboxAttribute as C, type DateAttribute as D, type BaseAttribute as E, type FeatureGate as F, type NumberUnit as G, type DateFormat as H, type DateValue as I, type Currency as J, type Location as K, type LocationAttribute as L, type MultiselectAttribute as M, type NumberAttribute as N, type Option as O, type Phone as P, type LocationGranularity as Q, type RichtextAttribute as R, type StatusAttribute as S, type TextAttribute as T, type UserAttribute as U, RELATION_TARGET_ANY as V, isUniversalRelation as W, isBilateralRelation as X, inferInverseCardinality as Y, type FlagOverride as Z, type FeatureFlagsConfig as _, type DocumentAttribute as a, type ValidationResult as a$, SYSTEM_FIELD_NAMES as a0, type ReservedAttributeName as a1, type SystemFieldName as a2, type Timestamps as a3, type SharingMode as a4, type ObjectAttribute as a5, type CompletionStatus as a6, type ObjectRecord as a7, type PropertyType as a8, FORBIDDEN_PROPERTY_TYPES as a9, getAttributeConfigSchema as aA, validateAttributeConfig as aB, parseAttributeConfig as aC, safeParseAttributeConfig as aD, createTextValidator as aE, createNumberValidator as aF, createCheckboxValidator as aG, createDateValidator as aH, createPhoneValidator as aI, createCurrencyValidator as aJ, createStatusValidator as aK, createSelectValidator as aL, createMultiselectValidator as aM, createLocationValidator as aN, createFileValidator as aO, createUserValidator as aP, createSingleRelationValidator as aQ, createMultiRelationValidator as aR, createRelationValidator as aS, createRatingValidator as aT, createFormulaValidator as aU, createRollupValidator as aV, createTextAreaValidator as aW, createRichtextValidator as aX, createAttributeValidator as aY, createFormAttributeValidator as aZ, createObjectValidator as a_, type ForbiddenPropertyType as aa, type PropertyAttribute as ab, type PropertySchema as ac, formatZodErrors as ad, type ValidationMessages as ae, DEFAULT_VALIDATION_MESSAGES as af, textConfigSchema as ag, textareaConfigSchema as ah, richtextConfigSchema as ai, numberConfigSchema as aj, checkboxConfigSchema as ak, dateConfigSchema as al, phoneConfigSchema as am, currencyConfigSchema as an, statusConfigSchema as ao, locationConfigSchema as ap, selectConfigSchema as aq, multiselectConfigSchema as ar, fileConfigSchema as as, userConfigSchema as at, relationConfigSchema as au, ratingConfigSchema as av, formulaConfigSchema as aw, rollupConfigSchema as ax, documentConfigSchema as ay, attributeConfigSchemas as az, type TextAreaAttribute as b, validateAttribute as b0, validateObject as b1, validateObjectOrThrow as b2, createDraftValidator as b3, validateDraft as b4, validateDraftOrThrow as b5, getMissingRequiredAttributes as b6, isRecordComplete as b7, computeRecordStatus as b8, type RichtextFeature as c, type PhoneAttribute as d, type CurrencyAttribute as e, type SelectAttribute as f, type FileAttribute as g, type RatingAttribute as h, type RelationAttribute as i, type SingleRelationAttribute as j, type MultiRelationAttribute as k, type RelationTarget as l, type FormulaAttribute as m, type FormulaReturnType as n, type RollupAttribute as o, type RollupFunction as p, type AttributeType as q, type ObjectDefinition as r, type FlagValueType as s, type FeatureFlagDefinition as t, type FlagLevel as u, type FeatureFlagsRepository as v, type StaticFlagDefault as w, type ResolvedFlag as x, type StatusGroup as y, type AttributeGroup as z };