@stndrds/schema 0.1.0-alpha.51 → 0.1.0-alpha.52

package/dist/{runtime-DRiI1SCJ.d.mts → runtime-C8IgSFtA.d.mts}

@@ -178,6 +178,16 @@ interface AITodoList {
     progress: number;
     isComplete: boolean;
 }
+/**
+ * Resolved attachment metadata (populated when fetching messages)
+ */
+interface AIMessageAttachment {
+    id: string;
+    name: string;
+    size: number;
+    mimeType: string;
+    url: string;
+}
 /**
  * AI Conversation record
  */
@@ -211,6 +221,8 @@ interface AIMessage {
     model: string | null;
     /** File attachment IDs (references files table) */
     attachmentIds: string[] | null;
+    /** Resolved attachments (populated when fetching messages) */
+    attachments?: AIMessageAttachment[];
     createdAt: Date;
 }
 /**
@@ -8097,6 +8109,7 @@ interface RecordServiceOptions {
 declare class RecordService extends BaseService {
     private schemaService;
     private queryService;
+    private recordResolver;
     private relationService;
     private userService;
     private rollupService;
@@ -8202,451 +8215,711 @@ declare class RecordService extends BaseService {
 }
 
 /**
- * Result of relation validation
+ * Default fallback value when expression resolves to empty string
  */
-interface RelationValidationResult {
-    valid: boolean;
-    errors: RelationValidationError[];
-}
+declare const DEFAULT_LABEL_FALLBACK = "(Untitled)";
+declare function renderLabelExpression(template: string, values: Record<string, unknown>, fallback?: string): string;
 /**
- * Individual relation validation error
+ * Check if a string is a valid label expression template
+ * A valid template contains at least one {{ variable }} block with a non-empty variable
  */
-interface RelationValidationError {
-    /** Attribute name */
-    attribute: string;
-    /** Error message */
-    message: string;
-    /** Invalid record IDs */
-    invalidIds?: string[];
-}
+declare function isLabelExpression(value: string): boolean;
 /**
- * Resolved relation option
+ * Extract attribute names referenced in a label expression
+ * Useful for validation or dependency tracking
  *
- * SECURITY: This type intentionally excludes raw record data.
- * Only the computed label is exposed to prevent unauthorized data access
- * through relation lookups. Users must have explicit read permissions
- * on an object to access its record data.
+ * @example
+ * extractAttributeNames("{{ firstName }} {{ lastName | UPPER }}")
+ * // → ["firstName", "lastName"]
  */
-interface RelationOption {
-    /** Record ID */
-    id: string;
-    /** Object ID */
-    objectId: string;
-    /** Object name (technical name) */
-    objectName: string;
-    /** Object label (display name) */
-    objectLabel: string;
-    /** Object icon */
-    objectIcon?: string;
-    /** Display label (computed from labelExpression) */
-    label: string;
-}
+declare function extractAttributeNames(template: string): string[];
 /**
- * Response for relation options
+ * Enrich record values by formatting complex types for display
+ *
+ * Transforms raw values (objects, dates, etc.) into human-readable strings
+ * for use in label expression rendering. Uses formatAttributeValue internally.
+ *
+ * @param values - Record values containing raw attribute values
+ * @param attributes - Attribute definitions for formatting
+ * @returns New object with complex values formatted as strings
+ *
+ * @example
+ * ```typescript
+ * const enriched = enrichValuesForDisplay(
+ *   { status: "active", price: { value: 1500, code: "EUR" } },
+ *   [
+ *     { type: "select", name: "status", options: [{ value: "active", label: "Active" }] },
+ *     { type: "currency", name: "price" }
+ *   ]
+ * );
+ * // → { status: "Active", price: "1,500.00 EUR" }
+ * ```
  */
-interface RelationOptionsResponse {
-    options: RelationOption[];
-    hasMore: boolean;
-    total: number;
-}
+declare function enrichValuesForDisplay(values: Record<string, unknown>, attributes: Attribute[]): Record<string, unknown>;
 /**
- * Parameters for fetching relation options
+ * @deprecated Use `enrichValuesForDisplay` instead
  */
-interface GetRelationOptionsParams {
-    /** Search query */
-    query?: string;
-    /** Page number (1-based) */
-    page?: number;
-    /** Page size */
-    pageSize?: number;
-    /** Filter by specific target object */
-    targetObject?: string;
-    /** Additional filter to apply (e.g., workflow context filtering) */
-    filter?: FilterState;
-}
+declare const enrichValuesWithSelectLabels: typeof enrichValuesForDisplay;
 /**
- * Options for RelationService constructor
+ * Extract relation IDs from a value (string or array)
+ * For cardinality "many", only the first ID is extracted for label display
+ *
+ * @param val - Relation value (string ID or array of IDs)
+ * @returns Array of IDs (max 1 element for display purposes)
+ *
+ * @example
+ * ```typescript
+ * extractRelationIds("rec-123") // → ["rec-123"]
+ * extractRelationIds(["rec-1", "rec-2"]) // → ["rec-1"]
+ * extractRelationIds(null) // → []
+ * ```
  */
-interface RelationServiceOptions {
-    /**
-     * Record query service for fetching relation options.
-     * Required for getOptions() to work.
-     * If not provided, getOptions() will throw.
-     */
-    queryService?: RecordQueryService;
-}
+declare function extractRelationIds(val: unknown): string[];
 /**
- * Request item for batch relation resolution
+ * Resolver function type for fetching relation labels
+ * Takes an array of record IDs and returns a map of ID → label
  */
-interface ResolveIdsBatchRequest {
-    /** Relation attribute ID */
-    attributeId: string;
-    /** Record IDs to resolve for this attribute */
-    ids: string[];
-}
+type RelationLabelResolver = (ids: string[]) => Promise<Map<string, string>>;
 /**
- * Response for batch relation resolution
- * Maps attributeId to resolved options
+ * Compute a label from a template with full relation resolution (1 level deep)
+ *
+ * Uses pre-computed record.label for nested relations to avoid infinite recursion.
+ * This function enriches select/multiselect values AND resolves relation IDs to their labels.
+ *
+ * @param template - Label expression template (e.g., "{{ company }} - {{ name }}")
+ * @param values - Record values to interpolate
+ * @param attributes - Attribute definitions for the object
+ * @param resolveRelationIds - Function to resolve record IDs to their labels
+ * @returns The rendered label string
+ *
+ * @example
+ * ```typescript
+ * const label = await computeLabelWithRelations(
+ *   "{{ company }} - {{ name }}",
+ *   { company: "rec-123", name: "Product A" },
+ *   objectSchema.attributes,
+ *   async (ids) => {
+ *     const records = await adapter.objectRecords.findByIds(ids);
+ *     return new Map(records.map(r => [r.id, r.label]));
+ *   }
+ * );
+ * // → "Acme Corp - Product A"
+ * ```
  */
-interface ResolveIdsBatchResponse {
-    [attributeId: string]: RelationOption[];
+declare function computeLabelWithRelations(template: string, values: Record<string, unknown>, attributes: Attribute[], resolveRelationIds: RelationLabelResolver): Promise<string>;
+
+/**
+ * Interface for resolving relation labels.
+ * Allows dependency injection for testing and decoupling.
+ */
+interface LabelResolver {
+    resolveRelationIds(ids: string[], attributeId: string): Promise<Array<{
+        id: string;
+        label: string;
+    }>>;
+    findRecordLabels(ids: string[]): Promise<Array<{
+        id: string;
+        label?: string;
+    }>>;
 }
 /**
- * Service for validating relation attributes.
- * Ensures referenced records exist and belong to valid target objects.
- * Automatically uses tenant context from AsyncLocalStorage.
+ * Compute display label from schema expression.
+ * Automatically resolves relation attribute values to their labels
+ * and select/multiselect values to their option labels.
  *
- * Supports optional caching via CacheAdapter for improved performance
- * on relation options lookups.
+ * @param schema - Object schema with labelExpression
+ * @param values - Record values
+ * @param resolver - Resolver for relation labels
+ * @returns Computed label string
  */
-declare class RelationService extends BaseService {
-    private schemaService;
-    private queryService?;
-    constructor(adapter: DatabaseAdapter, nativeRegistry: typeof registry, options?: RelationServiceOptions);
-    /**
-     * Set the query service after construction.
-     * Useful for breaking circular dependencies during initialization.
-     */
-    setQueryService(queryService: RecordQueryService): void;
+declare function computeLabel(schema: ObjectDefinition, values: Record<string, unknown>, resolver: LabelResolver): Promise<string>;
+
+/**
+ * Result of a rollup calculation
+ */
+interface RollupResult {
+    /** Computed value */
+    value: unknown;
+    /** Number of records that contributed to the calculation */
+    recordCount: number;
+}
+/**
+ * Options for RollupService constructor
+ */
+interface RollupServiceOptions {
     /**
-     * Get the query service, throwing if not configured.
+     * Record resolver for cached record fetching.
+     * Required for cached access to records.
      */
-    private getQueryServiceOrThrow;
+    recordResolver: RecordResolverService;
+}
+/**
+ * Service for calculating rollup attribute values
+ *
+ * Rollups aggregate values from related records (e.g., sum of order amounts
+ * for a company). They are calculated when needed and can be materialized
+ * (stored) for performance.
+ *
+ * Supports optional caching via CacheAdapter for improved performance.
+ * Rollup values have a short TTL (2 minutes) due to high volatility.
+ *
+ * Phase 3: Supports single-level relation rollups
+ */
+declare class RollupService extends BaseService {
+    private recordResolver;
+    constructor(adapter: DatabaseAdapter, options: RollupServiceOptions);
     /**
-     * Validate all relation attributes in the data
+     * Calculate a rollup value for a record
      *
-     * @param schema - Object schema containing attribute definitions
-     * @param data - Record data to validate
-     * @returns Validation result with errors if any
+     * Results are cached if a CacheAdapter is configured.
+     *
+     * @param recordId - ID of the parent record
+     * @param rollupAttr - Rollup attribute definition
+     * @param schema - Schema of the parent object
+     * @returns Computed rollup value
      *
      * @example
      * ```typescript
-     * const result = await relationService.validateRelations(schema, {
-     *   company: "rec-123",
-     *   contacts: ["rec-456", "rec-789"]
-     * });
-     *
-     * if (!result.valid) {
-     *   console.log(result.errors);
-     *   // [{ attribute: "company", message: "Record not found", invalidIds: ["rec-123"] }]
-     * }
+     * // Sum all order amounts for a company
+     * const totalOrders = await rollupService.calculate(
+     *   "company-123",
+     *   {
+     *     type: "rollup",
+     *     name: "totalOrders",
+     *     relationAttribute: "orders",
+     *     targetAttribute: "amount",
+     *     function: "sum",
+     *     ...
+     *   },
+     *   companySchema
+     * );
      * ```
      */
-    validateRelations(schema: ObjectDefinition, data: Record<string, unknown>): Promise<RelationValidationResult>;
+    calculate(recordId: string, rollupAttr: RollupAttribute, schema: ObjectDefinition): Promise<RollupResult>;
     /**
-     * Validate a single relation attribute value
-     *
-     * Uses batch fetching (findByIds) to avoid N+1 query pattern.
+     * Internal method to compute rollup value (no caching)
      */
-    private validateRelationAttribute;
+    private computeRollup;
     /**
-     * Extract IDs from relation value based on cardinality
+     * Forward pattern: this record has a relation attribute pointing to other records
+     * Example: entreprise222 has relation "entreprises" → companies, rollup collects from companies
      */
-    private extractIds;
+    private calculateForward;
     /**
-     * Get valid object IDs from relation targets
-     * Note: Universal relations (toAny) are handled earlier in validateRelationAttribute
+     * Reverse pattern: other records have a relation pointing to this record
+     * Example: Company has rollup on "orders", Order has relation "company" → companies
      */
-    private getValidObjectIds;
+    private calculateReverse;
     /**
-     * Validate relations and throw if invalid
+     * Extract and aggregate values from related records
      */
-    validateRelationsOrThrow(schema: ObjectDefinition, data: Record<string, unknown>): Promise<void>;
+    private aggregateValues;
     /**
-     * Get available options for a relation attribute.
-     * Searches across all target objects defined in the relation.
-     * Automatically uses tenant context from AsyncLocalStorage.
-     *
-     * @param attribute - Relation attribute definition
-     * @param params - Query parameters
+     * Calculate rollup values for multiple records (batched)
      *
-     * @example
-     * ```typescript
-     * const options = await relationService.getOptions(attribute, {
-     *   query: "nike",
-     *   page: 1,
-     *   pageSize: 20
-     * });
-     * ```
+     * More efficient than calling calculate() for each record individually.
      */
-    getOptions(attribute: RelationAttribute, params?: GetRelationOptionsParams): Promise<RelationOptionsResponse>;
+    calculateForMany(recordIds: string[], rollupAttr: RollupAttribute, schema: ObjectDefinition): Promise<Map<string, RollupResult>>;
     /**
-     * Internal method to fetch relation options (extracted for caching)
+     * Apply aggregation function to a set of values
      */
-    private fetchOptions;
+    private aggregate;
     /**
-     * Resolve record IDs to their display labels.
-     * Useful for displaying current values in the UI.
-     *
-     * Uses caching per individual record ID for optimal performance.
-     * Cache key format: `${attributeId}:${recordId}` to handle different displayTemplates.
-     *
-     * @param ids - Record IDs to resolve
-     * @param attributeId - Relation attribute ID to use its displayTemplate for label rendering
-     *
-     * @example
-     * ```typescript
-     * const resolved = await relationService.resolveIds(["rec-1", "rec-2"], "attr-123");
-     * // [{ id: "rec-1", label: "Nike Air Max", objectName: "products", ... }]
-     * ```
+     * Get the default empty value for a rollup function
      */
-    resolveIds(ids: string[], attributeId: string): Promise<RelationOption[]>;
+    private getEmptyValue;
     /**
-     * Resolve multiple attribute/IDs batches in a single operation.
-     * Optimized for DataGrid scenarios with multiple relation columns.
-     *
-     * Benefits over multiple resolveIds() calls:
-     * - Single DB query for all records across all attributes
-     * - Deduplication of records referenced by multiple attributes
-     * - Single schema lookup per objectId
-     *
-     * Uses caching per individual record ID for optimal performance.
-     *
-     * @param requests - Array of { attributeId, ids } to resolve
-     * @returns Map of attributeId to resolved options
+     * Sum numeric values
+     */
+    private sumNumbers;
+    /**
+     * Average numeric values
+     */
+    private averageNumbers;
+    /**
+     * Get earliest date from values
+     */
+    private earliestDate;
+    /**
+     * Get latest date from values
+     */
+    private latestDate;
+    /**
+     * Recalculate all rollup attributes for a record and update it
      *
-     * @example
-     * ```typescript
-     * const results = await relationService.resolveIdsBatch([
-     *   { attributeId: "attr-company", ids: ["rec-1", "rec-2"] },
-     *   { attributeId: "attr-contact", ids: ["rec-3", "rec-4"] },
-     * ]);
-     * // { "attr-company": [...], "attr-contact": [...] }
-     * ```
+     * Called after related records change to keep rollups up-to-date.
      */
-    resolveIdsBatch(requests: ResolveIdsBatchRequest[]): Promise<ResolveIdsBatchResponse>;
+    recalculateAndUpdate(record: ObjectRecord, schema: ObjectDefinition): Promise<ObjectRecord>;
     /**
-     * Internal method to fetch and resolve multiple composite IDs at once.
-     * Optimized for batch operations - single DB query for all records.
+     * Find parent records that need rollup recalculation when a child record changes
+     *
+     * Used by hooks to determine which parent records to recalculate after
+     * a child record is created, updated, or deleted.
+     *
+     * @param changedRecord - The record that was modified
+     * @param changedSchema - Schema of the changed record's object
+     * @returns Array of parent record IDs that need recalculation
      */
-    private fetchResolveIdsBatch;
+    findAffectedParentRecords(changedRecord: ObjectRecord, changedSchema: ObjectDefinition): Promise<string[]>;
     /**
-     * Internal method to fetch and resolve relation IDs (no caching).
-     * Uses batch fetching for performance - fetches all records in one query,
-     * then groups by objectId to minimize schema lookups.
+     * Invalidate cached rollups for affected parent records.
+     * Call this after a child record is created, updated, or deleted.
+     *
+     * @param affectedParentIds - Array of parent record IDs whose rollups need invalidation
      */
-    private fetchResolveIds;
+    invalidateAffectedRollups(affectedParentIds: string[]): Promise<void>;
     /**
-     * Find a relation attribute by ID.
-     * Results are cached if a CacheAdapter is configured.
-     * Cache is invalidated by ObjectSchemaService.invalidateSchemaCache() via allAttributes pattern.
+     * Invalidate all cached rollups for the current tenant.
+     * Use sparingly - prefer targeted invalidation.
      */
-    findAttributeById(attributeId: string): Promise<RelationAttribute | null>;
+    invalidateAllRollups(): Promise<void>;
     /**
-     * Internal method to fetch attribute by ID (no caching)
+     * Find records that have forward rollups pointing to the modified record.
+     *
+     * Forward rollups are rollups where the record has a relation attribute
+     * pointing to another object, and the rollup aggregates values from that target.
+     * When the target record changes, we need to recalculate these rollups.
+     *
+     * Example: Order has relation "company" → Company, and rollup "capitalSocial"
+     * aggregating from the Company. When Company.capitalSocial changes,
+     * all Orders pointing to that Company need their rollup recalculated.
+     *
+     * @param changedRecord - The record that was modified
+     * @param changedSchema - Schema of the changed record's object
+     * @returns Array of records that need their forward rollups recalculated
      */
-    private fetchAttributeById;
+    findRecordsWithForwardRollup(changedRecord: ObjectRecord, changedSchema: ObjectDefinition): Promise<ObjectRecord[]>;
 }
 
 /**
- * Resolved relation values for a record
- * Maps relation attribute name to the resolved record's values
+ * Context for rollup cascade operations.
+ * Provides the necessary services via dependency injection.
  */
-type ResolvedRelations = Record<string, Record<string, unknown>>;
+interface RollupCascadeContext {
+    rollupService: RollupService;
+    schemaService: ObjectSchemaService;
+    findRecordsByIds: (ids: string[]) => Promise<ObjectRecord[]>;
+}
 /**
- * Service for resolving relation values from related records
+ * Recalculate rollups after a record changes.
  *
- * Used by formula evaluation to access values from related records
- * (e.g., "company.name" in a formula on an order)
+ * This handles three cases:
+ * 1. The record itself has rollups (e.g., aggregating from related records it points to)
+ * 2. Parent records have rollups that aggregate from this record (reverse pattern)
+ * 3. Records that have forward rollups pointing to this record (forward pattern)
+ *
+ * Optimized: Pre-loads schemas by objectId to avoid N redundant calls
+ * when multiple records share the same objectId.
+ *
+ * @param record - The record that was modified
+ * @param schema - Schema of the record's object
+ * @param ctx - Context with required services
  */
-declare class RelationResolverService {
-    private adapter;
+declare function recalculateParentRollups(record: ObjectRecord, schema: ObjectDefinition, ctx: RollupCascadeContext): Promise<void>;
+
+/**
+ * Service for cached record resolution.
+ *
+ * Centralizes all record fetching with automatic caching to avoid
+ * redundant database queries across services (relation, rollup, formulas).
+ *
+ * Also provides factory methods for creating resolver interfaces used by
+ * helpers (label computation, rollup cascade).
+ *
+ * @example
+ * ```typescript
+ * const resolver = new RecordResolverService(adapter);
+ *
+ * // Cached record fetching
+ * const record = await resolver.findById("rec-123");
+ * const records = await resolver.findByIds(["rec-1", "rec-2"]);
+ *
+ * // Factory methods for helpers
+ * const labelResolver = resolver.createLabelResolver(relationService);
+ * const rollupContext = resolver.createRollupContext(rollupService, schemaService);
+ * ```
+ */
+declare class RecordResolverService extends BaseService {
     constructor(adapter: DatabaseAdapter);
     /**
-     * Resolve values from related records for formula evaluation
+     * Find a record by ID with caching.
      *
-     * Phase 2: Supports 1 level of relation traversal only
+     * Uses the shared record cache for optimal performance.
+     * Delegates to findByIds for consistent cache handling.
      *
-     * @param record - The source record
-     * @param schema - Schema of the source object
-     * @param relationNames - Names of relation attributes to resolve
-     * @returns Map of relation name to related record's values
+     * @param id - Record ID
+     * @returns Record or null if not found
+     */
+    findById(id: string): Promise<ObjectRecord | null>;
+    /**
+     * Find multiple records by IDs with caching.
      *
-     * @example
-     * ```typescript
-     * // For an order with company relation
-     * const resolved = await resolver.resolveRelationValues(
-     *   orderRecord,
-     *   orderSchema,
-     *   ["company"]
-     * );
-     * // → { company: { id: "...", name: "Acme Corp", ... } }
-     * ```
+     * Each record is cached individually for reuse across services.
+     * Only fetches records not already in cache.
+     *
+     * @param ids - Record IDs to fetch
+     * @returns Array of found records (missing IDs are not included)
      */
-    resolveRelationValues(record: ObjectRecord, schema: ObjectDefinition, relationNames: string[]): Promise<ResolvedRelations>;
+    findByIds(ids: string[]): Promise<ObjectRecord[]>;
     /**
-     * Resolve relation values for multiple records (batched)
+     * Create a RelationLabelResolver callback for computeLabelWithRelations.
      *
-     * Optimized for list operations - fetches all related records in one batch
+     * Used by RelationService.resolveLabel() and ObjectSchemaService.
      *
-     * @param records - Source records
-     * @param schema - Schema of the source object
-     * @param relationNames - Names of relation attributes to resolve
-     * @returns Map of record ID to resolved relations
+     * @returns Callback that resolves record IDs to their labels (cached)
      */
-    resolveRelationValuesForMany(records: ObjectRecord[], schema: ObjectDefinition, relationNames: string[]): Promise<Map<string, ResolvedRelations>>;
+    createRelationLabelResolver(): RelationLabelResolver;
     /**
-     * Flatten resolved relations for formula evaluation
+     * Create a LabelResolver interface for label computation helpers.
      *
-     * Converts nested structure to dot-notation keys:
-     * { company: { name: "Acme" } } → { "company.name": "Acme" }
+     * Used by RecordService for computing record labels.
      *
-     * @param resolved - Resolved relations from resolveRelationValues
-     * @returns Flattened values suitable for formula evaluation
+     * @param relationService - RelationService for resolving relation display labels
+     * @returns LabelResolver interface with cached record fetching
      */
-    flattenResolvedRelations(resolved: ResolvedRelations): Record<string, unknown>;
+    createLabelResolver(relationService: RelationService): LabelResolver;
     /**
-     * Extract a single relation ID from a value
-     * Handles both single (string) and multi (array) relations
-     * @internal
+     * Create a RollupCascadeContext for rollup recalculation.
+     *
+     * Used by RecordService after create/update/delete operations.
+     *
+     * @param rollupService - RollupService for recalculating rollups
+     * @param schemaService - ObjectSchemaService for fetching schemas
+     * @returns Context with cached record fetching
      */
-    private extractSingleId;
+    createRollupContext(rollupService: RollupService, schemaService: ObjectSchemaService): RollupCascadeContext;
 }
 
 /**
- * Result of a rollup calculation
+ * Result of relation validation
  */
-interface RollupResult {
-    /** Computed value */
-    value: unknown;
-    /** Number of records that contributed to the calculation */
-    recordCount: number;
+interface RelationValidationResult {
+    valid: boolean;
+    errors: RelationValidationError[];
 }
 /**
- * Service for calculating rollup attribute values
- *
- * Rollups aggregate values from related records (e.g., sum of order amounts
- * for a company). They are calculated when needed and can be materialized
- * (stored) for performance.
+ * Individual relation validation error
+ */
+interface RelationValidationError {
+    /** Attribute name */
+    attribute: string;
+    /** Error message */
+    message: string;
+    /** Invalid record IDs */
+    invalidIds?: string[];
+}
+/**
+ * Resolved relation option
  *
- * Supports optional caching via CacheAdapter for improved performance.
- * Rollup values have a short TTL (2 minutes) due to high volatility.
+ * SECURITY: This type intentionally excludes raw record data.
+ * Only the computed label is exposed to prevent unauthorized data access
+ * through relation lookups. Users must have explicit read permissions
+ * on an object to access its record data.
+ */
+interface RelationOption {
+    /** Record ID */
+    id: string;
+    /** Object ID */
+    objectId: string;
+    /** Object name (technical name) */
+    objectName: string;
+    /** Object label (display name) */
+    objectLabel: string;
+    /** Object icon */
+    objectIcon?: string;
+    /** Display label (computed from labelExpression) */
+    label: string;
+}
+/**
+ * Response for relation options
+ */
+interface RelationOptionsResponse {
+    options: RelationOption[];
+    hasMore: boolean;
+    total: number;
+}
+/**
+ * Parameters for fetching relation options
+ */
+interface GetRelationOptionsParams {
+    /** Search query */
+    query?: string;
+    /** Page number (1-based) */
+    page?: number;
+    /** Page size */
+    pageSize?: number;
+    /** Filter by specific target object */
+    targetObject?: string;
+    /** Additional filter to apply (e.g., workflow context filtering) */
+    filter?: FilterState;
+}
+/**
+ * Options for RelationService constructor
+ */
+interface RelationServiceOptions {
+    /**
+     * Record query service for fetching relation options.
+     * Required for getOptions() to work.
+     * If not provided, getOptions() will throw.
+     */
+    queryService?: RecordQueryService;
+    /**
+     * Record resolver for cached record fetching.
+     * Required for cached access to records.
+     */
+    recordResolver: RecordResolverService;
+}
+/**
+ * Request item for batch relation resolution
+ */
+interface ResolveIdsBatchRequest {
+    /** Relation attribute ID */
+    attributeId: string;
+    /** Record IDs to resolve for this attribute */
+    ids: string[];
+}
+/**
+ * Response for batch relation resolution
+ * Maps attributeId to resolved options
+ */
+interface ResolveIdsBatchResponse {
+    [attributeId: string]: RelationOption[];
+}
+/**
+ * Service for validating relation attributes.
+ * Ensures referenced records exist and belong to valid target objects.
+ * Automatically uses tenant context from AsyncLocalStorage.
  *
- * Phase 3: Supports single-level relation rollups
+ * Supports optional caching via CacheAdapter for improved performance
+ * on relation options lookups.
  */
-declare class RollupService extends BaseService {
-    constructor(adapter: DatabaseAdapter);
+declare class RelationService extends BaseService {
+    private schemaService;
+    private queryService?;
+    private recordResolver;
+    constructor(adapter: DatabaseAdapter, nativeRegistry: typeof registry, options: RelationServiceOptions);
     /**
-     * Calculate a rollup value for a record
-     *
-     * Results are cached if a CacheAdapter is configured.
+     * Set the query service after construction.
+     * Useful for breaking circular dependencies during initialization.
+     */
+    setQueryService(queryService: RecordQueryService): void;
+    /**
+     * Get the query service, throwing if not configured.
+     */
+    private getQueryServiceOrThrow;
+    /**
+     * Validate all relation attributes in the data
      *
-     * @param recordId - ID of the parent record
-     * @param rollupAttr - Rollup attribute definition
-     * @param schema - Schema of the parent object
-     * @returns Computed rollup value
+     * @param schema - Object schema containing attribute definitions
+     * @param data - Record data to validate
+     * @returns Validation result with errors if any
      *
      * @example
      * ```typescript
-     * // Sum all order amounts for a company
-     * const totalOrders = await rollupService.calculate(
-     *   "company-123",
-     *   {
-     *     type: "rollup",
-     *     name: "totalOrders",
-     *     relationAttribute: "orders",
-     *     targetAttribute: "amount",
-     *     function: "sum",
-     *     ...
-     *   },
-     *   companySchema
-     * );
+     * const result = await relationService.validateRelations(schema, {
+     *   company: "rec-123",
+     *   contacts: ["rec-456", "rec-789"]
+     * });
+     *
+     * if (!result.valid) {
+     *   console.log(result.errors);
+     *   // [{ attribute: "company", message: "Record not found", invalidIds: ["rec-123"] }]
+     * }
      * ```
      */
-    calculate(recordId: string, rollupAttr: RollupAttribute, schema: ObjectDefinition): Promise<RollupResult>;
+    validateRelations(schema: ObjectDefinition, data: Record<string, unknown>): Promise<RelationValidationResult>;
     /**
-     * Internal method to compute rollup value (no caching)
+     * Validate a single relation attribute value
+     *
+     * Uses batch fetching (findByIds) to avoid N+1 query pattern.
      */
-    private computeRollup;
+    private validateRelationAttribute;
     /**
-     * Forward pattern: this record has a relation attribute pointing to other records
-     * Example: entreprise222 has relation "entreprises" → companies, rollup collects from companies
+     * Extract IDs from relation value based on cardinality
      */
-    private calculateForward;
+    private extractIds;
     /**
-     * Reverse pattern: other records have a relation pointing to this record
-     * Example: Company has rollup on "orders", Order has relation "company" → companies
+     * Get valid object IDs from relation targets
+     * Note: Universal relations (toAny) are handled earlier in validateRelationAttribute
      */
-    private calculateReverse;
+    private getValidObjectIds;
     /**
-     * Extract and aggregate values from related records
+     * Validate relations and throw if invalid
      */
-    private aggregateValues;
+    validateRelationsOrThrow(schema: ObjectDefinition, data: Record<string, unknown>): Promise<void>;
     /**
-     * Calculate rollup values for multiple records (batched)
+     * Get available options for a relation attribute.
+     * Searches across all target objects defined in the relation.
+     * Automatically uses tenant context from AsyncLocalStorage.
      *
-     * More efficient than calling calculate() for each record individually.
+     * @param attribute - Relation attribute definition
+     * @param params - Query parameters
+     *
+     * @example
+     * ```typescript
+     * const options = await relationService.getOptions(attribute, {
+     *   query: "nike",
+     *   page: 1,
+     *   pageSize: 20
+     * });
+     * ```
      */
-    calculateForMany(recordIds: string[], rollupAttr: RollupAttribute, schema: ObjectDefinition): Promise<Map<string, RollupResult>>;
+    getOptions(attribute: RelationAttribute, params?: GetRelationOptionsParams): Promise<RelationOptionsResponse>;
     /**
-     * Apply aggregation function to a set of values
+     * Internal method to fetch relation options (extracted for caching)
+     */
+    private fetchOptions;
+    /**
+     * Resolve record IDs to their display labels.
+     * Useful for displaying current values in the UI.
+     *
+     * Uses caching per individual record ID for optimal performance.
+     * Cache key format: `${attributeId}:${recordId}` to handle different displayTemplates.
+     *
+     * @param ids - Record IDs to resolve
+     * @param attributeId - Relation attribute ID to use its displayTemplate for label rendering
+     *
+     * @example
+     * ```typescript
+     * const resolved = await relationService.resolveIds(["rec-1", "rec-2"], "attr-123");
+     * // [{ id: "rec-1", label: "Nike Air Max", objectName: "products", ... }]
+     * ```
+     */
+    resolveIds(ids: string[], attributeId: string): Promise<RelationOption[]>;
+    /**
+     * Resolve multiple attribute/IDs batches in a single operation.
+     * Optimized for DataGrid scenarios with multiple relation columns.
+     *
+     * Benefits over multiple resolveIds() calls:
+     * - Single DB query for all records across all attributes
+     * - Deduplication of records referenced by multiple attributes
+     * - Single schema lookup per objectId
+     *
+     * Uses caching per individual record ID for optimal performance.
+     *
+     * @param requests - Array of { attributeId, ids } to resolve
+     * @returns Map of attributeId to resolved options
+     *
+     * @example
+     * ```typescript
+     * const results = await relationService.resolveIdsBatch([
+     *   { attributeId: "attr-company", ids: ["rec-1", "rec-2"] },
+     *   { attributeId: "attr-contact", ids: ["rec-3", "rec-4"] },
+     * ]);
+     * // { "attr-company": [...], "attr-contact": [...] }
+     * ```
      */
-    private aggregate;
+    resolveIdsBatch(requests: ResolveIdsBatchRequest[]): Promise<ResolveIdsBatchResponse>;
     /**
-     * Get the default empty value for a rollup function
+     * Internal method to resolve multiple composite IDs at once.
+     * Optimized for batch operations - single DB query for all records.
+     *
+     * @param compositeIds - Array of composite IDs in format "attributeId:recordId"
      */
-    private getEmptyValue;
+    private resolveCompositeIds;
     /**
-     * Sum numeric values
+     * Resolve the display label for a record.
+     * Uses custom template if provided, otherwise falls back to pre-computed label.
      */
-    private sumNumbers;
+    private resolveLabel;
     /**
-     * Average numeric values
+     * Find a relation attribute by ID.
+     * Results are cached if a CacheAdapter is configured.
+     * Cache is invalidated by ObjectSchemaService.invalidateSchemaCache() via allAttributes pattern.
      */
-    private averageNumbers;
+    findAttributeById(attributeId: string): Promise<RelationAttribute | null>;
     /**
-     * Get earliest date from values
+     * Internal method to fetch attribute by ID (no caching)
      */
-    private earliestDate;
+    private fetchAttributeById;
+}
+
+/**
+ * Resolved relation values for a record
+ * Maps relation attribute name to the resolved record's values
+ */
+type ResolvedRelations = Record<string, Record<string, unknown>>;
+/**
+ * Options for FormulaResolverService constructor
+ */
+interface FormulaResolverServiceOptions {
     /**
-     * Get latest date from values
+     * Record resolver for cached record fetching.
+     * Required for cached access to records.
      */
-    private latestDate;
+    recordResolver: RecordResolverService;
+}
+/**
+ * Service for resolving relation values from related records.
+ *
+ * Used by formula evaluation to access values from related records
+ * (e.g., "company.name" in a formula on an order).
+ *
+ * Supports optional RecordResolverService injection for cached record fetching.
+ *
+ * @example
+ * ```typescript
+ * const resolver = new FormulaResolverService(adapter, { recordResolver });
+ *
+ * // Resolve relation values for formula evaluation
+ * const resolved = await resolver.resolveRelationValues(
+ *   orderRecord,
+ *   orderSchema,
+ *   ["company"]
+ * );
+ * // → { company: { id: "...", name: "Acme Corp", ... } }
+ * ```
+ */
+declare class FormulaResolverService extends BaseService {
+    private recordResolver;
+    constructor(adapter: DatabaseAdapter, options: FormulaResolverServiceOptions);
     /**
-     * Recalculate all rollup attributes for a record and update it
+     * Resolve values from related records for formula evaluation
      *
-     * Called after related records change to keep rollups up-to-date.
-     */
-    recalculateAndUpdate(record: ObjectRecord, schema: ObjectDefinition): Promise<ObjectRecord>;
-    /**
-     * Find parent records that need rollup recalculation when a child record changes
+     * Supports 1 level of relation traversal only.
      *
-     * Used by hooks to determine which parent records to recalculate after
-     * a child record is created, updated, or deleted.
+     * @param record - The source record
+     * @param schema - Schema of the source object
+     * @param relationNames - Names of relation attributes to resolve
+     * @returns Map of relation name to related record's values
      *
-     * @param changedRecord - The record that was modified
-     * @param changedSchema - Schema of the changed record's object
-     * @returns Array of parent record IDs that need recalculation
+     * @example
+     * ```typescript
+     * const resolved = await resolver.resolveRelationValues(
+     *   orderRecord,
+     *   orderSchema,
+     *   ["company"]
+     * );
+     * // → { company: { id: "...", name: "Acme Corp", ... } }
+     * ```
      */
-    findAffectedParentRecords(changedRecord: ObjectRecord, changedSchema: ObjectDefinition): Promise<string[]>;
+    resolveRelationValues(record: ObjectRecord, schema: ObjectDefinition, relationNames: string[]): Promise<ResolvedRelations>;
     /**
-     * Invalidate cached rollups for affected parent records.
-     * Call this after a child record is created, updated, or deleted.
+     * Resolve relation values for multiple records (batched)
      *
-     * @param affectedParentIds - Array of parent record IDs whose rollups need invalidation
-     */
-    invalidateAffectedRollups(affectedParentIds: string[]): Promise<void>;
-    /**
-     * Invalidate all cached rollups for the current tenant.
-     * Use sparingly - prefer targeted invalidation.
+     * Optimized for list operations - fetches all related records in one batch
+     *
+     * @param records - Source records
+     * @param schema - Schema of the source object
+     * @param relationNames - Names of relation attributes to resolve
+     * @returns Map of record ID to resolved relations
      */
-    invalidateAllRollups(): Promise<void>;
+    resolveRelationValuesForMany(records: ObjectRecord[], schema: ObjectDefinition, relationNames: string[]): Promise<Map<string, ResolvedRelations>>;
     /**
-     * Find records that have forward rollups pointing to the modified record.
-     *
-     * Forward rollups are rollups where the record has a relation attribute
-     * pointing to another object, and the rollup aggregates values from that target.
-     * When the target record changes, we need to recalculate these rollups.
+     * Flatten resolved relations for formula evaluation
      *
-     * Example: Order has relation "company" → Company, and rollup "capitalSocial"
-     * aggregating from the Company. When Company.capitalSocial changes,
-     * all Orders pointing to that Company need their rollup recalculated.
+     * Converts nested structure to dot-notation keys:
+     * { company: { name: "Acme" } } → { "company.name": "Acme" }
      *
-     * @param changedRecord - The record that was modified
-     * @param changedSchema - Schema of the changed record's object
-     * @returns Array of records that need their forward rollups recalculated
+     * @param resolved - Resolved relations from resolveRelationValues
+     * @returns Flattened values suitable for formula evaluation
      */
-    findRecordsWithForwardRollup(changedRecord: ObjectRecord, changedSchema: ObjectDefinition): Promise<ObjectRecord[]>;
+    flattenResolvedRelations(resolved: ResolvedRelations): Record<string, unknown>;
+    /**
+     * Extract a single relation ID from a value
+     * Handles both single (string) and multi (array) relations
+     */
+    private extractSingleId;
 }
 
 /**
@@ -8657,6 +8930,8 @@ interface RollupSchedulerOptions {
     debounceMs?: number;
     /** Maximum pending recalculations before forced flush (default: 100) */
     maxPending?: number;
+    /** Record resolver for cached record fetching (required) */
+    recordResolver: RecordResolverService;
 }
 /**
  * Scheduler for debouncing rollup recalculations
@@ -8666,7 +8941,8 @@ interface RollupSchedulerOptions {
  *
  * @example
  * ```typescript
- * const scheduler = new RollupScheduler(adapter, {
+ * const scheduler = new RollupScheduler(adapter, getSchemaById, {
+ *   recordResolver,
  *   debounceMs: 100,
  *   maxPending: 50,
  * });
@@ -8686,7 +8962,7 @@ declare class RollupScheduler {
     private rollupService;
     private debounceMs;
     private maxPending;
-    constructor(adapter: DatabaseAdapter, getSchemaById: (id: string) => Promise<ObjectDefinition | null>, options?: RollupSchedulerOptions);
+    constructor(adapter: DatabaseAdapter, getSchemaById: (id: string) => Promise<ObjectDefinition | null>, options: RollupSchedulerOptions);
     /**
      * Schedule a rollup recalculation for a parent record.
      *
@@ -8755,32 +9031,6 @@ declare function checkRecordModifyOrThrow(policy: RecordPolicy, record: ObjectRe
  */
 declare function checkRecordDeleteOrThrow(policy: RecordPolicy, record: ObjectRecord, context: PolicyContext): void;
 
-/**
- * Interface for resolving relation labels.
- * Allows dependency injection for testing and decoupling.
- */
-interface LabelResolver {
-    resolveRelationIds(ids: string[], attributeId: string): Promise<Array<{
-        id: string;
-        label: string;
-    }>>;
-    findRecordLabels(ids: string[]): Promise<Array<{
-        id: string;
-        label?: string;
-    }>>;
-}
-/**
- * Compute display label from schema expression.
- * Automatically resolves relation attribute values to their labels
- * and select/multiselect values to their option labels.
- *
- * @param schema - Object schema with labelExpression
- * @param values - Record values
- * @param resolver - Resolver for relation labels
- * @returns Computed label string
- */
-declare function computeLabel(schema: ObjectDefinition, values: Record<string, unknown>, resolver: LabelResolver): Promise<string>;
-
 /**
  * Enrich a record with computed formula values.
  *
@@ -8818,32 +9068,6 @@ declare function createContextForDelete(schema: ObjectDefinition, tenantId: stri
  */
 declare function createContextForRestore(schema: ObjectDefinition, tenantId: string, record: ObjectRecord, metadata?: Record<string, unknown>): HookContext;
 
-/**
- * Context for rollup cascade operations.
- * Provides the necessary services via dependency injection.
- */
-interface RollupCascadeContext {
-    rollupService: RollupService;
-    schemaService: ObjectSchemaService;
-    findRecordsByIds: (ids: string[]) => Promise<ObjectRecord[]>;
-}
-/**
- * Recalculate rollups after a record changes.
- *
- * This handles three cases:
- * 1. The record itself has rollups (e.g., aggregating from related records it points to)
- * 2. Parent records have rollups that aggregate from this record (reverse pattern)
- * 3. Records that have forward rollups pointing to this record (forward pattern)
- *
- * Optimized: Pre-loads schemas by objectId to avoid N redundant calls
- * when multiple records share the same objectId.
- *
- * @param record - The record that was modified
- * @param schema - Schema of the record's object
- * @param ctx - Context with required services
- */
-declare function recalculateParentRollups(record: ObjectRecord, schema: ObjectDefinition, ctx: RollupCascadeContext): Promise<void>;
-
 /**
  * Fluent query builder for schema records.
  * Supports chained filters, sorts, and pagination.
@@ -9861,7 +10085,7 @@ declare function flattenRelationsForEval(resolvedRelations: ResolvedRelations):
  * // → "Acme Corp - ORD-001"
  * ```
  */
-declare function evaluateFormulaWithRelations(expression: string, record: ObjectRecord, schema: ObjectDefinition, resolver: RelationResolverService): Promise<unknown>;
+declare function evaluateFormulaWithRelations(expression: string, record: ObjectRecord, schema: ObjectDefinition, resolver: FormulaResolverService): Promise<unknown>;
 /**
  * Evaluate a formula attribute that may contain relation references
  *
@@ -9871,7 +10095,7 @@ declare function evaluateFormulaWithRelations(expression: string, record: Object
  * @param resolver - Relation resolver service
  * @returns Formatted computed value
  */
-declare function evaluateFormulaAttributeWithRelations(attr: FormulaAttribute, record: ObjectRecord, schema: ObjectDefinition, resolver: RelationResolverService): Promise<unknown>;
+declare function evaluateFormulaAttributeWithRelations(attr: FormulaAttribute, record: ObjectRecord, schema: ObjectDefinition, resolver: FormulaResolverService): Promise<unknown>;
 
 /**
  * Type of a path segment
@@ -11484,98 +11708,4 @@ interface FullSyncOptions extends SyncOptions, ViewSyncOptions {
  */
 declare function syncAll(adapter: DatabaseAdapter, objectRegistry: typeof registry, nativeViewRegistry: typeof viewRegistry, options?: FullSyncOptions): Promise<FullSyncResult>;
 
-/**
- * Default fallback value when expression resolves to empty string
- */
-declare const DEFAULT_LABEL_FALLBACK = "(Untitled)";
-declare function renderLabelExpression(template: string, values: Record<string, unknown>, fallback?: string): string;
-/**
- * Check if a string is a valid label expression template
- * A valid template contains at least one {{ variable }} block with a non-empty variable
- */
-declare function isLabelExpression(value: string): boolean;
-/**
- * Extract attribute names referenced in a label expression
- * Useful for validation or dependency tracking
- *
- * @example
- * extractAttributeNames("{{ firstName }} {{ lastName | UPPER }}")
- * // → ["firstName", "lastName"]
- */
-declare function extractAttributeNames(template: string): string[];
-/**
- * Enrich record values by formatting complex types for display
- *
- * Transforms raw values (objects, dates, etc.) into human-readable strings
- * for use in label expression rendering. Uses formatAttributeValue internally.
- *
- * @param values - Record values containing raw attribute values
- * @param attributes - Attribute definitions for formatting
- * @returns New object with complex values formatted as strings
- *
- * @example
- * ```typescript
- * const enriched = enrichValuesForDisplay(
- *   { status: "active", price: { value: 1500, code: "EUR" } },
- *   [
- *     { type: "select", name: "status", options: [{ value: "active", label: "Active" }] },
- *     { type: "currency", name: "price" }
- *   ]
- * );
- * // → { status: "Active", price: "1,500.00 EUR" }
- * ```
- */
-declare function enrichValuesForDisplay(values: Record<string, unknown>, attributes: Attribute[]): Record<string, unknown>;
-/**
- * @deprecated Use `enrichValuesForDisplay` instead
- */
-declare const enrichValuesWithSelectLabels: typeof enrichValuesForDisplay;
-/**
- * Extract relation IDs from a value (string or array)
- * For cardinality "many", only the first ID is extracted for label display
- *
- * @param val - Relation value (string ID or array of IDs)
- * @returns Array of IDs (max 1 element for display purposes)
- *
- * @example
- * ```typescript
- * extractRelationIds("rec-123") // → ["rec-123"]
- * extractRelationIds(["rec-1", "rec-2"]) // → ["rec-1"]
- * extractRelationIds(null) // → []
- * ```
- */
-declare function extractRelationIds(val: unknown): string[];
-/**
- * Resolver function type for fetching relation labels
- * Takes an array of record IDs and returns a map of ID → label
- */
-type RelationLabelResolver = (ids: string[]) => Promise<Map<string, string>>;
-/**
- * Compute a label from a template with full relation resolution (1 level deep)
- *
- * Uses pre-computed record.label for nested relations to avoid infinite recursion.
- * This function enriches select/multiselect values AND resolves relation IDs to their labels.
- *
- * @param template - Label expression template (e.g., "{{ company }} - {{ name }}")
- * @param values - Record values to interpolate
- * @param attributes - Attribute definitions for the object
- * @param resolveRelationIds - Function to resolve record IDs to their labels
- * @returns The rendered label string
- *
- * @example
- * ```typescript
- * const label = await computeLabelWithRelations(
- *   "{{ company }} - {{ name }}",
- *   { company: "rec-123", name: "Product A" },
- *   objectSchema.attributes,
- *   async (ids) => {
- *     const records = await adapter.objectRecords.findByIds(ids);
- *     return new Map(records.map(r => [r.id, r.label]));
- *   }
- * );
- * // → "Acme Corp - Product A"
- * ```
- */
-declare function computeLabelWithRelations(template: string, values: Record<string, unknown>, attributes: Attribute[], resolveRelationIds: RelationLabelResolver): Promise<string>;
-
-export { type FlowRow as $, type Attribute as A, type DirectTableTab as B, type CheckboxAttribute as C, type DateAttribute as D, type WorkflowConfig as E, type FileAttribute as F, type Group as G, type SlotMode as H, type InferAttributeValue as I, type AuthMethod as J, type AuthChannel as K, type LocationAttribute as L, type MultiselectAttribute as M, type NumberAttribute as N, type ObjectAction as O, type PhoneAttribute as P, type ParticipantTemplate as Q, type RichtextAttribute as R, type SystemResource as S, type TextAttribute as T, type UserAttribute as U, type ViewLayout as V, type WorkflowTheme as W, type ConditionGroup as X, type ConditionRule as Y, type WorkflowNode as Z, type WorkflowDefinition as _, type SystemAction as a, type AuditServiceOptions as a$, type BlockNoteContent as a0, type AIMessageRole as a1, type AIThinkingLevel as a2, type AIToolCallStatus as a3, type AIToolCall as a4, type AIChatMessagePartType as a5, type TextPartData as a6, type ToolPartData as a7, type ThinkingPartData as a8, type ReasoningPartData as a9, RELATION_TARGET_ANY as aA, type RelationAttribute as aB, isUniversalRelation as aC, type BlockNoteBlock as aD, type BlockNoteCustomInlineContent as aE, type BlockNoteDefaultProps as aF, type BlockNoteInlineContent as aG, type BlockNoteLink as aH, type BlockNoteStyledText as aI, type BlockNoteStyles as aJ, type BlockNoteTableCell as aK, type BlockNoteTableCellProps as aL, type BlockNoteTableContent as aM, type PartialBlockNoteBlock as aN, type PartialBlockNoteContent as aO, type PartialBlockNoteInlineContent as aP, type PartialBlockNoteLink as aQ, type PartialBlockNoteStyledText as aR, type PartialBlockNoteTableCell as aS, type PartialBlockNoteTableContent as aT, type AuditResourceType as aU, type AuditAction as aV, type AuditActorType as aW, type AuditChange as aX, type AuditLogEntry as aY, type CreateAuditLogInput as aZ, type AuditListOptions as a_, type AIChatMessagePart as aa, type AIChatMessage as ab, type AIQuestionType as ac, type AIQuestionOption as ad, type AIQuestion as ae, type AIQuestionAnswer as af, type AITodoStatus as ag, type AITodoItem as ah, type AITodoList as ai, type AIConversation as aj, type AIMessage as ak, type AIToolCallRecord as al, type AIUserMemory as am, type AIUsageMetrics as an, type AIProviderMetrics as ao, type CreateAIMessageInput as ap, type StatusGroup as aq, type AttributeGroup as ar, type BaseAttribute as as, type NumberUnit as at, type DateFormat as au, type DateValue as av, type Phone as aw, type Currency as ax, type Location as ay, type LocationGranularity as az, type TextAreaAttribute as b, type ExtractRecordUpdate as b$, type StorageProvider as b0, type FileVisibility as b1, type File as b2, type CreateFile as b3, type UpdateFile as b4, type TextFilterOperator as b5, type NumberFilterOperator as b6, type CheckboxFilterOperator as b7, type DateFilterOperator as b8, type SelectFilterOperator as b9, type FlowDefinition as bA, isFlowDefinition as bB, isFlowPublished as bC, isSystemFlow as bD, type GeocodingSuggestion as bE, type GeocodingAutocompleteParams as bF, type ReverseGeocodingParams as bG, type GeocodingParams as bH, type GeocodingAdapter as bI, NoopGeocodingAdapter as bJ, type AttributeSchema as bK, type InferRecordFromSchema as bL, type InferRecordWithRequirements as bM, type TypedAttribute as bN, type AttributeMap as bO, type AddAttribute as bP, type InferRecord as bQ, type InferRecordInput as bR, type InferRecordUpdate as bS, type CustomAttributeValue as bT, type WithCustomAttributes as bU, type RecordMetadata as bV, type SystemFields as bW, type ExtractRecord as bX, type ExtractRecordStrict as bY, type ExtractRecordInput as bZ, type ExtractRecordInputStrict as b_, type MultiselectFilterOperator as ba, type RelationFilterOperator as bb, type FilterOperator as bc, type RelativeDateValue as bd, type CurrencyFilterValue as be, type PhoneFilterValue as bf, type FilterValue as bg, type FilterRule as bh, type ExtendedFilterRule as bi, type FilterCombinator as bj, type FilterGroup as bk, type AdvancedFilterState as bl, isAdvancedFilterState as bm, toAdvancedFilterState as bn, toSimpleFilterState as bo, type SortDirection as bp, type QueryState as bq, OPERATORS_BY_TYPE as br, type NoValueOperator as bs, NO_VALUE_OPERATORS as bt, isNoValueOperator as bu, type FlowSlot as bv, type FlowRowField as bw, type FlowPage as bx, type FlowRelation as by, type FlowStatus as bz, type RichtextFeature as c, eq as c$, type ExtractRecordUpdateStrict as c0, type ExtractAttributes as c1, type TypedObjectRecord as c2, type ExtractObjectRecord as c3, type ExtractObjectRecordWithCustom as c4, RESERVED_ATTRIBUTE_NAMES as c5, SYSTEM_FIELD_NAMES as c6, type ReservedAttributeName as c7, type SystemFieldName as c8, type Timestamps as c9, type ActivityTab as cA, type NotesTab as cB, type FlowsTab as cC, isFormTab as cD, isTableTab as cE, isDirectTableTab as cF, isInverseTableTab as cG, isCustomTab as cH, isActivityTab as cI, isNotesTab as cJ, isFlowsTab as cK, type StartNode as cL, type FormNode as cM, type FormFieldRef as cN, type ConditionNode as cO, type EndNode as cP, type WorkflowNodeType as cQ, isStartNode as cR, isFormNode as cS, isConditionNode as cT, isEndNode as cU, isSimpleFormNode as cV, isAdvancedFormNode as cW, getNodeOutputs as cX, type ConditionOperator as cY, isConditionRule as cZ, isConditionGroup as c_, type ObjectAttribute as ca, type CompletionStatus as cb, type ObjectRecord as cc, type PermissionScope as cd, type Role as ce, type Permission as cf, type UserRoleAssignment as cg, type EffectivePermissions as ch, type ObjectPermissions as ci, type SystemPermissions as cj, type CreateRoleInput as ck, type UpdateRoleInput as cl, type CreatePermissionInput as cm, type AssignRoleInput as cn, type PolicyContext as co, type RecordPolicy as cp, PolicyViolationError as cq, type UserRole as cr, type UserStatus as cs, type UserProfile as ct, type CreateUserProfile as cu, type UpdateUserProfile as cv, type InviteUserInput as cw, type TabType as cx, type FormTab as cy, type CustomTab as cz, type CurrencyAttribute as d, textConfigSchema as d$, neq as d0, and as d1, or as d2, inValues as d3, isEmpty as d4, isNotEmpty as d5, type WorkflowSlot as d6, type NodePosition as d7, type CanvasViewport as d8, type WorkflowLayout as d9, createEmptyContext as dA, getContextValue as dB, setContextValue as dC, mergeFormToSlot as dD, type WorkflowAccessMode as dE, type ReadOnlyReason as dF, type FormFieldContext as dG, type FormFieldRow as dH, type FormNodeInfo as dI, type FormContextResponse as dJ, type ThemeLogo as dK, type ThemeColors as dL, type ThemeTypography as dM, DEFAULT_THEME as dN, mergeWithDefaults as dO, generateCssVariables as dP, type Uuid as dQ, type TenantId as dR, type UserId as dS, asTenantId as dT, asUserId as dU, generateId as dV, generatePrefixedId as dW, registry as dX, viewRegistry as dY, type ValidationMessages as dZ, DEFAULT_VALIDATION_MESSAGES as d_, type ParticipantAuthConfig as da, type WorkflowStatus as db, isWorkflowDefinition as dc, isWorkflowPublished as dd, isSystemWorkflow as de, type WorkflowTransition as df, type WorkflowError as dg, type PendingAction as dh, type WorkflowInstance as di, isInstanceTerminal as dj, isInstanceWaiting as dk, canResumeInstance as dl, createStartTransition as dm, type ParticipationStatus as dn, type SignedLinkAuth as dp, type PinCodeAuth as dq, type ParticipationAuth as dr, type WorkflowParticipation as ds, isSignedLinkAuth as dt, isPinCodeAuth as du, canParticipate as dv, canAuthenticate as dw, canExecuteNode as dx, type GeneratedDocument as dy, type WorkflowExecutionContext as dz, type Option as e, getDefaultPinCodeService as e$, textareaConfigSchema as e0, richtextConfigSchema as e1, numberConfigSchema as e2, checkboxConfigSchema as e3, dateConfigSchema as e4, phoneConfigSchema as e5, currencyConfigSchema as e6, statusConfigSchema as e7, locationConfigSchema as e8, selectConfigSchema as e9, createRelationValidator as eA, createRatingValidator as eB, createFormulaValidator as eC, createRollupValidator as eD, createTextAreaValidator as eE, createRichtextValidator as eF, createAttributeValidator as eG, createFormAttributeValidator as eH, createObjectValidator as eI, type ValidationResult as eJ, validateAttribute as eK, validateObject as eL, validateObjectOrThrow as eM, createDraftValidator as eN, validateDraft as eO, validateDraftOrThrow as eP, getMissingRequiredAttributes as eQ, isRecordComplete as eR, computeRecordStatus as eS, type DatabaseAdapter as eT, ParticipationTokenService as eU, getDefaultTokenService as eV, initializeTokenService as eW, type ParticipationTokenPayload as eX, type TokenGenerationOptions as eY, type TokenVerificationResult as eZ, PinCodeService as e_, multiselectConfigSchema as ea, fileConfigSchema as eb, userConfigSchema as ec, relationConfigSchema as ed, ratingConfigSchema as ee, formulaConfigSchema as ef, rollupConfigSchema as eg, attributeConfigSchemas as eh, getAttributeConfigSchema as ei, validateAttributeConfig as ej, parseAttributeConfig as ek, safeParseAttributeConfig as el, createTextValidator as em, createNumberValidator as en, createCheckboxValidator as eo, createDateValidator as ep, createPhoneValidator as eq, createCurrencyValidator as er, createStatusValidator as es, createSelectValidator as et, createMultiselectValidator as eu, createLocationValidator as ev, createFileValidator as ew, createUserValidator as ex, createSingleRelationValidator as ey, createMultiRelationValidator as ez, type StatusAttribute as f, ConditionExecutor as f$, initializePinCodeService as f0, type PinCodeGenerationOptions as f1, type PinCodeVerificationResult as f2, type CacheKeyType as f3, hashOptions as f4, type CacheAdapter as f5, type CacheOptions as f6, cacheKeys as f7, cacheTtl as f8, defaultTtl as f9, getSchemaContext as fA, getSchemaFromContext as fB, hasSchemaContext as fC, runWithMergedSchemaContext as fD, runWithSchemaContext as fE, type SchemaContext as fF, getContext as fG, getTenantId as fH, getUserId as fI, hasContext as fJ, runWithContext as fK, withTenantContext as fL, type TenantContext as fM, createDefaultExecutorRegistry as fN, getDefaultExecutorRegistry as fO, type ExecutorCompleteResult as fP, type ExecutorContext as fQ, type ExecutorErrorResult as fR, type ExecutorResult as fS, type ExecutorSuccessResult as fT, type ExecutorWaitResult as fU, type NodeExecutor as fV, complete as fW, error as fX, ExecutorRegistry as fY, success as fZ, wait as f_, NoopCacheAdapter as fa, type FetchResult as fb, type FormattedRecord as fc, type GroupedFetchResult as fd, type InsertOptions as fe, type QueryBuilderState as ff, type RegistryMap as fg, type RegistryObjectNames as fh, type ShortcutOperator as fi, createDefaultState as fj, formatRecord as fk, formatRecords as fl, QueryMultipleResultsError as fm, QueryNoResultError as fn, SHORTCUT_TO_FILTER_OPERATOR as fo, createQueryBuilder as fp, QueryBuilder as fq, type QueryBuilderOptions as fr, type EvaluationResult as fs, type EvaluationTrace as ft, evaluateCondition as fu, evaluate as fv, evaluateWithTrace as fw, TenantContextError as fx, addSchemaToContext as fy, getSchemaByNameFromContext as fz, type SelectAttribute as g, TenantAwareService as g$, EndExecutor as g0, FormExecutor as g1, StartExecutor as g2, evaluateFormula as g3, evaluateFormulaAttribute as g4, evaluateFormulaAttributeWithRelations as g5, evaluateFormulaWithRelations as g6, evaluateFormulaWithResult as g7, extractFormulaVariables as g8, extractRelationNames as g9, type HookHandler as gA, type HookType as gB, NoopHookRegistry as gC, type HookRegistry as gD, createMockAdapter as gE, defaultPolicyRegistry as gF, PolicyRegistry as gG, notesPolicy as gH, type ObjectsRepository as gI, type AttributesRepository as gJ, type UserProfilesRepository as gK, type FilesRepository as gL, type ObjectRecordsRepository as gM, type ViewsRepository as gN, type WorkflowsRepository as gO, type WorkflowInstancesRepository as gP, type WorkflowParticipationsRepository as gQ, type AuditRepository as gR, type PermissionsRepository as gS, type AIConversationsRepository as gT, type AIUserMemoryRepository as gU, type AIUsageMetricsRepository as gV, BaseService as gW, BaseRepository as gX, type SchemaContextAware as gY, SchemaContextAwareRepository as gZ, TenantAwareRepository as g_, extractRelationReferences as ga, flattenRelationsForEval as gb, formatFormulaResult as gc, hasRelationReferences as gd, validateFormulaExpression as ge, type FormulaResult as gf, getPathDepth as gg, getRelationPath as gh, getTargetAttributeName as gi, InvalidPathError as gj, MaxDepthExceededError as gk, parsePath as gl, pathHasManyCardinality as gm, validatePath as gn, type PathCardinality as go, type PathSegment as gp, type PathSegmentType as gq, type SchemaResolver as gr, resolveMultiplePaths as gs, resolveSingleValue as gt, traversePath as gu, type TraversalOptions as gv, type TraversalResult as gw, type AttributeChange as gx, type HookContext as gy, type HookDefinition as gz, type SingleRelationAttribute as h, AuditService as h$, type CreateCustomObjectInput as h0, type AddAttributeInput as h1, type UpdateObjectInput as h2, type ObjectSchemaServiceOptions as h3, ObjectSchemaService as h4, type RecordServiceOptions as h5, RecordService as h6, type RecordQueryServiceOptions as h7, type QueryOptions as h8, type SearchQueryOptions as h9, enrichWithFormulas as hA, enrichRecordsWithFormulas as hB, createContextForCreate as hC, createContextForUpdate as hD, createContextForDelete as hE, createContextForRestore as hF, recalculateParentRollups as hG, type RollupCascadeContext as hH, type CreateWorkflowInput as hI, type UpdateWorkflowInput as hJ, type WorkflowServiceOptions as hK, WorkflowService as hL, type StartWorkflowInput as hM, type ResumeWorkflowInput as hN, type WorkflowInstanceServiceOptions as hO, WorkflowInstanceService as hP, type CreateParticipationInput as hQ, type CreateParticipationResult as hR, type AuthenticationResult as hS, WorkflowParticipationService as hT, type FieldReadOnlyResult as hU, WorkflowRelationService as hV, type UserValidationResult as hW, type UserValidationError as hX, UserService as hY, type UserProfileServiceOptions as hZ, UserProfileService as h_, type QueryResult as ha, RecordQueryService as hb, type RelationValidationResult as hc, type RelationValidationError as hd, type RelationOption as he, type RelationOptionsResponse as hf, type GetRelationOptionsParams as hg, type RelationServiceOptions as hh, type ResolveIdsBatchRequest as hi, type ResolveIdsBatchResponse as hj, RelationService as hk, type ResolvedRelations as hl, RelationResolverService as hm, type RollupResult as hn, RollupService as ho, type RollupSchedulerOptions as hp, RollupScheduler as hq, applyDefaultValues as hr, checkPermission as hs, getPolicy as ht, buildPolicyContext as hu, checkRecordAccess as hv, checkRecordModifyOrThrow as hw, checkRecordDeleteOrThrow as hx, computeLabel as hy, type LabelResolver as hz, type MultiRelationAttribute as i, type ViewSyncResult as i$, buildAuditChanges as i0, type FileServiceOptions as i1, FileService as i2, GeocodingService as i3, GlobalSearchService as i4, type PermissionServiceOptions as i5, PermissionService as i6, type CreateViewInput as i7, type UpdateViewInput as i8, ViewService as i9, type CreateDBObject as iA, type UpdateDBObject as iB, type UpsertDBObject as iC, type DBAttribute as iD, type CreateDBAttribute as iE, type UpdateDBAttribute as iF, type UpsertDBAttribute as iG, type CreateObjectRecord as iH, type ListOptions as iI, type SearchOptions as iJ, type GlobalSearchOptions as iK, type GlobalSearchResultItem as iL, type FileListOptions as iM, type DBView as iN, type CreateDBView as iO, type UpdateDBView as iP, type UpsertDBView as iQ, type DBWorkflow as iR, type CreateDBWorkflow as iS, type UpdateDBWorkflow as iT, type DBWorkflowInstance as iU, type CreateDBWorkflowInstance as iV, type UpdateDBWorkflowInstance as iW, type DBWorkflowParticipation as iX, type CreateDBWorkflowParticipation as iY, type UpdateDBWorkflowParticipation as iZ, type OperationResult as i_, type FileContent as ia, type StorageUploadInput as ib, type StorageUploadResult as ic, type SignedUrlOptions as id, type StorageAdapter as ie, type UploadFileInput as ig, type SyncResult as ih, type SyncOptions as ii, syncNativeObjects as ij, verifyNativeObjectsSync as ik, getSyncPreview as il, type FullSyncResult as im, type FullSyncOptions as io, syncAll as ip, DEFAULT_LABEL_FALLBACK as iq, renderLabelExpression as ir, isLabelExpression as is, extractAttributeNames as it, enrichValuesForDisplay as iu, enrichValuesWithSelectLabels as iv, extractRelationIds as iw, type RelationLabelResolver as ix, computeLabelWithRelations as iy, type DBObject as iz, type RelationTarget as j, type ViewSyncOptions as j0, syncNativeViews as j1, verifyNativeViewsSync as j2, getViewSyncPreview as j3, type RatingAttribute as k, type FormulaAttribute as l, type FormulaReturnType as m, type RollupAttribute as n, type RollupFunction as o, type AttributeType as p, type ObjectDefinition as q, type Field as r, type AttributeGroupField as s, type TableTab as t, type InverseTableTab as u, type ViewDefinition as v, type InstanceStatus as w, type Tab as x, type FilterState as y, type SortRule as z };
+export { type FlowRow as $, type Attribute as A, type DirectTableTab as B, type CheckboxAttribute as C, type DateAttribute as D, type WorkflowConfig as E, type FileAttribute as F, type Group as G, type SlotMode as H, type InferAttributeValue as I, type AuthMethod as J, type AuthChannel as K, type LocationAttribute as L, type MultiselectAttribute as M, type NumberAttribute as N, type ObjectAction as O, type PhoneAttribute as P, type ParticipantTemplate as Q, type RichtextAttribute as R, type SystemResource as S, type TextAttribute as T, type UserAttribute as U, type ViewLayout as V, type WorkflowTheme as W, type ConditionGroup as X, type ConditionRule as Y, type WorkflowNode as Z, type WorkflowDefinition as _, type SystemAction as a, type AuditListOptions as a$, type BlockNoteContent as a0, type AIMessageRole as a1, type AIThinkingLevel as a2, type AIToolCallStatus as a3, type AIToolCall as a4, type AIChatMessagePartType as a5, type TextPartData as a6, type ToolPartData as a7, type ThinkingPartData as a8, type ReasoningPartData as a9, type LocationGranularity as aA, RELATION_TARGET_ANY as aB, type RelationAttribute as aC, isUniversalRelation as aD, type BlockNoteBlock as aE, type BlockNoteCustomInlineContent as aF, type BlockNoteDefaultProps as aG, type BlockNoteInlineContent as aH, type BlockNoteLink as aI, type BlockNoteStyledText as aJ, type BlockNoteStyles as aK, type BlockNoteTableCell as aL, type BlockNoteTableCellProps as aM, type BlockNoteTableContent as aN, type PartialBlockNoteBlock as aO, type PartialBlockNoteContent as aP, type PartialBlockNoteInlineContent as aQ, type PartialBlockNoteLink as aR, type PartialBlockNoteStyledText as aS, type PartialBlockNoteTableCell as aT, type PartialBlockNoteTableContent as aU, type AuditResourceType as aV, type AuditAction as aW, type AuditActorType as aX, type AuditChange as aY, type AuditLogEntry as aZ, type CreateAuditLogInput as a_, type AIChatMessagePart as aa, type AIChatMessage as ab, type AIQuestionType as ac, type AIQuestionOption as ad, type AIQuestion as ae, type AIQuestionAnswer as af, type AITodoStatus as ag, type AITodoItem as ah, type AITodoList as ai, type AIMessageAttachment as aj, type AIConversation as ak, type AIMessage as al, type AIToolCallRecord as am, type AIUserMemory as an, type AIUsageMetrics as ao, type AIProviderMetrics as ap, type CreateAIMessageInput as aq, type StatusGroup as ar, type AttributeGroup as as, type BaseAttribute as at, type NumberUnit as au, type DateFormat as av, type DateValue as aw, type Phone as ax, type Currency as ay, type Location as az, type TextAreaAttribute as b, type ExtractRecordInputStrict as b$, type AuditServiceOptions as b0, type StorageProvider as b1, type FileVisibility as b2, type File as b3, type CreateFile as b4, type UpdateFile as b5, type TextFilterOperator as b6, type NumberFilterOperator as b7, type CheckboxFilterOperator as b8, type DateFilterOperator as b9, type FlowStatus as bA, type FlowDefinition as bB, isFlowDefinition as bC, isFlowPublished as bD, isSystemFlow as bE, type GeocodingSuggestion as bF, type GeocodingAutocompleteParams as bG, type ReverseGeocodingParams as bH, type GeocodingParams as bI, type GeocodingAdapter as bJ, NoopGeocodingAdapter as bK, type AttributeSchema as bL, type InferRecordFromSchema as bM, type InferRecordWithRequirements as bN, type TypedAttribute as bO, type AttributeMap as bP, type AddAttribute as bQ, type InferRecord as bR, type InferRecordInput as bS, type InferRecordUpdate as bT, type CustomAttributeValue as bU, type WithCustomAttributes as bV, type RecordMetadata as bW, type SystemFields as bX, type ExtractRecord as bY, type ExtractRecordStrict as bZ, type ExtractRecordInput as b_, type SelectFilterOperator as ba, type MultiselectFilterOperator as bb, type RelationFilterOperator as bc, type FilterOperator as bd, type RelativeDateValue as be, type CurrencyFilterValue as bf, type PhoneFilterValue as bg, type FilterValue as bh, type FilterRule as bi, type ExtendedFilterRule as bj, type FilterCombinator as bk, type FilterGroup as bl, type AdvancedFilterState as bm, isAdvancedFilterState as bn, toAdvancedFilterState as bo, toSimpleFilterState as bp, type SortDirection as bq, type QueryState as br, OPERATORS_BY_TYPE as bs, type NoValueOperator as bt, NO_VALUE_OPERATORS as bu, isNoValueOperator as bv, type FlowSlot as bw, type FlowRowField as bx, type FlowPage as by, type FlowRelation as bz, type RichtextFeature as c, isConditionGroup as c$, type ExtractRecordUpdate as c0, type ExtractRecordUpdateStrict as c1, type ExtractAttributes as c2, type TypedObjectRecord as c3, type ExtractObjectRecord as c4, type ExtractObjectRecordWithCustom as c5, RESERVED_ATTRIBUTE_NAMES as c6, SYSTEM_FIELD_NAMES as c7, type ReservedAttributeName as c8, type SystemFieldName as c9, type CustomTab as cA, type ActivityTab as cB, type NotesTab as cC, type FlowsTab as cD, isFormTab as cE, isTableTab as cF, isDirectTableTab as cG, isInverseTableTab as cH, isCustomTab as cI, isActivityTab as cJ, isNotesTab as cK, isFlowsTab as cL, type StartNode as cM, type FormNode as cN, type FormFieldRef as cO, type ConditionNode as cP, type EndNode as cQ, type WorkflowNodeType as cR, isStartNode as cS, isFormNode as cT, isConditionNode as cU, isEndNode as cV, isSimpleFormNode as cW, isAdvancedFormNode as cX, getNodeOutputs as cY, type ConditionOperator as cZ, isConditionRule as c_, type Timestamps as ca, type ObjectAttribute as cb, type CompletionStatus as cc, type ObjectRecord as cd, type PermissionScope as ce, type Role as cf, type Permission as cg, type UserRoleAssignment as ch, type EffectivePermissions as ci, type ObjectPermissions as cj, type SystemPermissions as ck, type CreateRoleInput as cl, type UpdateRoleInput as cm, type CreatePermissionInput as cn, type AssignRoleInput as co, type PolicyContext as cp, type RecordPolicy as cq, PolicyViolationError as cr, type UserRole as cs, type UserStatus as ct, type UserProfile as cu, type CreateUserProfile as cv, type UpdateUserProfile as cw, type InviteUserInput as cx, type TabType as cy, type FormTab as cz, type CurrencyAttribute as d, DEFAULT_VALIDATION_MESSAGES as d$, eq as d0, neq as d1, and as d2, or as d3, inValues as d4, isEmpty as d5, isNotEmpty as d6, type WorkflowSlot as d7, type NodePosition as d8, type CanvasViewport as d9, type WorkflowExecutionContext as dA, createEmptyContext as dB, getContextValue as dC, setContextValue as dD, mergeFormToSlot as dE, type WorkflowAccessMode as dF, type ReadOnlyReason as dG, type FormFieldContext as dH, type FormFieldRow as dI, type FormNodeInfo as dJ, type FormContextResponse as dK, type ThemeLogo as dL, type ThemeColors as dM, type ThemeTypography as dN, DEFAULT_THEME as dO, mergeWithDefaults as dP, generateCssVariables as dQ, type Uuid as dR, type TenantId as dS, type UserId as dT, asTenantId as dU, asUserId as dV, generateId as dW, generatePrefixedId as dX, registry as dY, viewRegistry as dZ, type ValidationMessages as d_, type WorkflowLayout as da, type ParticipantAuthConfig as db, type WorkflowStatus as dc, isWorkflowDefinition as dd, isWorkflowPublished as de, isSystemWorkflow as df, type WorkflowTransition as dg, type WorkflowError as dh, type PendingAction as di, type WorkflowInstance as dj, isInstanceTerminal as dk, isInstanceWaiting as dl, canResumeInstance as dm, createStartTransition as dn, type ParticipationStatus as dp, type SignedLinkAuth as dq, type PinCodeAuth as dr, type ParticipationAuth as ds, type WorkflowParticipation as dt, isSignedLinkAuth as du, isPinCodeAuth as dv, canParticipate as dw, canAuthenticate as dx, canExecuteNode as dy, type GeneratedDocument as dz, type Option as e, PinCodeService as e$, textConfigSchema as e0, textareaConfigSchema as e1, richtextConfigSchema as e2, numberConfigSchema as e3, checkboxConfigSchema as e4, dateConfigSchema as e5, phoneConfigSchema as e6, currencyConfigSchema as e7, statusConfigSchema as e8, locationConfigSchema as e9, createMultiRelationValidator as eA, createRelationValidator as eB, createRatingValidator as eC, createFormulaValidator as eD, createRollupValidator as eE, createTextAreaValidator as eF, createRichtextValidator as eG, createAttributeValidator as eH, createFormAttributeValidator as eI, createObjectValidator as eJ, type ValidationResult as eK, validateAttribute as eL, validateObject as eM, validateObjectOrThrow as eN, createDraftValidator as eO, validateDraft as eP, validateDraftOrThrow as eQ, getMissingRequiredAttributes as eR, isRecordComplete as eS, computeRecordStatus as eT, type DatabaseAdapter as eU, ParticipationTokenService as eV, getDefaultTokenService as eW, initializeTokenService as eX, type ParticipationTokenPayload as eY, type TokenGenerationOptions as eZ, type TokenVerificationResult as e_, selectConfigSchema as ea, multiselectConfigSchema as eb, fileConfigSchema as ec, userConfigSchema as ed, relationConfigSchema as ee, ratingConfigSchema as ef, formulaConfigSchema as eg, rollupConfigSchema as eh, attributeConfigSchemas as ei, getAttributeConfigSchema as ej, validateAttributeConfig as ek, parseAttributeConfig as el, safeParseAttributeConfig as em, createTextValidator as en, createNumberValidator as eo, createCheckboxValidator as ep, createDateValidator as eq, createPhoneValidator as er, createCurrencyValidator as es, createStatusValidator as et, createSelectValidator as eu, createMultiselectValidator as ev, createLocationValidator as ew, createFileValidator as ex, createUserValidator as ey, createSingleRelationValidator as ez, type StatusAttribute as f, wait as f$, getDefaultPinCodeService as f0, initializePinCodeService as f1, type PinCodeGenerationOptions as f2, type PinCodeVerificationResult as f3, type CacheKeyType as f4, hashOptions as f5, type CacheAdapter as f6, type CacheOptions as f7, cacheKeys as f8, cacheTtl as f9, getSchemaByNameFromContext as fA, getSchemaContext as fB, getSchemaFromContext as fC, hasSchemaContext as fD, runWithMergedSchemaContext as fE, runWithSchemaContext as fF, type SchemaContext as fG, getContext as fH, getTenantId as fI, getUserId as fJ, hasContext as fK, runWithContext as fL, withTenantContext as fM, type TenantContext as fN, createDefaultExecutorRegistry as fO, getDefaultExecutorRegistry as fP, type ExecutorCompleteResult as fQ, type ExecutorContext as fR, type ExecutorErrorResult as fS, type ExecutorResult as fT, type ExecutorSuccessResult as fU, type ExecutorWaitResult as fV, type NodeExecutor as fW, complete as fX, error as fY, ExecutorRegistry as fZ, success as f_, defaultTtl as fa, NoopCacheAdapter as fb, type FetchResult as fc, type FormattedRecord as fd, type GroupedFetchResult as fe, type InsertOptions as ff, type QueryBuilderState as fg, type RegistryMap as fh, type RegistryObjectNames as fi, type ShortcutOperator as fj, createDefaultState as fk, formatRecord as fl, formatRecords as fm, QueryMultipleResultsError as fn, QueryNoResultError as fo, SHORTCUT_TO_FILTER_OPERATOR as fp, createQueryBuilder as fq, QueryBuilder as fr, type QueryBuilderOptions as fs, type EvaluationResult as ft, type EvaluationTrace as fu, evaluateCondition as fv, evaluate as fw, evaluateWithTrace as fx, TenantContextError as fy, addSchemaToContext as fz, type SelectAttribute as g, TenantAwareRepository as g$, ConditionExecutor as g0, EndExecutor as g1, FormExecutor as g2, StartExecutor as g3, evaluateFormula as g4, evaluateFormulaAttribute as g5, evaluateFormulaAttributeWithRelations as g6, evaluateFormulaWithRelations as g7, evaluateFormulaWithResult as g8, extractFormulaVariables as g9, type HookDefinition as gA, type HookHandler as gB, type HookType as gC, NoopHookRegistry as gD, type HookRegistry as gE, createMockAdapter as gF, defaultPolicyRegistry as gG, PolicyRegistry as gH, notesPolicy as gI, type ObjectsRepository as gJ, type AttributesRepository as gK, type UserProfilesRepository as gL, type FilesRepository as gM, type ObjectRecordsRepository as gN, type ViewsRepository as gO, type WorkflowsRepository as gP, type WorkflowInstancesRepository as gQ, type WorkflowParticipationsRepository as gR, type AuditRepository as gS, type PermissionsRepository as gT, type AIConversationsRepository as gU, type AIUserMemoryRepository as gV, type AIUsageMetricsRepository as gW, BaseService as gX, BaseRepository as gY, type SchemaContextAware as gZ, SchemaContextAwareRepository as g_, extractRelationNames as ga, extractRelationReferences as gb, flattenRelationsForEval as gc, formatFormulaResult as gd, hasRelationReferences as ge, validateFormulaExpression as gf, type FormulaResult as gg, getPathDepth as gh, getRelationPath as gi, getTargetAttributeName as gj, InvalidPathError as gk, MaxDepthExceededError as gl, parsePath as gm, pathHasManyCardinality as gn, validatePath as go, type PathCardinality as gp, type PathSegment as gq, type PathSegmentType as gr, type SchemaResolver as gs, resolveMultiplePaths as gt, resolveSingleValue as gu, traversePath as gv, type TraversalOptions as gw, type TraversalResult as gx, type AttributeChange as gy, type HookContext as gz, type SingleRelationAttribute as h, type UserValidationError as h$, TenantAwareService as h0, type CreateCustomObjectInput as h1, type AddAttributeInput as h2, type UpdateObjectInput as h3, type ObjectSchemaServiceOptions as h4, ObjectSchemaService as h5, type RecordServiceOptions as h6, RecordService as h7, type RecordQueryServiceOptions as h8, type QueryOptions as h9, checkRecordModifyOrThrow as hA, checkRecordDeleteOrThrow as hB, computeLabel as hC, type LabelResolver as hD, enrichWithFormulas as hE, enrichRecordsWithFormulas as hF, createContextForCreate as hG, createContextForUpdate as hH, createContextForDelete as hI, createContextForRestore as hJ, recalculateParentRollups as hK, type RollupCascadeContext as hL, type CreateWorkflowInput as hM, type UpdateWorkflowInput as hN, type WorkflowServiceOptions as hO, WorkflowService as hP, type StartWorkflowInput as hQ, type ResumeWorkflowInput as hR, type WorkflowInstanceServiceOptions as hS, WorkflowInstanceService as hT, type CreateParticipationInput as hU, type CreateParticipationResult as hV, type AuthenticationResult as hW, WorkflowParticipationService as hX, type FieldReadOnlyResult as hY, WorkflowRelationService as hZ, type UserValidationResult as h_, type SearchQueryOptions as ha, type QueryResult as hb, RecordQueryService as hc, type RelationValidationResult as hd, type RelationValidationError as he, type RelationOption as hf, type RelationOptionsResponse as hg, type GetRelationOptionsParams as hh, type RelationServiceOptions as hi, type ResolveIdsBatchRequest as hj, type ResolveIdsBatchResponse as hk, RelationService as hl, RecordResolverService as hm, type ResolvedRelations as hn, type FormulaResolverServiceOptions as ho, FormulaResolverService as hp, type RollupResult as hq, type RollupServiceOptions as hr, RollupService as hs, type RollupSchedulerOptions as ht, RollupScheduler as hu, applyDefaultValues as hv, checkPermission as hw, getPolicy as hx, buildPolicyContext as hy, checkRecordAccess as hz, type MultiRelationAttribute as i, type DBWorkflowParticipation as i$, UserService as i0, type UserProfileServiceOptions as i1, UserProfileService as i2, AuditService as i3, buildAuditChanges as i4, type FileServiceOptions as i5, FileService as i6, GeocodingService as i7, GlobalSearchService as i8, type PermissionServiceOptions as i9, extractRelationIds as iA, type RelationLabelResolver as iB, computeLabelWithRelations as iC, type DBObject as iD, type CreateDBObject as iE, type UpdateDBObject as iF, type UpsertDBObject as iG, type DBAttribute as iH, type CreateDBAttribute as iI, type UpdateDBAttribute as iJ, type UpsertDBAttribute as iK, type CreateObjectRecord as iL, type ListOptions as iM, type SearchOptions as iN, type GlobalSearchOptions as iO, type GlobalSearchResultItem as iP, type FileListOptions as iQ, type DBView as iR, type CreateDBView as iS, type UpdateDBView as iT, type UpsertDBView as iU, type DBWorkflow as iV, type CreateDBWorkflow as iW, type UpdateDBWorkflow as iX, type DBWorkflowInstance as iY, type CreateDBWorkflowInstance as iZ, type UpdateDBWorkflowInstance as i_, PermissionService as ia, type CreateViewInput as ib, type UpdateViewInput as ic, ViewService as id, type FileContent as ie, type StorageUploadInput as ig, type StorageUploadResult as ih, type SignedUrlOptions as ii, type StorageAdapter as ij, type UploadFileInput as ik, type SyncResult as il, type SyncOptions as im, syncNativeObjects as io, verifyNativeObjectsSync as ip, getSyncPreview as iq, type FullSyncResult as ir, type FullSyncOptions as is, syncAll as it, DEFAULT_LABEL_FALLBACK as iu, renderLabelExpression as iv, isLabelExpression as iw, extractAttributeNames as ix, enrichValuesForDisplay as iy, enrichValuesWithSelectLabels as iz, type RelationTarget as j, type CreateDBWorkflowParticipation as j0, type UpdateDBWorkflowParticipation as j1, type OperationResult as j2, type ViewSyncResult as j3, type ViewSyncOptions as j4, syncNativeViews as j5, verifyNativeViewsSync as j6, getViewSyncPreview as j7, type RatingAttribute as k, type FormulaAttribute as l, type FormulaReturnType as m, type RollupAttribute as n, type RollupFunction as o, type AttributeType as p, type ObjectDefinition as q, type Field as r, type AttributeGroupField as s, type TableTab as t, type InverseTableTab as u, type ViewDefinition as v, type InstanceStatus as w, type Tab as x, type FilterState as y, type SortRule as z };