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

package/dist/{runtime-BbM_jyVU.d.ts → runtime-C8IgSFtA.d.ts}

@@ -1,6 +1,295 @@
 import { ColorId, IconName, CountryIso3, CurrencyCode, MimeType } from '@stndrds/constants';
 import { z } from 'zod';
 
+/**
+ * Message role in a conversation
+ */
+type AIMessageRole = "user" | "assistant";
+/**
+ * Level of "thinking" or reasoning depth
+ */
+type AIThinkingLevel = "none" | "light" | "deep" | "maximum";
+/**
+ * Tool call status during execution
+ */
+type AIToolCallStatus = "pending" | "running" | "success" | "error";
+/**
+ * Tool call information for chat UI
+ */
+interface AIToolCall {
+    /** Unique tool call ID */
+    id: string;
+    /** Tool name */
+    name: string;
+    /** Tool arguments */
+    args?: Record<string, unknown>;
+    /** Tool result (when complete) */
+    result?: unknown;
+    /** Error message if failed */
+    error?: string;
+    /** Execution status */
+    status: AIToolCallStatus;
+}
+/**
+ * Part type for message content
+ */
+type AIChatMessagePartType = "text" | "attachment" | "tool" | "thinking" | "reasoning" | "todo" | "question" | "error" | "approval" | "record" | "search-results" | (string & {});
+/**
+ * Data for text part
+ */
+interface TextPartData {
+    text: string;
+    isStreaming?: boolean;
+}
+/**
+ * Data for tool part (same as AIToolCall)
+ */
+interface ToolPartData {
+    id: string;
+    name: string;
+    args?: Record<string, unknown>;
+    result?: unknown;
+    error?: string;
+    status: AIToolCallStatus;
+}
+/**
+ * Data for thinking part
+ */
+interface ThinkingPartData {
+    isStreaming: boolean;
+    startTime?: number;
+}
+/**
+ * Data for reasoning part (Extended Thinking content)
+ */
+interface ReasoningPartData {
+    /** Reasoning content (accumulated during streaming) */
+    content: string;
+    /** Whether reasoning is still streaming */
+    isStreaming: boolean;
+    /** Start timestamp for elapsed time display */
+    startTime?: number;
+}
+/**
+ * A part of a chat message.
+ * Parts are ordered chronologically as they arrive from the stream.
+ */
+interface AIChatMessagePart {
+    /** Part type */
+    type: AIChatMessagePartType;
+    /** Unique part ID */
+    id: string;
+    /** Part-specific data */
+    data: unknown;
+}
+/**
+ * Chat message for runtime/streaming.
+ *
+ * All content is represented as ordered parts (text, tools, thinking, etc.)
+ * Parts are in chronological order as they arrive from the stream.
+ *
+ * Used in:
+ * - useAgentChat hook
+ * - AI chat UI components
+ * - Stream processing
+ */
+interface AIChatMessage {
+    /** Unique message ID */
+    id: string;
+    /** Message role */
+    role: AIMessageRole;
+    /** Ordered message parts (text, tools, thinking, etc.) */
+    parts: AIChatMessagePart[];
+    /** Whether the message is still streaming */
+    isStreaming?: boolean;
+    /** Message timestamp */
+    timestamp?: Date;
+    /** Error message if the message failed */
+    error?: string;
+}
+/**
+ * Question types supported by the agent
+ */
+type AIQuestionType = "text" | "choice" | "confirm" | "multiselect";
+/**
+ * Option for choice/multiselect questions
+ */
+interface AIQuestionOption {
+    value: string;
+    label: string;
+    description?: string;
+}
+/**
+ * Question from the agent to the user
+ */
+interface AIQuestion {
+    /** Unique question ID */
+    id: string;
+    /** Question type */
+    type: AIQuestionType;
+    /** Question text */
+    question: string;
+    /** Options for choice/multiselect */
+    options?: AIQuestionOption[];
+    /** Placeholder for text input */
+    placeholder?: string;
+    /** Whether answer is required */
+    required?: boolean;
+    /** Min selections for multiselect */
+    minSelections?: number;
+    /** Max selections for multiselect */
+    maxSelections?: number;
+}
+/**
+ * Answer format for questions
+ */
+type AIQuestionAnswer = {
+    type: "text";
+    value: string;
+} | {
+    type: "choice";
+    value: string;
+} | {
+    type: "confirm";
+    value: boolean;
+} | {
+    type: "multiselect";
+    value: string[];
+};
+/**
+ * Todo item status
+ */
+type AITodoStatus = "pending" | "in_progress" | "completed" | "blocked";
+/**
+ * Todo item in a task list
+ */
+interface AITodoItem {
+    id: string;
+    description: string;
+    status: AITodoStatus;
+    result?: string;
+    updatedAt?: number;
+}
+/**
+ * Todo list managed by the agent
+ */
+interface AITodoList {
+    items: AITodoItem[];
+    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
+ */
+interface AIConversation {
+    id: string;
+    tenantId: string;
+    userId: string;
+    title: string | null;
+    messageCount: number;
+    totalTokens: number;
+    totalCost: number;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt: Date | null;
+}
+/**
+ * AI Message record
+ */
+interface AIMessage {
+    id: string;
+    conversationId: string;
+    role: AIMessageRole;
+    content: string;
+    thinkingLevel: AIThinkingLevel | null;
+    thinkingSummary: string | null;
+    toolCalls: AIToolCallRecord[] | null;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cost: number | null;
+    provider: string | null;
+    model: string | null;
+    /** File attachment IDs (references files table) */
+    attachmentIds: string[] | null;
+    /** Resolved attachments (populated when fetching messages) */
+    attachments?: AIMessageAttachment[];
+    createdAt: Date;
+}
+/**
+ * Tool call record stored in JSONB
+ */
+interface AIToolCallRecord {
+    /** Tool call ID (from AI SDK) for matching call with result */
+    id?: string;
+    name: string;
+    args: unknown;
+    result?: unknown;
+    error?: string;
+    /** Reasoning/thinking that occurred before this tool call */
+    reasoningBefore?: string;
+}
+/**
+ * AI User Memory record
+ */
+interface AIUserMemory {
+    id: string;
+    tenantId: string;
+    userId: string;
+    preferences: Record<string, unknown>;
+    facts: string[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * AI Usage Metrics record
+ */
+interface AIUsageMetrics {
+    id: string;
+    tenantId: string;
+    date: Date;
+    requestCount: number;
+    totalTokens: number;
+    totalCost: number;
+    providerBreakdown: Record<string, AIProviderMetrics>;
+    toolUsage: Record<string, number>;
+}
+/**
+ * Provider-specific metrics
+ */
+interface AIProviderMetrics {
+    requests: number;
+    tokens: number;
+    cost: number;
+}
+/**
+ * Input for creating an AI message
+ */
+interface CreateAIMessageInput {
+    conversationId: string;
+    role: AIMessageRole;
+    content: string;
+    thinkingLevel?: AIThinkingLevel;
+    thinkingSummary?: string;
+    toolCalls?: AIToolCallRecord[];
+    inputTokens?: number;
+    outputTokens?: number;
+    cost?: number;
+    provider?: string;
+    model?: string;
+    /** File attachment IDs (references files table) */
+    attachmentIds?: string[];
+}
+
 /**
  * Brand symbol for nominal typing.
  * This ensures type-safety by making IDs non-interchangeable.
@@ -4473,8 +4762,8 @@ declare const statusConfigSchema: z.ZodObject<{
         icon: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
         group: z.ZodOptional<z.ZodEnum<{
-            idle: "idle";
             in_progress: "in_progress";
+            idle: "idle";
             finished: "finished";
         }>>;
     }, z.core.$strip>>;
@@ -4533,8 +4822,8 @@ declare const selectConfigSchema: z.ZodObject<{
         icon: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
         group: z.ZodOptional<z.ZodEnum<{
-            idle: "idle";
             in_progress: "in_progress";
+            idle: "idle";
             finished: "finished";
         }>>;
     }, z.core.$strip>>;
@@ -4561,8 +4850,8 @@ declare const multiselectConfigSchema: z.ZodObject<{
         icon: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
         group: z.ZodOptional<z.ZodEnum<{
-            idle: "idle";
             in_progress: "in_progress";
+            idle: "idle";
             finished: "finished";
         }>>;
     }, z.core.$strip>>;
@@ -4715,8 +5004,8 @@ declare const rollupConfigSchema: z.ZodObject<{
         icon: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
         group: z.ZodOptional<z.ZodEnum<{
-            idle: "idle";
             in_progress: "in_progress";
+            idle: "idle";
             finished: "finished";
         }>>;
     }, z.core.$strip>>>;
@@ -5391,12 +5680,17 @@ interface UserProfilesRepository {
 interface FilesRepository {
     /**
      * Find file by ID.
-     * Automatically filtered by current tenant context.
+     * Returns file with signed URL. Automatically filtered by current tenant context.
      */
     findById(id: Uuid): Promise<File | null>;
+    /**
+     * Find multiple files by IDs.
+     * Returns files with signed URLs. Automatically filtered by current tenant context.
+     */
+    findByIds(ids: Uuid[]): Promise<File[]>;
     /**
      * Create file.
-     * Tenant ID is automatically set from context.
+     * Returns file with signed URL. Tenant ID is automatically set from context.
      */
     create(data: CreateFile): Promise<File>;
     /**
@@ -5969,6 +6263,150 @@ interface PermissionsRepository {
     getEffectivePermissions(userProfileId: Uuid): Promise<EffectivePermissions>;
 }
 
+/**
+ * Repository for AI conversations and messages.
+ *
+ * This repository is optional - if not provided in the DatabaseAdapter,
+ * AI conversation history features are disabled.
+ *
+ * All operations are automatically scoped to the current tenant
+ * from the execution context (via AsyncLocalStorage).
+ */
+interface AIConversationsRepository {
+    /**
+     * Find conversation by ID.
+     * Automatically filtered by current tenant context.
+     */
+    findById(id: Uuid): Promise<AIConversation | null>;
+    /**
+     * List conversations for current user.
+     * Automatically filtered by current tenant and user context.
+     */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+        includeDeleted?: boolean;
+    }): Promise<{
+        conversations: AIConversation[];
+        total: number;
+    }>;
+    /**
+     * Create conversation.
+     * Tenant ID and User ID are automatically set from context.
+     */
+    create(data: {
+        title?: string;
+    }): Promise<AIConversation>;
+    /**
+     * Update conversation title.
+     * Automatically filtered by current tenant context.
+     */
+    updateTitle(id: Uuid, title: string): Promise<AIConversation | null>;
+    /**
+     * Soft delete conversation.
+     * Automatically filtered by current tenant context.
+     */
+    delete(id: Uuid): Promise<boolean>;
+    /**
+     * Add message to conversation.
+     * Automatically updates conversation stats.
+     */
+    addMessage(input: CreateAIMessageInput): Promise<AIMessage>;
+    /**
+     * List messages in a conversation.
+     * Automatically filtered by current tenant context (via conversation ownership).
+     */
+    listMessages(conversationId: Uuid, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        messages: AIMessage[];
+        total: number;
+    }>;
+    /**
+     * Get recent messages for context (last N messages).
+     * Returns messages ordered by created_at ASC.
+     */
+    getRecentMessages(conversationId: Uuid, count?: number): Promise<AIMessage[]>;
+}
+/**
+ * Repository for AI user memory (preferences and learned facts).
+ *
+ * This repository is optional - if not provided in the DatabaseAdapter,
+ * AI personalization features are disabled.
+ *
+ * All operations are automatically scoped to the current tenant and user
+ * from the execution context (via AsyncLocalStorage).
+ */
+interface AIUserMemoryRepository {
+    /**
+     * Get memory for current user.
+     * Automatically filtered by current tenant and user context.
+     * Returns null if no memory exists yet.
+     */
+    get(): Promise<AIUserMemory | null>;
+    /**
+     * Create or update memory for current user.
+     * Tenant ID and User ID are automatically set from context.
+     */
+    upsert(data: {
+        preferences?: Record<string, unknown>;
+        facts?: string[];
+    }): Promise<AIUserMemory>;
+    /**
+     * Add a fact to user memory.
+     * Automatically appends to existing facts.
+     */
+    addFact(fact: string): Promise<AIUserMemory>;
+    /**
+     * Remove a fact from user memory.
+     */
+    removeFact(fact: string): Promise<AIUserMemory>;
+    /**
+     * Update a specific preference.
+     */
+    setPreference(key: string, value: unknown): Promise<AIUserMemory>;
+    /**
+     * Clear all memory for current user.
+     */
+    clear(): Promise<void>;
+}
+/**
+ * Repository for AI usage metrics.
+ *
+ * This repository is optional - if not provided in the DatabaseAdapter,
+ * AI usage tracking is disabled.
+ *
+ * All operations are automatically scoped to the current tenant
+ * from the execution context (via AsyncLocalStorage).
+ */
+interface AIUsageMetricsRepository {
+    /**
+     * Record a usage event (increments counters for the current date).
+     * Automatically handles upsert for the current date.
+     */
+    recordUsage(data: {
+        provider: string;
+        tokens: number;
+        cost: number;
+        toolName?: string;
+    }): Promise<void>;
+    /**
+     * Get usage metrics for a date range.
+     * Automatically filtered by current tenant context.
+     */
+    getByDateRange(startDate: Date, endDate: Date): Promise<AIUsageMetrics[]>;
+    /**
+     * Get aggregated usage for current month.
+     * Automatically filtered by current tenant context.
+     */
+    getCurrentMonthUsage(): Promise<{
+        requestCount: number;
+        totalTokens: number;
+        totalCost: number;
+    }>;
+}
+
 /**
  * File content type - supports various formats
  * Use Uint8Array for cross-platform compatibility
@@ -6204,6 +6642,9 @@ interface DatabaseAdapter {
     audit?: AuditRepository;
     storage?: StorageAdapter;
     cache?: CacheAdapter;
+    aiConversations?: AIConversationsRepository;
+    aiUserMemory?: AIUserMemoryRepository;
+    aiUsageMetrics?: AIUsageMetricsRepository;
     transaction<T>(callback: (adapter: DatabaseAdapter) => Promise<T>): Promise<T>;
 }
 
@@ -7668,6 +8109,7 @@ interface RecordServiceOptions {
 declare class RecordService extends BaseService {
     private schemaService;
     private queryService;
+    private recordResolver;
     private relationService;
     private userService;
     private rollupService;
@@ -7773,55 +8215,431 @@ 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.
- */
-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
+ * @example
+ * extractAttributeNames("{{ firstName }} {{ lastName | UPPER }}")
+ * // → ["firstName", "lastName"]
  */
-interface RelationOptionsResponse {
-    options: RelationOption[];
-    hasMore: boolean;
-    total: number;
-}
+declare function extractAttributeNames(template: string): string[];
 /**
- * Parameters for fetching 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" }
+ * ```
+ */
+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>;
+
+/**
+ * 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>;
+
+/**
+ * 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 {
+    /**
+     * Record resolver for cached record fetching.
+     * Required for cached access to records.
+     */
+    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);
+    /**
+     * Calculate a rollup value for a record
+     *
+     * 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
+     * // 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
+     * );
+     * ```
+     */
+    calculate(recordId: string, rollupAttr: RollupAttribute, schema: ObjectDefinition): Promise<RollupResult>;
+    /**
+     * Internal method to compute rollup value (no caching)
+     */
+    private computeRollup;
+    /**
+     * Forward pattern: this record has a relation attribute pointing to other records
+     * Example: entreprise222 has relation "entreprises" → companies, rollup collects from companies
+     */
+    private calculateForward;
+    /**
+     * Reverse pattern: other records have a relation pointing to this record
+     * Example: Company has rollup on "orders", Order has relation "company" → companies
+     */
+    private calculateReverse;
+    /**
+     * Extract and aggregate values from related records
+     */
+    private aggregateValues;
+    /**
+     * Calculate rollup values for multiple records (batched)
+     *
+     * More efficient than calling calculate() for each record individually.
+     */
+    calculateForMany(recordIds: string[], rollupAttr: RollupAttribute, schema: ObjectDefinition): Promise<Map<string, RollupResult>>;
+    /**
+     * Apply aggregation function to a set of values
+     */
+    private aggregate;
+    /**
+     * Get the default empty value for a rollup function
+     */
+    private getEmptyValue;
+    /**
+     * 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
+     *
+     * 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
+     *
+     * 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
+     */
+    findAffectedParentRecords(changedRecord: ObjectRecord, changedSchema: ObjectDefinition): Promise<string[]>;
+    /**
+     * 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
+     */
+    invalidateAffectedRollups(affectedParentIds: string[]): Promise<void>;
+    /**
+     * Invalidate all cached rollups for the current tenant.
+     * Use sparingly - prefer targeted invalidation.
+     */
+    invalidateAllRollups(): Promise<void>;
+    /**
+     * 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
+     */
+    findRecordsWithForwardRollup(changedRecord: ObjectRecord, changedSchema: ObjectDefinition): Promise<ObjectRecord[]>;
+}
+
+/**
+ * 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>;
+
+/**
+ * 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);
+    /**
+     * Find a record by ID with caching.
+     *
+     * Uses the shared record cache for optimal performance.
+     * Delegates to findByIds for consistent cache handling.
+     *
+     * @param id - Record ID
+     * @returns Record or null if not found
+     */
+    findById(id: string): Promise<ObjectRecord | null>;
+    /**
+     * Find multiple records by IDs with caching.
+     *
+     * 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)
+     */
+    findByIds(ids: string[]): Promise<ObjectRecord[]>;
+    /**
+     * Create a RelationLabelResolver callback for computeLabelWithRelations.
+     *
+     * Used by RelationService.resolveLabel() and ObjectSchemaService.
+     *
+     * @returns Callback that resolves record IDs to their labels (cached)
+     */
+    createRelationLabelResolver(): RelationLabelResolver;
+    /**
+     * Create a LabelResolver interface for label computation helpers.
+     *
+     * Used by RecordService for computing record labels.
+     *
+     * @param relationService - RelationService for resolving relation display labels
+     * @returns LabelResolver interface with cached record fetching
+     */
+    createLabelResolver(relationService: RelationService): LabelResolver;
+    /**
+     * 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
+     */
+    createRollupContext(rollupService: RollupService, schemaService: ObjectSchemaService): RollupCascadeContext;
+}
+
+/**
+ * Result of relation validation
+ */
+interface RelationValidationResult {
+    valid: boolean;
+    errors: RelationValidationError[];
+}
+/**
+ * Individual relation validation error
+ */
+interface RelationValidationError {
+    /** Attribute name */
+    attribute: string;
+    /** Error message */
+    message: string;
+    /** Invalid record IDs */
+    invalidIds?: string[];
+}
+/**
+ * Resolved relation option
+ *
+ * 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 */
@@ -7845,6 +8663,11 @@ interface RelationServiceOptions {
      * 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
@@ -7873,7 +8696,8 @@ interface ResolveIdsBatchResponse {
 declare class RelationService extends BaseService {
     private schemaService;
     private queryService?;
-    constructor(adapter: DatabaseAdapter, nativeRegistry: typeof registry, options?: RelationServiceOptions);
+    private recordResolver;
+    constructor(adapter: DatabaseAdapter, nativeRegistry: typeof registry, options: RelationServiceOptions);
     /**
      * Set the query service after construction.
      * Useful for breaking circular dependencies during initialization.
@@ -7985,239 +8809,117 @@ declare class RelationService extends BaseService {
      * // { "attr-company": [...], "attr-contact": [...] }
      * ```
      */
-    resolveIdsBatch(requests: ResolveIdsBatchRequest[]): Promise<ResolveIdsBatchResponse>;
-    /**
-     * Internal method to fetch and resolve multiple composite IDs at once.
-     * Optimized for batch operations - single DB query for all records.
-     */
-    private fetchResolveIdsBatch;
-    /**
-     * 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.
-     */
-    private fetchResolveIds;
-    /**
-     * Find a relation attribute by ID.
-     * Results are cached if a CacheAdapter is configured.
-     * Cache is invalidated by ObjectSchemaService.invalidateSchemaCache() via allAttributes pattern.
-     */
-    findAttributeById(attributeId: string): Promise<RelationAttribute | null>;
-    /**
-     * Internal method to fetch attribute by ID (no caching)
-     */
-    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>>;
-/**
- * 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)
- */
-declare class RelationResolverService {
-    private adapter;
-    constructor(adapter: DatabaseAdapter);
-    /**
-     * Resolve values from related records for formula evaluation
-     *
-     * Phase 2: Supports 1 level of relation traversal only
-     *
-     * @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
-     *
-     * @example
-     * ```typescript
-     * // For an order with company relation
-     * const resolved = await resolver.resolveRelationValues(
-     *   orderRecord,
-     *   orderSchema,
-     *   ["company"]
-     * );
-     * // → { company: { id: "...", name: "Acme Corp", ... } }
-     * ```
-     */
-    resolveRelationValues(record: ObjectRecord, schema: ObjectDefinition, relationNames: string[]): Promise<ResolvedRelations>;
-    /**
-     * Resolve relation values for multiple records (batched)
-     *
-     * 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
-     */
-    resolveRelationValuesForMany(records: ObjectRecord[], schema: ObjectDefinition, relationNames: string[]): Promise<Map<string, ResolvedRelations>>;
-    /**
-     * Flatten resolved relations for formula evaluation
-     *
-     * Converts nested structure to dot-notation keys:
-     * { company: { name: "Acme" } } → { "company.name": "Acme" }
-     *
-     * @param resolved - Resolved relations from resolveRelationValues
-     * @returns Flattened values suitable for formula evaluation
-     */
-    flattenResolvedRelations(resolved: ResolvedRelations): Record<string, unknown>;
-    /**
-     * Extract a single relation ID from a value
-     * Handles both single (string) and multi (array) relations
-     * @internal
-     */
-    private extractSingleId;
-}
-
-/**
- * Result of a rollup calculation
- */
-interface RollupResult {
-    /** Computed value */
-    value: unknown;
-    /** Number of records that contributed to the calculation */
-    recordCount: number;
-}
-/**
- * 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 {
-    constructor(adapter: DatabaseAdapter);
-    /**
-     * Calculate a rollup value for a record
-     *
-     * 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
-     * // 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
-     * );
-     * ```
-     */
-    calculate(recordId: string, rollupAttr: RollupAttribute, schema: ObjectDefinition): Promise<RollupResult>;
-    /**
-     * Internal method to compute rollup value (no caching)
-     */
-    private computeRollup;
-    /**
-     * Forward pattern: this record has a relation attribute pointing to other records
-     * Example: entreprise222 has relation "entreprises" → companies, rollup collects from companies
-     */
-    private calculateForward;
-    /**
-     * Reverse pattern: other records have a relation pointing to this record
-     * Example: Company has rollup on "orders", Order has relation "company" → companies
-     */
-    private calculateReverse;
-    /**
-     * Extract and aggregate values from related records
-     */
-    private aggregateValues;
-    /**
-     * Calculate rollup values for multiple records (batched)
-     *
-     * More efficient than calling calculate() for each record individually.
-     */
-    calculateForMany(recordIds: string[], rollupAttr: RollupAttribute, schema: ObjectDefinition): Promise<Map<string, RollupResult>>;
-    /**
-     * Apply aggregation function to a set of values
-     */
-    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;
 }
 
 /**
@@ -8228,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
@@ -8237,7 +8941,8 @@ interface RollupSchedulerOptions {
  *
  * @example
  * ```typescript
- * const scheduler = new RollupScheduler(adapter, {
+ * const scheduler = new RollupScheduler(adapter, getSchemaById, {
+ *   recordResolver,
  *   debounceMs: 100,
  *   maxPending: 50,
  * });
@@ -8257,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.
      *
@@ -8326,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.
  *
@@ -8389,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.
@@ -9432,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
  *
@@ -9442,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
@@ -9645,6 +10298,10 @@ interface MockStores {
     workflows: Map<Uuid, DBWorkflow>;
     workflowInstances: Map<Uuid, DBWorkflowInstance>;
     workflowParticipations: Map<Uuid, DBWorkflowParticipation>;
+    aiConversations: Map<Uuid, AIConversation>;
+    aiMessages: Map<Uuid, AIMessage>;
+    aiUserMemory: Map<string, AIUserMemory>;
+    aiUsageMetrics: Map<string, AIUsageMetrics>;
 }
 /**
  * Create an in-memory mock adapter for testing and development
@@ -11051,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, toSimpleFilterState as a$, type BlockNoteContent as a0, type StatusGroup as a1, type AttributeGroup as a2, type BaseAttribute as a3, type NumberUnit as a4, type DateFormat as a5, type DateValue as a6, type Phone as a7, type Currency as a8, type Location as a9, type CreateAuditLogInput as aA, type AuditListOptions as aB, type AuditServiceOptions as aC, type StorageProvider as aD, type FileVisibility as aE, type File as aF, type CreateFile as aG, type UpdateFile as aH, type TextFilterOperator as aI, type NumberFilterOperator as aJ, type CheckboxFilterOperator as aK, type DateFilterOperator as aL, type SelectFilterOperator as aM, type MultiselectFilterOperator as aN, type RelationFilterOperator as aO, type FilterOperator as aP, type RelativeDateValue as aQ, type CurrencyFilterValue as aR, type PhoneFilterValue as aS, type FilterValue as aT, type FilterRule as aU, type ExtendedFilterRule as aV, type FilterCombinator as aW, type FilterGroup as aX, type AdvancedFilterState as aY, isAdvancedFilterState as aZ, toAdvancedFilterState as a_, type LocationGranularity as aa, RELATION_TARGET_ANY as ab, type RelationAttribute as ac, isUniversalRelation as ad, type BlockNoteBlock as ae, type BlockNoteCustomInlineContent as af, type BlockNoteDefaultProps as ag, type BlockNoteInlineContent as ah, type BlockNoteLink as ai, type BlockNoteStyledText as aj, type BlockNoteStyles as ak, type BlockNoteTableCell as al, type BlockNoteTableCellProps as am, type BlockNoteTableContent as an, type PartialBlockNoteBlock as ao, type PartialBlockNoteContent as ap, type PartialBlockNoteInlineContent as aq, type PartialBlockNoteLink as ar, type PartialBlockNoteStyledText as as, type PartialBlockNoteTableCell as at, type PartialBlockNoteTableContent as au, type AuditResourceType as av, type AuditAction as aw, type AuditActorType as ax, type AuditChange as ay, type AuditLogEntry as az, type TextAreaAttribute as b, type PolicyContext as b$, type SortDirection as b0, type QueryState as b1, OPERATORS_BY_TYPE as b2, type NoValueOperator as b3, NO_VALUE_OPERATORS as b4, isNoValueOperator as b5, type FlowSlot as b6, type FlowRowField as b7, type FlowPage as b8, type FlowRelation as b9, type ExtractRecordInput as bA, type ExtractRecordInputStrict as bB, type ExtractRecordUpdate as bC, type ExtractRecordUpdateStrict as bD, type ExtractAttributes as bE, type TypedObjectRecord as bF, type ExtractObjectRecord as bG, type ExtractObjectRecordWithCustom as bH, RESERVED_ATTRIBUTE_NAMES as bI, SYSTEM_FIELD_NAMES as bJ, type ReservedAttributeName as bK, type SystemFieldName as bL, type Timestamps as bM, type ObjectAttribute as bN, type CompletionStatus as bO, type ObjectRecord as bP, type PermissionScope as bQ, type Role as bR, type Permission as bS, type UserRoleAssignment as bT, type EffectivePermissions as bU, type ObjectPermissions as bV, type SystemPermissions as bW, type CreateRoleInput as bX, type UpdateRoleInput as bY, type CreatePermissionInput as bZ, type AssignRoleInput as b_, type FlowStatus as ba, type FlowDefinition as bb, isFlowDefinition as bc, isFlowPublished as bd, isSystemFlow as be, type GeocodingSuggestion as bf, type GeocodingAutocompleteParams as bg, type ReverseGeocodingParams as bh, type GeocodingParams as bi, type GeocodingAdapter as bj, NoopGeocodingAdapter as bk, type AttributeSchema as bl, type InferRecordFromSchema as bm, type InferRecordWithRequirements as bn, type TypedAttribute as bo, type AttributeMap as bp, type AddAttribute as bq, type InferRecord as br, type InferRecordInput as bs, type InferRecordUpdate as bt, type CustomAttributeValue as bu, type WithCustomAttributes as bv, type RecordMetadata as bw, type SystemFields as bx, type ExtractRecord as by, type ExtractRecordStrict as bz, type RichtextFeature as c, type SignedLinkAuth as c$, type RecordPolicy as c0, PolicyViolationError as c1, type UserRole as c2, type UserStatus as c3, type UserProfile as c4, type CreateUserProfile as c5, type UpdateUserProfile as c6, type InviteUserInput as c7, type TabType as c8, type FormTab as c9, isConditionRule as cA, isConditionGroup as cB, eq as cC, neq as cD, and as cE, or as cF, inValues as cG, isEmpty as cH, isNotEmpty as cI, type WorkflowSlot as cJ, type NodePosition as cK, type CanvasViewport as cL, type WorkflowLayout as cM, type ParticipantAuthConfig as cN, type WorkflowStatus as cO, isWorkflowDefinition as cP, isWorkflowPublished as cQ, isSystemWorkflow as cR, type WorkflowTransition as cS, type WorkflowError as cT, type PendingAction as cU, type WorkflowInstance as cV, isInstanceTerminal as cW, isInstanceWaiting as cX, canResumeInstance as cY, createStartTransition as cZ, type ParticipationStatus as c_, 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, type CurrencyAttribute as d, createCheckboxValidator as d$, type PinCodeAuth as d0, type ParticipationAuth as d1, type WorkflowParticipation as d2, isSignedLinkAuth as d3, isPinCodeAuth as d4, canParticipate as d5, canAuthenticate as d6, canExecuteNode as d7, type GeneratedDocument as d8, type WorkflowExecutionContext as d9, type ValidationMessages as dA, DEFAULT_VALIDATION_MESSAGES as dB, textConfigSchema as dC, textareaConfigSchema as dD, richtextConfigSchema as dE, numberConfigSchema as dF, checkboxConfigSchema as dG, dateConfigSchema as dH, phoneConfigSchema as dI, currencyConfigSchema as dJ, statusConfigSchema as dK, locationConfigSchema as dL, selectConfigSchema as dM, multiselectConfigSchema as dN, fileConfigSchema as dO, userConfigSchema as dP, relationConfigSchema as dQ, ratingConfigSchema as dR, formulaConfigSchema as dS, rollupConfigSchema as dT, attributeConfigSchemas as dU, getAttributeConfigSchema as dV, validateAttributeConfig as dW, parseAttributeConfig as dX, safeParseAttributeConfig as dY, createTextValidator as dZ, createNumberValidator as d_, 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 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 Option as e, SHORTCUT_TO_FILTER_OPERATOR as e$, createDateValidator as e0, createPhoneValidator as e1, createCurrencyValidator as e2, createStatusValidator as e3, createSelectValidator as e4, createMultiselectValidator as e5, createLocationValidator as e6, createFileValidator as e7, createUserValidator as e8, createSingleRelationValidator as e9, type TokenVerificationResult as eA, PinCodeService as eB, getDefaultPinCodeService as eC, initializePinCodeService as eD, type PinCodeGenerationOptions as eE, type PinCodeVerificationResult as eF, type CacheKeyType as eG, hashOptions as eH, type CacheAdapter as eI, type CacheOptions as eJ, cacheKeys as eK, cacheTtl as eL, defaultTtl as eM, NoopCacheAdapter as eN, type FetchResult as eO, type FormattedRecord as eP, type GroupedFetchResult as eQ, type InsertOptions as eR, type QueryBuilderState as eS, type RegistryMap as eT, type RegistryObjectNames as eU, type ShortcutOperator as eV, createDefaultState as eW, formatRecord as eX, formatRecords as eY, QueryMultipleResultsError as eZ, QueryNoResultError as e_, 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 StatusAttribute as f, type PathCardinality as f$, createQueryBuilder as f0, QueryBuilder as f1, type QueryBuilderOptions as f2, type EvaluationResult as f3, type EvaluationTrace as f4, evaluateCondition as f5, evaluate as f6, evaluateWithTrace as f7, TenantContextError as f8, addSchemaToContext as f9, success as fA, wait as fB, ConditionExecutor as fC, EndExecutor as fD, FormExecutor as fE, StartExecutor as fF, evaluateFormula as fG, evaluateFormulaAttribute as fH, evaluateFormulaAttributeWithRelations as fI, evaluateFormulaWithRelations as fJ, evaluateFormulaWithResult as fK, extractFormulaVariables as fL, extractRelationNames as fM, extractRelationReferences as fN, flattenRelationsForEval as fO, formatFormulaResult as fP, hasRelationReferences as fQ, validateFormulaExpression as fR, type FormulaResult as fS, getPathDepth as fT, getRelationPath as fU, getTargetAttributeName as fV, InvalidPathError as fW, MaxDepthExceededError as fX, parsePath as fY, pathHasManyCardinality as fZ, validatePath as f_, 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, type SelectAttribute as g, applyDefaultValues as g$, type PathSegment as g0, type PathSegmentType as g1, type SchemaResolver as g2, resolveMultiplePaths as g3, resolveSingleValue as g4, traversePath as g5, type TraversalOptions as g6, type TraversalResult as g7, type AttributeChange as g8, type HookContext as g9, type CreateCustomObjectInput as gA, type AddAttributeInput as gB, type UpdateObjectInput as gC, type ObjectSchemaServiceOptions as gD, ObjectSchemaService as gE, type RecordServiceOptions as gF, RecordService as gG, type RecordQueryServiceOptions as gH, type QueryOptions as gI, type SearchQueryOptions as gJ, type QueryResult as gK, RecordQueryService as gL, type RelationValidationResult as gM, type RelationValidationError as gN, type RelationOption as gO, type RelationOptionsResponse as gP, type GetRelationOptionsParams as gQ, type RelationServiceOptions as gR, type ResolveIdsBatchRequest as gS, type ResolveIdsBatchResponse as gT, RelationService as gU, type ResolvedRelations as gV, RelationResolverService as gW, type RollupResult as gX, RollupService as gY, type RollupSchedulerOptions as gZ, RollupScheduler as g_, 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, BaseService as gu, BaseRepository as gv, type SchemaContextAware as gw, SchemaContextAwareRepository as gx, TenantAwareRepository as gy, TenantAwareService as gz, type SingleRelationAttribute as h, extractAttributeNames as h$, checkPermission as h0, getPolicy as h1, buildPolicyContext as h2, checkRecordAccess as h3, checkRecordModifyOrThrow as h4, checkRecordDeleteOrThrow as h5, computeLabel as h6, type LabelResolver as h7, enrichWithFormulas as h8, enrichRecordsWithFormulas as h9, buildAuditChanges as hA, type FileServiceOptions as hB, FileService as hC, GeocodingService as hD, GlobalSearchService as hE, type PermissionServiceOptions as hF, PermissionService as hG, type CreateViewInput as hH, type UpdateViewInput as hI, ViewService as hJ, type FileContent as hK, type StorageUploadInput as hL, type StorageUploadResult as hM, type SignedUrlOptions as hN, type StorageAdapter as hO, type UploadFileInput as hP, type SyncResult as hQ, type SyncOptions as hR, syncNativeObjects as hS, verifyNativeObjectsSync as hT, getSyncPreview as hU, type FullSyncResult as hV, type FullSyncOptions as hW, syncAll as hX, DEFAULT_LABEL_FALLBACK as hY, renderLabelExpression as hZ, isLabelExpression as h_, createContextForCreate as ha, createContextForUpdate as hb, createContextForDelete as hc, createContextForRestore as hd, recalculateParentRollups as he, type RollupCascadeContext as hf, type CreateWorkflowInput as hg, type UpdateWorkflowInput as hh, type WorkflowServiceOptions as hi, WorkflowService as hj, type StartWorkflowInput as hk, type ResumeWorkflowInput as hl, type WorkflowInstanceServiceOptions as hm, WorkflowInstanceService as hn, type CreateParticipationInput as ho, type CreateParticipationResult as hp, type AuthenticationResult as hq, WorkflowParticipationService as hr, type FieldReadOnlyResult as hs, WorkflowRelationService as ht, type UserValidationResult as hu, type UserValidationError as hv, UserService as hw, type UserProfileServiceOptions as hx, UserProfileService as hy, AuditService as hz, type MultiRelationAttribute as i, enrichValuesForDisplay as i0, enrichValuesWithSelectLabels as i1, extractRelationIds as i2, type RelationLabelResolver as i3, computeLabelWithRelations as i4, type DBObject as i5, type CreateDBObject as i6, type UpdateDBObject as i7, type UpsertDBObject as i8, type DBAttribute as i9, type ViewSyncOptions as iA, syncNativeViews as iB, verifyNativeViewsSync as iC, getViewSyncPreview as iD, type CreateDBAttribute as ia, type UpdateDBAttribute as ib, type UpsertDBAttribute as ic, type CreateObjectRecord as id, type ListOptions as ie, type SearchOptions as ig, type GlobalSearchOptions as ih, type GlobalSearchResultItem as ii, type FileListOptions as ij, type DBView as ik, type CreateDBView as il, type UpdateDBView as im, type UpsertDBView as io, type DBWorkflow as ip, type CreateDBWorkflow as iq, type UpdateDBWorkflow as ir, type DBWorkflowInstance as is, type CreateDBWorkflowInstance as it, type UpdateDBWorkflowInstance as iu, type DBWorkflowParticipation as iv, type CreateDBWorkflowParticipation as iw, type UpdateDBWorkflowParticipation as ix, type OperationResult as iy, type ViewSyncResult as iz, type RelationTarget as j, type RatingAttribute as k, type FormulaAttribute as l, type FormulaReturnType as m, type RollupAttribute as n, type RollupFunction as o, type AttributeType as p, type ObjectDefinition as q, type Field as r, type AttributeGroupField as s, type TableTab as t, type InverseTableTab as u, type ViewDefinition as v, type InstanceStatus as w, type Tab as x, type FilterState as y, type SortRule as z };
+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 };