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

package/dist/{runtime-DRiI1SCJ.d.ts → runtime-B5JYQdZx.d.ts}

@@ -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;
 }
 /**
@@ -370,244 +382,6 @@ declare function generateId(): Uuid;
  */
 declare function generatePrefixedId(prefix: string): Uuid;
 
-/**
- * BlockNote text styles (inline formatting)
- * Applied to StyledText nodes within inline content.
- */
-interface BlockNoteStyles {
-    /** Bold text */
-    bold?: boolean;
-    /** Italic text */
-    italic?: boolean;
-    /** Underlined text */
-    underline?: boolean;
-    /** Strikethrough text */
-    strikethrough?: boolean;
-    /** Monospace/code text */
-    code?: boolean;
-    /** Text color (color name or CSS value) */
-    textColor?: string;
-    /** Background/highlight color (color name or CSS value) */
-    backgroundColor?: string;
-}
-/**
- * Styled text node - the basic text unit with formatting
- */
-interface BlockNoteStyledText {
-    type: "text";
-    /** The text content */
-    text: string;
-    /** Applied styles */
-    styles: BlockNoteStyles;
-}
-/**
- * Link inline content - contains styled text with a URL
- */
-interface BlockNoteLink {
-    type: "link";
-    /** Link URL */
-    href: string;
-    /** Link text content (styled text nodes) */
-    content: BlockNoteStyledText[];
-}
-/**
- * Custom inline content (for extensions)
- */
-interface BlockNoteCustomInlineContent {
-    type: string;
-    /** Props specific to this inline content type */
-    props?: Record<string, unknown>;
-    /** Styled content (for inline content with "styled" content type) */
-    content?: BlockNoteStyledText[];
-}
-/**
- * Union of all inline content types
- */
-type BlockNoteInlineContent = BlockNoteStyledText | BlockNoteLink | BlockNoteCustomInlineContent;
-/**
- * Table cell properties
- */
-interface BlockNoteTableCellProps {
-    /** Cell background color */
-    backgroundColor?: string;
-    /** Cell text color */
-    textColor?: string;
-    /** Text alignment within cell */
-    textAlignment?: "left" | "center" | "right" | "justify";
-    /** Column span (merge cells horizontally) */
-    colspan?: number;
-    /** Row span (merge cells vertically) */
-    rowspan?: number;
-}
-/**
- * Table cell with explicit props
- */
-interface BlockNoteTableCell {
-    type: "tableCell";
-    props: BlockNoteTableCellProps;
-    content: BlockNoteInlineContent[];
-}
-/**
- * Table content structure
- * Used as the content of table blocks.
- */
-interface BlockNoteTableContent {
-    type: "tableContent";
-    /** Column widths (undefined = auto) */
-    columnWidths: (number | undefined)[];
-    /** Number of header rows (frozen at top) */
-    headerRows?: number;
-    /** Number of header columns (frozen at left) */
-    headerCols?: number;
-    /** Table rows */
-    rows: Array<{
-        /** Row cells - either simple inline content arrays or explicit TableCell objects */
-        cells: BlockNoteInlineContent[][] | BlockNoteTableCell[];
-    }>;
-}
-/**
- * Default block properties available on all blocks
- */
-interface BlockNoteDefaultProps {
-    /** Background color (color name or CSS value, "default" for none) */
-    backgroundColor?: string;
-    /** Text color (color name or CSS value, "default" for none) */
-    textColor?: string;
-    /** Text alignment */
-    textAlignment?: "left" | "center" | "right" | "justify";
-}
-/**
- * BlockNote block structure
- * Represents a single block in the editor document.
- *
- * @example Paragraph block
- * ```typescript
- * {
- *   id: "abc123",
- *   type: "paragraph",
- *   props: { textAlignment: "left" },
- *   content: [{ type: "text", text: "Hello world", styles: {} }],
- *   children: []
- * }
- * ```
- *
- * @example Heading block
- * ```typescript
- * {
- *   id: "def456",
- *   type: "heading",
- *   props: { level: 2, textAlignment: "left" },
- *   content: [{ type: "text", text: "My Heading", styles: { bold: true } }],
- *   children: []
- * }
- * ```
- *
- * @example Nested list
- * ```typescript
- * {
- *   id: "ghi789",
- *   type: "bulletListItem",
- *   props: { textAlignment: "left" },
- *   content: [{ type: "text", text: "Parent item", styles: {} }],
- *   children: [
- *     {
- *       id: "jkl012",
- *       type: "bulletListItem",
- *       props: { textAlignment: "left" },
- *       content: [{ type: "text", text: "Child item", styles: {} }],
- *       children: []
- *     }
- *   ]
- * }
- * ```
- */
-interface BlockNoteBlock {
-    /** Unique block identifier (auto-generated if not provided) */
-    id: string;
-    /**
-     * Block type identifier
-     * Built-in types: paragraph, heading, bulletListItem, numberedListItem,
-     * checkListItem, table, image, video, audio, file, codeBlock, quote
-     */
-    type: string;
-    /**
-     * Block-specific properties
-     * All blocks have defaultProps (backgroundColor, textColor, textAlignment)
-     * Additional props depend on block type (e.g., level for headings, checked for checkListItem)
-     */
-    props: Record<string, boolean | number | string>;
-    /**
-     * Block content
-     * - InlineContent[] for text blocks (paragraph, heading, list items, etc.)
-     * - TableContent for table blocks
-     * - undefined for void blocks (image, video, file, divider, etc.)
-     */
-    content?: BlockNoteInlineContent[] | BlockNoteTableContent;
-    /** Nested child blocks (for indentation/nesting) */
-    children: BlockNoteBlock[];
-}
-/**
- * BlockNote document content
- * An array of blocks representing the full editor document.
- * This is the format returned by `editor.document` and accepted by `initialContent`.
- */
-type BlockNoteContent = BlockNoteBlock[];
-/**
- * Partial styled text (text can be a plain string shorthand)
- */
-type PartialBlockNoteStyledText = string | {
-    type: "text";
-    text: string;
-    styles?: Partial<BlockNoteStyles>;
-};
-/**
- * Partial link (content can be a string shorthand)
- */
-interface PartialBlockNoteLink {
-    type: "link";
-    href: string;
-    content: string | BlockNoteStyledText[];
-}
-/**
- * Partial inline content union
- */
-type PartialBlockNoteInlineContent = PartialBlockNoteStyledText | PartialBlockNoteLink | BlockNoteCustomInlineContent;
-/**
- * Partial table cell
- */
-interface PartialBlockNoteTableCell {
-    type: "tableCell";
-    props?: Partial<BlockNoteTableCellProps>;
-    content?: PartialBlockNoteInlineContent[];
-}
-/**
- * Partial table content
- */
-interface PartialBlockNoteTableContent {
-    type: "tableContent";
-    columnWidths?: (number | undefined)[];
-    headerRows?: number;
-    headerCols?: number;
-    rows: Array<{
-        cells: PartialBlockNoteInlineContent[][] | PartialBlockNoteTableCell[];
-    }>;
-}
-/**
- * Partial block for creation/updates
- * All properties are optional except that at least `type` should be provided for new blocks.
- */
-interface PartialBlockNoteBlock {
-    id?: string;
-    type?: string;
-    props?: Partial<Record<string, boolean | number | string>>;
-    content?: PartialBlockNoteInlineContent[] | PartialBlockNoteTableContent | string;
-    children?: PartialBlockNoteBlock[];
-}
-/**
- * Partial document content for initialization
- */
-type PartialBlockNoteContent = PartialBlockNoteBlock[];
-
 type AttributeType = "text" | "textarea" | "richtext" | "number" | "checkbox" | "date" | "phone" | "currency" | "status" | "location" | "select" | "multiselect" | "file" | "user" | "relation" | "rating" | "formula" | "rollup";
 /**
  * Status group categorization
@@ -846,15 +620,15 @@ declare function isUniversalRelation(attr: RelationAttribute): boolean;
 interface TextAreaAttribute extends BaseAttribute<string> {
     type: "textarea";
 }
-
 /**
  * Available features for richtext editor
  */
 type RichtextFeature = "headings" | "bold" | "italic" | "lists" | "links" | "images" | "codeBlocks" | "tables";
 /**
- * RichtextAttribute - Rich text content using BlockNote editor
+ * RichtextAttribute - Rich text content using semantic markdown
  *
- * Stores content as BlockNote JSON format for maximum flexibility.
+ * Stores content as semantic markdown string (with directives like :::callout).
+ * Parsed at runtime to Tiptap JSON for editing.
  * Use this for: Notes, articles, descriptions, long-form content.
  *
  * @example
@@ -864,9 +638,9 @@ type RichtextFeature = "headings" | "bold" | "italic" | "lists" | "links" | "ima
  *   .required()
  * ```
  */
-interface RichtextAttribute extends BaseAttribute<BlockNoteContent> {
+interface RichtextAttribute extends BaseAttribute<string> {
     type: "richtext";
-    /** Enabled BlockNote features. If undefined, all features are enabled. */
+    /** Enabled features. If undefined, all features are enabled. */
     features?: RichtextFeature[];
 }
 interface RatingAttribute extends BaseAttribute<number> {
@@ -1086,6 +860,15 @@ interface Timestamps {
     createdAt: Date;
     updatedAt: Date;
 }
+/**
+ * Sharing mode for multi-tenant object access.
+ *
+ * - `private`: Object is only visible to its owner tenant (default)
+ * - `shared`: Object is readable by all tenants, but only writable by the owner tenant
+ *
+ * Records inherit the sharing mode of their parent object.
+ */
+type SharingMode = "private" | "shared";
 /**
  * Object definition - Represents a database table/entity
  */
@@ -1117,6 +900,15 @@ interface ObjectDefinition {
     labelExpression: string;
     attributes: Attribute[];
     system?: boolean;
+    /**
+     * Sharing mode for multi-tenant access.
+     * - `private`: Only visible to the owner tenant (default)
+     * - `shared`: Readable by all tenants, writable only by the owner
+     *
+     * Records inherit the sharing mode of their parent object.
+     * @default "private"
+     */
+    sharingMode?: SharingMode;
     metadata?: Record<string, unknown>;
 }
 /**
@@ -1771,7 +1563,8 @@ declare class NoopGeocodingAdapter implements GeocodingAdapter {
 type AttributeValueMap = {
     text: string;
     textarea: string;
-    richtext: BlockNoteContent;
+    /** Semantic markdown string (parsed at runtime to TiptapDocument) */
+    richtext: string;
     number: number;
     checkbox: boolean;
     date: string | Date;
@@ -3665,6 +3458,12 @@ interface DBObject extends Timestamps {
     icon?: IconName;
     labelExpression: string;
     system: boolean;
+    /**
+     * Sharing mode for multi-tenant access.
+     * - `private`: Only visible to the owner tenant (default)
+     * - `shared`: Readable by all tenants, writable only by the owner
+     */
+    sharingMode: SharingMode;
     metadata?: Record<string, unknown>;
 }
 /**
@@ -3679,6 +3478,7 @@ interface CreateDBObject {
     icon?: IconName;
     labelExpression: string;
     system?: boolean;
+    sharingMode?: SharingMode;
     metadata?: Record<string, unknown>;
 }
 interface UpdateDBObject {
@@ -3687,6 +3487,7 @@ interface UpdateDBObject {
     description?: string;
     icon?: IconName;
     labelExpression?: string;
+    sharingMode?: SharingMode;
     metadata?: Record<string, unknown>;
 }
 /**
@@ -3695,6 +3496,7 @@ interface UpdateDBObject {
  */
 interface UpsertDBObject extends CreateDBObject {
     system: boolean;
+    sharingMode: SharingMode;
 }
 /**
  * Attribute as stored in database (metadata)
@@ -5128,19 +4930,18 @@ declare function createRollupValidator(_attr: RollupAttribute, _messages?: Valid
 declare function createTextAreaValidator(_attr: TextAreaAttribute, _messages?: ValidationMessages): z.ZodString;
 /**
  * Create a Zod schema for a richtext attribute.
- * Validates BlockNote content structure with strict block validation.
+ * Validates semantic markdown content as a string.
  *
- * @example Valid BlockNote content
+ * @example Valid richtext content (semantic markdown)
  * ```typescript
- * [
- *   {
- *     id: "block-1",
- *     type: "paragraph",
- *     props: { textAlignment: "left" },
- *     content: [{ type: "text", text: "Hello world" }],
- *     children: []
- *   }
- * ]
+ * `# Heading
+ *
+ * Some paragraph text.
+ *
+ * :::callout{variant="info"}
+ * This is a callout block
+ * :::
+ * `
  * ```
  */
 declare function createRichtextValidator(attr: RichtextAttribute, messages?: ValidationMessages): z.ZodTypeAny;
@@ -5454,6 +5255,22 @@ declare const cacheKeys: {
     readonly allWorkflows: (tenantId: string) => string;
     /** All cache for a tenant (nuclear option) */
     readonly allForTenant: (tenantId: string) => string;
+    /** Object schema for shared object (not tenant-scoped) */
+    readonly sharedObjectSchema: (objectId: string) => string;
+    /** Object schema for shared object by name */
+    readonly sharedObjectSchemaByName: (name: string) => string;
+    /** Attributes for a shared object */
+    readonly sharedObjectAttributes: (objectId: string) => string;
+    /** Record from a shared object */
+    readonly sharedRecord: (recordId: string) => string;
+    /** Record list for a shared object */
+    readonly sharedRecordList: (objectId: string, hash: string) => string;
+    /** All shared record lists for an object (for invalidation) */
+    readonly allSharedRecordLists: (objectId: string) => string;
+    /** All shared schemas (for invalidation) */
+    readonly allSharedSchemas: () => string;
+    /** All shared records (for invalidation) */
+    readonly allSharedRecords: () => string;
 };
 /**
  * Recommended TTL values for different resource types.
@@ -7867,6 +7684,19 @@ declare class ObjectSchemaService extends BaseService {
      * Internal method to fetch all object schemas (no caching)
      */
     private fetchObjectSchemaList;
+    /**
+     * Get object ownership info for write access checks.
+     *
+     * Used by RecordService to verify if the current tenant can write
+     * to a shared object's records.
+     *
+     * @param objectId - Object UUID
+     * @returns Object ownership info with tenantId and sharingMode
+     */
+    getObjectOwnerInfo(objectId: string): Promise<{
+        tenantId: TenantId;
+        sharingMode: SharingMode;
+    }>;
     /**
      * Invalidate all schema-related cache for the current tenant.
      * Called automatically after schema mutations.
@@ -8097,6 +7927,7 @@ interface RecordServiceOptions {
 declare class RecordService extends BaseService {
     private schemaService;
     private queryService;
+    private recordResolver;
     private relationService;
     private userService;
     private rollupService;
@@ -8202,95 +8033,476 @@ 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;
+    }>>;
+}
+/**
+ * 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 */
+    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.
@@ -8302,7 +8514,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.
@@ -8414,239 +8627,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;
-    /**
-     * Get the default empty value for a rollup function
-     */
-    private getEmptyValue;
+    resolveIdsBatch(requests: ResolveIdsBatchRequest[]): Promise<ResolveIdsBatchResponse>;
     /**
-     * Sum numeric values
+     * 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 sumNumbers;
+    private resolveCompositeIds;
     /**
-     * Average numeric values
+     * Resolve the display label for a record.
+     * Uses custom template if provided, otherwise falls back to pre-computed label.
      */
-    private averageNumbers;
+    private resolveLabel;
     /**
-     * Get earliest date from 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 earliestDate;
+    findAttributeById(attributeId: string): Promise<RelationAttribute | null>;
     /**
-     * Get latest date from values
+     * Internal method to fetch attribute by ID (no caching)
      */
-    private latestDate;
+    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 {
     /**
-     * Recalculate all rollup attributes for a record and update it
-     *
-     * Called after related records change to keep rollups up-to-date.
+     * Record resolver for cached record fetching.
+     * Required for cached access to records.
      */
-    recalculateAndUpdate(record: ObjectRecord, schema: ObjectDefinition): Promise<ObjectRecord>;
+    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);
     /**
-     * Find parent records that need rollup recalculation when a child record changes
+     * Resolve values from related records for formula evaluation
      *
-     * Used by hooks to determine which parent records to recalculate after
-     * a child record is created, updated, or deleted.
+     * Supports 1 level of relation traversal only.
      *
-     * @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 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 affectedParentIds - Array of parent record IDs whose rollups need invalidation
+     * @example
+     * ```typescript
+     * const resolved = await resolver.resolveRelationValues(
+     *   orderRecord,
+     *   orderSchema,
+     *   ["company"]
+     * );
+     * // → { company: { id: "...", name: "Acme Corp", ... } }
+     * ```
      */
-    invalidateAffectedRollups(affectedParentIds: string[]): Promise<void>;
+    resolveRelationValues(record: ObjectRecord, schema: ObjectDefinition, relationNames: string[]): Promise<ResolvedRelations>;
     /**
-     * Invalidate all cached rollups for the current tenant.
-     * Use sparingly - prefer targeted invalidation.
+     * 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
      */
-    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 +8748,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 +8759,8 @@ interface RollupSchedulerOptions {
  *
  * @example
  * ```typescript
- * const scheduler = new RollupScheduler(adapter, {
+ * const scheduler = new RollupScheduler(adapter, getSchemaById, {
+ *   recordResolver,
  *   debounceMs: 100,
  *   maxPending: 50,
  * });
@@ -8686,7 +8780,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.
      *
@@ -8754,32 +8848,19 @@ declare function checkRecordModifyOrThrow(policy: RecordPolicy, record: ObjectRe
  * Throws PolicyViolationError if denied.
  */
 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.
+ * Check if the current tenant can write to an object based on sharing mode.
  *
- * @param schema - Object schema with labelExpression
- * @param values - Record values
- * @param resolver - Resolver for relation labels
- * @returns Computed label string
+ * Shared objects are read-only for non-owner tenants.
+ * Only the tenant that owns the object (tenant_id) can perform write operations.
+ *
+ * @param objectName - Name of the object (for error messages)
+ * @param sharingMode - Sharing mode of the object
+ * @param objectOwnerTenantId - Tenant ID that owns the object
+ * @param currentTenantId - Current tenant ID from context
+ * @throws ForbiddenError if the object is shared and current tenant is not the owner
  */
-declare function computeLabel(schema: ObjectDefinition, values: Record<string, unknown>, resolver: LabelResolver): Promise<string>;
+declare function checkSharedObjectWriteAccess(objectName: string, sharingMode: SharingMode | undefined, objectOwnerTenantId: TenantId, currentTenantId: TenantId): void;
 
 /**
  * Enrich a record with computed formula values.
@@ -8818,32 +8899,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 +9916,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 +9926,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
@@ -11382,6 +11437,17 @@ interface SyncResult {
 interface SyncOptions {
     dryRun?: boolean;
     verbose?: boolean;
+    /**
+     * Master tenant ID for shared object validation.
+     * If provided, only this tenant can sync shared objects.
+     * If not provided and a shared object is synced, an error will be thrown.
+     */
+    masterTenantId?: string;
+    /**
+     * Current tenant ID executing the sync.
+     * Required when syncing shared objects to validate against masterTenantId.
+     */
+    tenantId?: string;
 }
 /**
  * Sync native objects from registry to database
@@ -11484,98 +11550,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 FilterValue as a$, type AIMessageRole as a0, type AIThinkingLevel as a1, type AIToolCallStatus as a2, type AIToolCall as a3, type AIChatMessagePartType as a4, type TextPartData as a5, type ToolPartData as a6, type ThinkingPartData as a7, type ReasoningPartData as a8, type AIChatMessagePart as a9, RELATION_TARGET_ANY as aA, type RelationAttribute as aB, isUniversalRelation as aC, type AuditResourceType as aD, type AuditAction as aE, type AuditActorType as aF, type AuditChange as aG, type AuditLogEntry as aH, type CreateAuditLogInput as aI, type AuditListOptions as aJ, type AuditServiceOptions as aK, type StorageProvider as aL, type FileVisibility as aM, type File as aN, type CreateFile as aO, type UpdateFile as aP, type TextFilterOperator as aQ, type NumberFilterOperator as aR, type CheckboxFilterOperator as aS, type DateFilterOperator as aT, type SelectFilterOperator as aU, type MultiselectFilterOperator as aV, type RelationFilterOperator as aW, type FilterOperator as aX, type RelativeDateValue as aY, type CurrencyFilterValue as aZ, type PhoneFilterValue as a_, type AIChatMessage as aa, type AIQuestionType as ab, type AIQuestionOption as ac, type AIQuestion as ad, type AIQuestionAnswer as ae, type AITodoStatus as af, type AITodoItem as ag, type AITodoList as ah, type AIMessageAttachment 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 Permission as b$, type FilterRule as b0, type ExtendedFilterRule as b1, type FilterCombinator as b2, type FilterGroup as b3, type AdvancedFilterState as b4, isAdvancedFilterState as b5, toAdvancedFilterState as b6, toSimpleFilterState as b7, type SortDirection as b8, type QueryState as b9, type InferRecordInput as bA, type InferRecordUpdate as bB, type CustomAttributeValue as bC, type WithCustomAttributes as bD, type RecordMetadata as bE, type SystemFields as bF, type ExtractRecord as bG, type ExtractRecordStrict as bH, type ExtractRecordInput as bI, type ExtractRecordInputStrict as bJ, type ExtractRecordUpdate as bK, type ExtractRecordUpdateStrict as bL, type ExtractAttributes as bM, type TypedObjectRecord as bN, type ExtractObjectRecord as bO, type ExtractObjectRecordWithCustom as bP, RESERVED_ATTRIBUTE_NAMES as bQ, SYSTEM_FIELD_NAMES as bR, type ReservedAttributeName as bS, type SystemFieldName as bT, type Timestamps as bU, type SharingMode as bV, type ObjectAttribute as bW, type CompletionStatus as bX, type ObjectRecord as bY, type PermissionScope as bZ, type Role as b_, OPERATORS_BY_TYPE as ba, type NoValueOperator as bb, NO_VALUE_OPERATORS as bc, isNoValueOperator as bd, type FlowSlot as be, type FlowRowField as bf, type FlowPage as bg, type FlowRelation as bh, type FlowStatus as bi, type FlowDefinition as bj, isFlowDefinition as bk, isFlowPublished as bl, isSystemFlow as bm, type GeocodingSuggestion as bn, type GeocodingAutocompleteParams as bo, type ReverseGeocodingParams as bp, type GeocodingParams as bq, type GeocodingAdapter as br, NoopGeocodingAdapter as bs, type AttributeSchema as bt, type InferRecordFromSchema as bu, type InferRecordWithRequirements as bv, type TypedAttribute as bw, type AttributeMap as bx, type AddAttribute as by, type InferRecord as bz, type RichtextFeature as c, type WorkflowTransition as c$, type UserRoleAssignment as c0, type EffectivePermissions as c1, type ObjectPermissions as c2, type SystemPermissions as c3, type CreateRoleInput as c4, type UpdateRoleInput as c5, type CreatePermissionInput as c6, type AssignRoleInput as c7, type PolicyContext as c8, type RecordPolicy as c9, type WorkflowNodeType as cA, isStartNode as cB, isFormNode as cC, isConditionNode as cD, isEndNode as cE, isSimpleFormNode as cF, isAdvancedFormNode as cG, getNodeOutputs as cH, type ConditionOperator as cI, isConditionRule as cJ, isConditionGroup as cK, eq as cL, neq as cM, and as cN, or as cO, inValues as cP, isEmpty as cQ, isNotEmpty as cR, type WorkflowSlot as cS, type NodePosition as cT, type CanvasViewport as cU, type WorkflowLayout as cV, type ParticipantAuthConfig as cW, type WorkflowStatus as cX, isWorkflowDefinition as cY, isWorkflowPublished as cZ, isSystemWorkflow as c_, PolicyViolationError as ca, type UserRole as cb, type UserStatus as cc, type UserProfile as cd, type CreateUserProfile as ce, type UpdateUserProfile as cf, type InviteUserInput as cg, type TabType as ch, type FormTab as ci, type CustomTab as cj, type ActivityTab as ck, type NotesTab as cl, type FlowsTab as cm, isFormTab as cn, isTableTab as co, isDirectTableTab as cp, isInverseTableTab as cq, isCustomTab as cr, isActivityTab as cs, isNotesTab as ct, isFlowsTab as cu, type StartNode as cv, type FormNode as cw, type FormFieldRef as cx, type ConditionNode as cy, type EndNode as cz, type CurrencyAttribute as d, formulaConfigSchema as d$, type WorkflowError as d0, type PendingAction as d1, type WorkflowInstance as d2, isInstanceTerminal as d3, isInstanceWaiting as d4, canResumeInstance as d5, createStartTransition as d6, type ParticipationStatus as d7, type SignedLinkAuth as d8, type PinCodeAuth as d9, type Uuid as dA, type TenantId as dB, type UserId as dC, asTenantId as dD, asUserId as dE, generateId as dF, generatePrefixedId as dG, registry as dH, viewRegistry as dI, type ValidationMessages as dJ, DEFAULT_VALIDATION_MESSAGES as dK, textConfigSchema as dL, textareaConfigSchema as dM, richtextConfigSchema as dN, numberConfigSchema as dO, checkboxConfigSchema as dP, dateConfigSchema as dQ, phoneConfigSchema as dR, currencyConfigSchema as dS, statusConfigSchema as dT, locationConfigSchema as dU, selectConfigSchema as dV, multiselectConfigSchema as dW, fileConfigSchema as dX, userConfigSchema as dY, relationConfigSchema as dZ, ratingConfigSchema as d_, type ParticipationAuth as da, type WorkflowParticipation as db, isSignedLinkAuth as dc, isPinCodeAuth as dd, canParticipate as de, canAuthenticate as df, canExecuteNode as dg, type GeneratedDocument as dh, type WorkflowExecutionContext as di, createEmptyContext as dj, getContextValue as dk, setContextValue as dl, mergeFormToSlot as dm, type WorkflowAccessMode as dn, type ReadOnlyReason as dp, type FormFieldContext as dq, type FormFieldRow as dr, type FormNodeInfo as ds, type FormContextResponse as dt, type ThemeLogo as du, type ThemeColors as dv, type ThemeTypography as dw, DEFAULT_THEME as dx, mergeWithDefaults as dy, generateCssVariables as dz, type Option as e, type QueryBuilderState as e$, rollupConfigSchema as e0, attributeConfigSchemas as e1, getAttributeConfigSchema as e2, validateAttributeConfig as e3, parseAttributeConfig as e4, safeParseAttributeConfig as e5, createTextValidator as e6, createNumberValidator as e7, createCheckboxValidator as e8, createDateValidator as e9, getMissingRequiredAttributes as eA, isRecordComplete as eB, computeRecordStatus as eC, type DatabaseAdapter as eD, ParticipationTokenService as eE, getDefaultTokenService as eF, initializeTokenService as eG, type ParticipationTokenPayload as eH, type TokenGenerationOptions as eI, type TokenVerificationResult as eJ, PinCodeService as eK, getDefaultPinCodeService as eL, initializePinCodeService as eM, type PinCodeGenerationOptions as eN, type PinCodeVerificationResult as eO, type CacheKeyType as eP, hashOptions as eQ, type CacheAdapter as eR, type CacheOptions as eS, cacheKeys as eT, cacheTtl as eU, defaultTtl as eV, NoopCacheAdapter as eW, type FetchResult as eX, type FormattedRecord as eY, type GroupedFetchResult as eZ, type InsertOptions as e_, createPhoneValidator as ea, createCurrencyValidator as eb, createStatusValidator as ec, createSelectValidator as ed, createMultiselectValidator as ee, createLocationValidator as ef, createFileValidator as eg, createUserValidator as eh, createSingleRelationValidator as ei, createMultiRelationValidator as ej, createRelationValidator as ek, createRatingValidator as el, createFormulaValidator as em, createRollupValidator as en, createTextAreaValidator as eo, createRichtextValidator as ep, createAttributeValidator as eq, createFormAttributeValidator as er, createObjectValidator as es, type ValidationResult as et, validateAttribute as eu, validateObject as ev, validateObjectOrThrow as ew, createDraftValidator as ex, validateDraft as ey, validateDraftOrThrow as ez, type StatusAttribute as f, type FormulaResult as f$, type RegistryMap as f0, type RegistryObjectNames as f1, type ShortcutOperator as f2, createDefaultState as f3, formatRecord as f4, formatRecords as f5, QueryMultipleResultsError as f6, QueryNoResultError as f7, SHORTCUT_TO_FILTER_OPERATOR as f8, createQueryBuilder as f9, type ExecutorContext as fA, type ExecutorErrorResult as fB, type ExecutorResult as fC, type ExecutorSuccessResult as fD, type ExecutorWaitResult as fE, type NodeExecutor as fF, complete as fG, error as fH, ExecutorRegistry as fI, success as fJ, wait as fK, ConditionExecutor as fL, EndExecutor as fM, FormExecutor as fN, StartExecutor as fO, evaluateFormula as fP, evaluateFormulaAttribute as fQ, evaluateFormulaAttributeWithRelations as fR, evaluateFormulaWithRelations as fS, evaluateFormulaWithResult as fT, extractFormulaVariables as fU, extractRelationNames as fV, extractRelationReferences as fW, flattenRelationsForEval as fX, formatFormulaResult as fY, hasRelationReferences as fZ, validateFormulaExpression as f_, QueryBuilder as fa, type QueryBuilderOptions as fb, type EvaluationResult as fc, type EvaluationTrace as fd, evaluateCondition as fe, evaluate as ff, evaluateWithTrace as fg, TenantContextError as fh, addSchemaToContext as fi, getSchemaByNameFromContext as fj, getSchemaContext as fk, getSchemaFromContext as fl, hasSchemaContext as fm, runWithMergedSchemaContext as fn, runWithSchemaContext as fo, type SchemaContext as fp, getContext as fq, getTenantId as fr, getUserId as fs, hasContext as ft, runWithContext as fu, withTenantContext as fv, type TenantContext as fw, createDefaultExecutorRegistry as fx, getDefaultExecutorRegistry as fy, type ExecutorCompleteResult as fz, type SelectAttribute as g, type RelationOptionsResponse as g$, getPathDepth as g0, getRelationPath as g1, getTargetAttributeName as g2, InvalidPathError as g3, MaxDepthExceededError as g4, parsePath as g5, pathHasManyCardinality as g6, validatePath as g7, type PathCardinality as g8, type PathSegment as g9, type WorkflowParticipationsRepository as gA, type AuditRepository as gB, type PermissionsRepository as gC, type AIConversationsRepository as gD, type AIUserMemoryRepository as gE, type AIUsageMetricsRepository as gF, BaseService as gG, BaseRepository as gH, type SchemaContextAware as gI, SchemaContextAwareRepository as gJ, TenantAwareRepository as gK, TenantAwareService as gL, type CreateCustomObjectInput as gM, type AddAttributeInput as gN, type UpdateObjectInput as gO, type ObjectSchemaServiceOptions as gP, ObjectSchemaService as gQ, type RecordServiceOptions as gR, RecordService as gS, type RecordQueryServiceOptions as gT, type QueryOptions as gU, type SearchQueryOptions as gV, type QueryResult as gW, RecordQueryService as gX, type RelationValidationResult as gY, type RelationValidationError as gZ, type RelationOption as g_, type PathSegmentType as ga, type SchemaResolver as gb, resolveMultiplePaths as gc, resolveSingleValue as gd, traversePath as ge, type TraversalOptions as gf, type TraversalResult as gg, type AttributeChange as gh, type HookContext as gi, type HookDefinition as gj, type HookHandler as gk, type HookType as gl, NoopHookRegistry as gm, type HookRegistry as gn, createMockAdapter as go, defaultPolicyRegistry as gp, PolicyRegistry as gq, notesPolicy as gr, type ObjectsRepository as gs, type AttributesRepository as gt, type UserProfilesRepository as gu, type FilesRepository as gv, type ObjectRecordsRepository as gw, type ViewsRepository as gx, type WorkflowsRepository as gy, type WorkflowInstancesRepository as gz, type SingleRelationAttribute as h, type StorageUploadInput as h$, type GetRelationOptionsParams as h0, type RelationServiceOptions as h1, type ResolveIdsBatchRequest as h2, type ResolveIdsBatchResponse as h3, RelationService as h4, RecordResolverService as h5, type ResolvedRelations as h6, type FormulaResolverServiceOptions as h7, FormulaResolverService as h8, type RollupResult as h9, type StartWorkflowInput as hA, type ResumeWorkflowInput as hB, type WorkflowInstanceServiceOptions as hC, WorkflowInstanceService as hD, type CreateParticipationInput as hE, type CreateParticipationResult as hF, type AuthenticationResult as hG, WorkflowParticipationService as hH, type FieldReadOnlyResult as hI, WorkflowRelationService as hJ, type UserValidationResult as hK, type UserValidationError as hL, UserService as hM, type UserProfileServiceOptions as hN, UserProfileService as hO, AuditService as hP, buildAuditChanges as hQ, type FileServiceOptions as hR, FileService as hS, GeocodingService as hT, GlobalSearchService as hU, type PermissionServiceOptions as hV, PermissionService as hW, type CreateViewInput as hX, type UpdateViewInput as hY, ViewService as hZ, type FileContent as h_, type RollupServiceOptions as ha, RollupService as hb, type RollupSchedulerOptions as hc, RollupScheduler as hd, applyDefaultValues as he, checkPermission as hf, getPolicy as hg, buildPolicyContext as hh, checkRecordAccess as hi, checkRecordModifyOrThrow as hj, checkRecordDeleteOrThrow as hk, checkSharedObjectWriteAccess as hl, computeLabel as hm, type LabelResolver as hn, enrichWithFormulas as ho, enrichRecordsWithFormulas as hp, createContextForCreate as hq, createContextForUpdate as hr, createContextForDelete as hs, createContextForRestore as ht, recalculateParentRollups as hu, type RollupCascadeContext as hv, type CreateWorkflowInput as hw, type UpdateWorkflowInput as hx, type WorkflowServiceOptions as hy, WorkflowService as hz, type MultiRelationAttribute as i, type StorageUploadResult as i0, type SignedUrlOptions as i1, type StorageAdapter as i2, type UploadFileInput as i3, type SyncResult as i4, type SyncOptions as i5, syncNativeObjects as i6, verifyNativeObjectsSync as i7, getSyncPreview as i8, type FullSyncResult as i9, type FileListOptions as iA, type DBView as iB, type CreateDBView as iC, type UpdateDBView as iD, type UpsertDBView as iE, type DBWorkflow as iF, type CreateDBWorkflow as iG, type UpdateDBWorkflow as iH, type DBWorkflowInstance as iI, type CreateDBWorkflowInstance as iJ, type UpdateDBWorkflowInstance as iK, type DBWorkflowParticipation as iL, type CreateDBWorkflowParticipation as iM, type UpdateDBWorkflowParticipation as iN, type OperationResult as iO, type ViewSyncResult as iP, type ViewSyncOptions as iQ, syncNativeViews as iR, verifyNativeViewsSync as iS, getViewSyncPreview as iT, type FullSyncOptions as ia, syncAll as ib, DEFAULT_LABEL_FALLBACK as ic, renderLabelExpression as id, isLabelExpression as ie, extractAttributeNames as ig, enrichValuesForDisplay as ih, enrichValuesWithSelectLabels as ii, extractRelationIds as ij, type RelationLabelResolver as ik, computeLabelWithRelations as il, type DBObject as im, type CreateDBObject as io, type UpdateDBObject as ip, type UpsertDBObject as iq, type DBAttribute as ir, type CreateDBAttribute as is, type UpdateDBAttribute as it, type UpsertDBAttribute as iu, type CreateObjectRecord as iv, type ListOptions as iw, type SearchOptions as ix, type GlobalSearchOptions as iy, type GlobalSearchResultItem 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 };