@stndrds/schema 1.0.0-alpha.329 → 1.0.0-alpha.331

package/dist/exceptions-DGCzCc9t.d.ts

@@ -0,0 +1,1405 @@
+
+import { ColorId, CountryIso3, CurrencyCode, IconName } from "@stndrds/constants";
+//#region src/computed/parser.d.ts
+type ComputedFormulaAstNode = ComputedFormulaLiteralNode | ComputedFormulaPathNode | ComputedFormulaCallNode | ComputedFormulaBinaryNode;
+interface ComputedFormulaLiteralNode {
+  kind: "literal";
+  value: string | number | boolean | null;
+}
+interface ComputedFormulaPathNode {
+  kind: "path";
+  parts: string[];
+}
+interface ComputedFormulaCallNode {
+  kind: "call";
+  functionName: string;
+  args: ComputedFormulaAstNode[];
+}
+interface ComputedFormulaBinaryNode {
+  kind: "binary";
+  operator: ComputedFormulaBinaryOperator;
+  left: ComputedFormulaAstNode;
+  right: ComputedFormulaAstNode;
+}
+type ComputedFormulaBinaryOperator = ">" | "<" | ">=" | "<=" | "==" | "!=" | "+" | "-" | "*" | "/";
+declare class ComputedFormulaParseError extends Error {
+  constructor(message: string);
+}
+declare function parseComputedFormula(expression: string): ComputedFormulaAstNode;
+//#endregion
+//#region src/computed/types.d.ts
+type ComputedReturnType = "text" | "number" | "boolean" | "date" | "select" | "multiselect";
+type ComputedFieldKind = "formula" | "rollup";
+type ComputedValueType = {
+  kind: "scalar";
+  type: Exclude<ComputedReturnType, "multiselect">;
+} | {
+  kind: "collection";
+  itemType: "text" | "number" | "boolean" | "date" | "select";
+};
+interface ComputedOptionsSource {
+  objectName: string;
+  attributeName: string;
+  attributeId?: string;
+}
+type ComputedDependency = {
+  kind: "local";
+  attributeName: string;
+} | {
+  kind: "relation";
+  relationName: string;
+  targetAttributeName?: string;
+  cardinality?: "one" | "many";
+} | {
+  kind: "computed";
+  attributeName: string;
+} | {
+  kind: "options";
+  source: ComputedOptionsSource;
+};
+interface ComputedPlan {
+  kind: ComputedFieldKind;
+  attributeName: string;
+  expression: string;
+  returnType: ComputedReturnType;
+  valueType: ComputedValueType;
+  dependencies: ComputedDependency[];
+  optionsSource?: ComputedOptionsSource;
+  targetAttributeType?: AttributeType;
+  dependenciesHash: string;
+  ast?: ComputedFormulaAstNode;
+}
+//#endregion
+//#region src/computed/functions.d.ts
+declare const COMPUTED_FUNCTION_NAMES: readonly ["if", "concat", "sum", "avg", "count", "min", "max", "earliest", "latest", "unique", "first", "percent_empty", "percent_not_empty", "count_empty", "count_not_empty", "count_unique"];
+type ComputedFunctionName = (typeof COMPUTED_FUNCTION_NAMES)[number];
+interface ComputedFunctionSignature {
+  name: ComputedFunctionName;
+  returnType: ComputedValueType | "argument" | "branch" | "source_item";
+  minArgs: number;
+  maxArgs?: number;
+}
+declare const COMPUTED_FUNCTIONS: Record<ComputedFunctionName, ComputedFunctionSignature>;
+declare function isComputedFunctionName(name: string): name is ComputedFunctionName;
+//#endregion
+//#region src/computed/compiler.d.ts
+interface ComputedCompileAttribute {
+  name: string;
+  type: AttributeType;
+  id?: string;
+  returnType?: ComputedReturnType;
+  optionsSource?: ComputedOptionsSource;
+  options?: readonly unknown[];
+  cardinality?: "one" | "many";
+  targetObjectName?: string;
+  targets?: readonly {
+    object: string;
+  }[];
+}
+interface ComputedCompileObject {
+  objectName: string;
+  attributes: readonly ComputedCompileAttribute[];
+}
+interface ComputedCompileSchema extends ComputedCompileObject {
+  relatedObjects?: Record<string, ComputedCompileObject>;
+}
+interface CompileComputedFormulaInput {
+  attributeName: string;
+  expression: string;
+  returnType: ComputedReturnType;
+  schema: ComputedCompileSchema;
+}
+interface ComputedDependencyGraphNode {
+  attributeName: string;
+  dependencies: readonly ComputedDependency[];
+}
+declare class ComputedFormulaCompileError extends Error {
+  constructor(message: string);
+}
+declare function compileComputedFormula(input: CompileComputedFormulaInput): ComputedPlan;
+declare function assertAcyclicComputedDependencies(nodes: readonly ComputedDependencyGraphNode[]): void;
+//#endregion
+//#region src/computed/rollup-compiler.d.ts
+declare function rollupToFormulaExpression(attr: RollupAttribute): string;
+declare function inferRollupReturnType(attr: RollupAttribute, schema: ComputedCompileSchema): ComputedReturnType;
+declare function compileRollupAttribute(attr: RollupAttribute, schema: ComputedCompileSchema): ComputedPlan;
+//#endregion
+//#region src/computed/evaluator.d.ts
+declare function isPlainRecord(value: unknown): value is Record<string, unknown>;
+declare function formatComputedResult(value: unknown, returnType: ComputedReturnType, decimals?: number): unknown;
+declare function evaluateComputedAst(node: ComputedFormulaAstNode, input: Record<string, unknown>): unknown;
+declare function evaluateComputedFormula(expression: string, input: Record<string, unknown>): unknown;
+interface ComputedFormulaResult {
+  value: unknown;
+  error?: string;
+}
+declare function evaluateComputedFormulaWithResult(expression: string, input: Record<string, unknown>, returnType?: ComputedReturnType, decimals?: number): ComputedFormulaResult;
+//#endregion
+//#region src/computed/function-metadata.d.ts
+type ComputedFunctionCategory = "logic" | "text" | "number" | "date" | "collection";
+interface ComputedFunctionMetadata {
+  name: ComputedFunctionName;
+  signature: string;
+  description: string;
+  category: ComputedFunctionCategory;
+  example: string;
+}
+declare const COMPUTED_FUNCTION_METADATA: ComputedFunctionMetadata[];
+//#endregion
+//#region src/utils/stable-json.d.ts
+declare class NonJsonValueError extends SchemaError {
+  constructor();
+}
+/**
+ * Serializes a value into deterministic JSON: object keys are sorted
+ * recursively, array order is preserved, `undefined` object entries are
+ * omitted, and no whitespace is emitted.
+ *
+ * The canonicalization hashed across the runtime boot seed, the server, the CLI
+ * and `@stndrds/reflex` — the output must stay byte-identical for equivalent
+ * inputs regardless of key insertion order or jsonb storage round-trips.
+ *
+ * @throws {ValidationError} On circular references, unsupported value types
+ * (functions, symbols, bigint), and on a `Date`, `Map`, `Set` or any other
+ * non-plain object — it is a content identity, and those carry no own
+ * enumerable entry, so emitting them as `{}` made two different values hash
+ * alike (#3406). Project such a value yourself (`date.toISOString()`,
+ * `[...map]`) before hashing it.
+ */
+declare function canonicalStringify(value: unknown): string;
+/**
+ * Key-sorted JSON for comparing values that round-trip through jsonb. Coerces
+ * what JSON cannot express rather than refusing — the caller is asking "are
+ * these the same?", not "is this valid?".
+ */
+declare function serializeStableJson(value: unknown): string;
+/**
+ * Key-sorted JSON for content identity. Throws {@link NonJsonValueError} on
+ * anything JSON cannot represent, so two different values never hash alike.
+ */
+declare function serializeCanonicalJson(value: unknown): string;
+/**
+ * Order-insensitive deep equality over {@link serializeStableJson}.
+ *
+ * Not `deepEqual` from `../utils`: that one compares in place without
+ * allocating, and answers differently for `NaN`, for an explicitly-`undefined`
+ * entry, and for a cycle. Reach for this when the bytes are the point.
+ */
+declare function sameStableValue(left: unknown, right: unknown): boolean;
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Brand symbol for nominal typing.
+ * This ensures type-safety by making IDs non-interchangeable.
+ */
+declare const __brand: unique symbol;
+/**
+ * Creates a branded type from a base type.
+ * Branded types are structurally identical but nominally different.
+ */
+type Brand<T, B> = T & {
+  readonly [__brand]: B;
+};
+/**
+ * UUID string type for all identifiers
+ */
+type Uuid = string;
+/**
+ * Tenant identifier for multi-tenant isolation.
+ * Branded type to prevent accidental mixing with other string IDs.
+ *
+ * @example
+ * ```typescript
+ * const tenantId: TenantId = asTenantId('tenant-123');
+ * const userId: UserId = asUserId('user-456');
+ *
+ * // Type error: cannot assign UserId to TenantId
+ * const wrong: TenantId = userId;
+ * ```
+ */
+type TenantId = Brand<string, "TenantId">;
+/**
+ * User identifier for audit trails and permissions.
+ * Branded type to prevent accidental mixing with other string IDs.
+ */
+type UserId = Brand<string, "UserId">;
+/**
+ * Convert a string to a TenantId.
+ * Use this when receiving tenant IDs from external sources (JWT, headers).
+ *
+ * @param id - The string to convert
+ * @returns A branded TenantId
+ *
+ * @example
+ * ```typescript
+ * const tenantId = asTenantId(request.headers['x-tenant-id']);
+ * ```
+ */
+declare function asTenantId(id: string): TenantId;
+/**
+ * Convert a string to a UserId.
+ * Use this when receiving user IDs from external sources (JWT, auth).
+ *
+ * @param id - The string to convert
+ * @returns A branded UserId
+ *
+ * @example
+ * ```typescript
+ * const userId = asUserId(jwtPayload.sub);
+ * ```
+ */
+declare function asUserId(id: string): UserId;
+/**
+ * Generate a unique UUID v4
+ * Uses crypto.randomUUID() when available (Node.js 19+, modern browsers)
+ * Falls back to a manual implementation for older environments
+ *
+ * @returns A UUID v4 string
+ *
+ * @example
+ * ```typescript
+ * const id = generateId();
+ * // "a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"
+ * ```
+ */
+declare function generateId(): Uuid;
+/**
+ * Create a Map indexed by a key extracted from each item.
+ * This eliminates the repeated pattern: new Map(items.map(item => [keyFn(item), item]))
+ *
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ *
+ * @param items - Array of items to index
+ * @param keyFn - Function to extract the key from each item
+ * @returns Map indexed by the extracted key
+ *
+ * @example
+ * ```typescript
+ * const attributes = [{ name: "title", type: "text" }, { name: "status", type: "select" }];
+ *
+ * // Before:
+ * const attrMap = new Map(attributes.map(a => [a.name, a]));
+ *
+ * // After:
+ * const attrMap = indexBy(attributes, a => a.name);
+ * ```
+ */
+declare function indexBy<T, K extends PropertyKey>(items: T[], keyFn: (item: T) => K): Map<K, T>;
+/**
+ * Deep equality comparison for plain objects and arrays.
+ * Handles nested structures, arrays, primitives, null, and undefined.
+ *
+ * Time complexity: O(n) where n is total number of properties
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @returns true if values are deeply equal
+ *
+ * @example
+ * ```typescript
+ * deepEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } }); // true
+ * deepEqual({ a: 1, b: 2 }, { b: 2, a: 1 }); // true (order-independent)
+ * deepEqual([1, 2, 3], [1, 2, 3]); // true
+ * deepEqual([1, 2], [2, 1]); // false (arrays preserve order)
+ * ```
+ */
+declare function deepEqual(a: unknown, b: unknown): boolean;
+//#endregion
+//#region src/types/relation-properties.d.ts
+/**
+ * Allowed attribute types in .qualifyWith()
+ *
+ * IMPORTANT: Complex types (formula, rollup, relation, file, user, document, richtext)
+ * are NOT supported to avoid duplicating backend behavior.
+ */
+type PropertyType = "text" | "number" | "checkbox" | "date" | "phone" | "currency" | "status" | "select" | "multiselect" | "location";
+/**
+ * Union of attribute types allowed as qualified relation properties.
+ *
+ * These are the same Attribute types used for object attributes,
+ * restricted to simple types that don't require complex backend duplication.
+ */
+type PropertyAttribute = TextAttribute | NumberAttribute | CheckboxAttribute | DateAttribute | PhoneAttribute | CurrencyAttribute | StatusAttribute | SelectAttribute | MultiselectAttribute | LocationAttribute;
+/**
+ * Schema defining properties for a qualified relation.
+ *
+ * Uses the same Attribute types as object attributes, enabling DRY builders:
+ *
+ * @example
+ * ```typescript
+ * relation({ name: "companies", label: "Companies" })
+ *   .to("companies").many()
+ *   .qualifyWith(
+ *     select({ name: "role", label: "Role" }).options([...]).required(),
+ *     number({ name: "shares", label: "Shares" }).min(0),
+ *   )
+ * ```
+ */
+interface PropertySchema {
+  definitions: PropertyAttribute[];
+}
+/**
+ * Normalizes an attribute's `properties` field to a flat list of
+ * {@link PropertyAttribute}. Handles both the production {@link PropertySchema}
+ * shape (`{ definitions: [...] }`) and the raw-array shape used in test
+ * fixtures (`PropertyAttribute[]`).
+ */
+declare function resolvePropertyDefinitions(attr: unknown): PropertyAttribute[];
+/**
+ * Property attribute types that have an `options` array.
+ */
+type OptionPropertyAttribute = SelectAttribute | StatusAttribute | MultiselectAttribute;
+/**
+ * Type guard to check if a property attribute has options.
+ *
+ * @param attr - The property attribute to check
+ * @returns true if the attribute is a select, status, or multiselect type with options
+ *
+ * @example
+ * ```typescript
+ * for (const def of definitions) {
+ *   if (hasOptions(def)) {
+ *     // TypeScript knows def.options exists and is Option[]
+ *     for (const option of def.options) {
+ *       console.log(option.value);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare function hasOptions(attr: PropertyAttribute): attr is OptionPropertyAttribute;
+//#endregion
+//#region src/types/attributes.d.ts
+declare const ATTRIBUTE_TYPES: readonly ["text", "richtext", "number", "checkbox", "date", "phone", "currency", "status", "location", "select", "multiselect", "user", "relation", "formula", "rollup", "document"];
+type AttributeType = (typeof ATTRIBUTE_TYPES)[number];
+/**
+ * Status group categorization
+ */
+type StatusGroup = "idle" | "in_progress" | "finished";
+/**
+ * Unified option type for select-like fields
+ */
+interface Option {
+  value: string;
+  label: string;
+  color?: ColorId;
+  description?: string;
+  group?: StatusGroup;
+  /** Value of the inverse option for bilateral relations (e.g. "parent" → "child") */
+  inverse?: string;
+  archived?: boolean;
+}
+/**
+ * Attribute grouping for UI organization
+ */
+interface AttributeGroup {
+  id: string;
+  label: string;
+  description?: string;
+  attributeIds: string[];
+  collapsible?: boolean;
+  collapsed?: boolean;
+  order?: number;
+}
+interface BaseAttribute<DefaultValueType = unknown> {
+  id?: Uuid;
+  objectId?: Uuid;
+  name: string;
+  label: string;
+  type: AttributeType;
+  required?: boolean;
+  placeholder?: string;
+  description?: string;
+  defaultValue?: DefaultValueType;
+  icon?: IconName;
+  order?: number;
+  hidden?: boolean;
+  archived?: boolean;
+  deprecated?: boolean;
+  system?: boolean;
+  unique?: boolean;
+  metadata?: Record<string, unknown>;
+}
+interface TextAttribute extends BaseAttribute<string> {
+  type: "text";
+  multiline?: boolean;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  format?: "email" | "url" | "slug";
+}
+type NumberUnit = "integer" | "decimal" | "percentage";
+interface NumberAttribute extends BaseAttribute<number> {
+  type: "number";
+  min?: number;
+  max?: number;
+  unit?: NumberUnit;
+  decimals?: number;
+  renderAs?: "number" | "rating";
+}
+interface CheckboxAttribute extends BaseAttribute<boolean> {
+  type: "checkbox";
+}
+type DateFormat = "short" | "long" | "full" | "relative";
+type DateValue = string | "today";
+type TimeFormat = "12h" | "24h";
+/** Stored value of a date attribute configured with `.endDate()`. */
+interface DateRangeValue {
+  start: string;
+  end: string | null;
+}
+interface DateAttribute extends BaseAttribute<string | DateRangeValue> {
+  type: "date";
+  dateFormat?: DateFormat;
+  minDate?: DateValue;
+  maxDate?: DateValue;
+  /** Values carry a time component; stored as full ISO UTC datetimes. */
+  includeTime?: boolean;
+  /** Values are ranges stored as { start, end } objects. */
+  endDate?: boolean;
+  /** Display format for the time component. Defaults to "24h". */
+  timeFormat?: TimeFormat;
+}
+interface Phone {
+  countryCode: CountryIso3;
+  phoneNumber: string;
+}
+interface PhoneAttribute extends BaseAttribute<Phone> {
+  type: "phone";
+  defaultCountryCode?: CountryIso3;
+}
+interface Currency {
+  code: CurrencyCode;
+  value: number;
+}
+interface CurrencyAttribute extends BaseAttribute<Currency> {
+  type: "currency";
+  defaultCurrency?: CurrencyCode;
+  allowedCurrencies?: CurrencyCode[];
+  /** Allow negative currency values (e.g. refunds, credits). Defaults to false. */
+  allowNegative?: boolean;
+}
+/**
+ * StatusAttribute - For workflow states with semantic grouping (idle/in_progress/finished)
+ * Use this for: Task status, Order status, Project phases, Process states
+ * Use SelectAttribute for: Categories, Types, simple choices without workflow
+ */
+interface StatusAttribute extends BaseAttribute<string> {
+  type: "status";
+  options: Option[];
+}
+interface Location {
+  address?: string;
+  address2?: string;
+  city?: string;
+  state?: string;
+  postalCode?: string;
+  country?: CountryIso3;
+  latitude?: number;
+  longitude?: number;
+}
+type LocationGranularity = "full" | "address" | "city" | "state" | "country" | "coordinates";
+interface LocationAttribute extends BaseAttribute<Location> {
+  type: "location";
+  granularity?: LocationGranularity;
+  defaultCountry?: CountryIso3;
+  allowedCountries?: CountryIso3[];
+}
+/**
+ * SelectAttribute - For simple single-choice selection
+ * Use this for: Categories, Document types, Departments, Priorities
+ * Options can be grouped (e.g., countries by continent) but no workflow logic
+ */
+interface SelectAttribute extends BaseAttribute<string> {
+  type: "select";
+  options: Option[];
+  renderAs?: "badges";
+}
+interface MultiselectAttribute extends BaseAttribute<string[]> {
+  type: "multiselect";
+  options: Option[];
+  renderAs?: "badges";
+}
+type UserReferenceType = "user" | "agent";
+interface UserAttribute extends BaseAttribute<string | string[]> {
+  type: "user";
+  types?: UserReferenceType[];
+  multiple?: boolean;
+}
+/**
+ * Wildcard marker for universal relations (can link to any object)
+ * Use with `.toAny()` builder method
+ */
+declare const RELATION_TARGET_ANY: "*";
+/**
+ * Configuration for bilateral synchronization (bidirectional relations)
+ */
+interface BilateralConfig {
+  /** Target object containing the inverse attribute */
+  object: string;
+  /** Name of the inverse attribute */
+  attribute: string;
+  /** Optional cardinality override (inferred by default) */
+  cardinality?: "one" | "many";
+  /** Label for the inverse attribute when it is generated from this declaration. */
+  label?: string;
+  /** When true, this side owns the storage direction for qualified properties.
+   *  Set to false on the inverse side (enriched at read time). */
+  storageOwner?: boolean;
+}
+/**
+ * Target object for a relation - defines which objects can be linked
+ */
+interface RelationTarget {
+  /** Object name (e.g., "companies", "contacts") or "*" for any object */
+  object: string;
+  /**
+   * Display template for the label using mustache-like syntax
+   * @example "{name}" or "{firstName} {lastName} — {email}"
+   */
+  displayTemplate?: string;
+  /**
+   * Optional filter to restrict available records
+   * @example { status: "active" }
+   */
+  filter?: Record<string, unknown>;
+}
+/**
+ * Base properties shared by both single and multi relation attributes
+ *
+ * Note: Deletion behavior is always "restrict" - if a record is referenced
+ * by other records, it cannot be deleted until those references are removed.
+ * This is enforced by RecordService.deleteRecord() which throws
+ * RecordReferencedError when attempting to delete a referenced record.
+ */
+interface RelationAttributeBase extends Omit<BaseAttribute<unknown>, "defaultValue"> {
+  type: "relation";
+  /** Target objects that can be linked */
+  targets: RelationTarget[];
+  /** Optional properties schema for qualified relations */
+  properties?: PropertySchema;
+  /** Configuration for bilateral synchronization (opt-in) */
+  bilateral?: BilateralConfig;
+}
+/**
+ * Single relation attribute (one-to-one or many-to-one)
+ * Stores a single record ID or null
+ */
+interface SingleRelationAttribute extends RelationAttributeBase {
+  cardinality: "one";
+  defaultValue?: string | null;
+}
+/**
+ * Multi relation attribute (one-to-many or many-to-many)
+ * Stores an array of record IDs
+ */
+interface MultiRelationAttribute extends RelationAttributeBase {
+  cardinality: "many";
+  defaultValue?: string[];
+  /** Maximum number of relations allowed */
+  maxItems?: number;
+}
+/**
+ * RelationAttribute links to other objects/records
+ * Discriminated union by cardinality for type-safe value handling
+ *
+ * @example Single relation (many-to-one)
+ * ```typescript
+ * relation({ name: "company", label: "Company" })
+ *   .to("companies")
+ *   .required()
+ * // → Value: "rec-uuid-123" | null
+ * ```
+ *
+ * @example Multi relation (many-to-many)
+ * ```typescript
+ * relation({ name: "contacts", label: "Contacts" })
+ *   .to("contacts", { displayTemplate: "{firstName} {lastName}" })
+ *   .many()
+ *   .maxItems(5)
+ * // → Value: ["rec-1", "rec-2", ...]
+ * ```
+ *
+ * @example Polymorphic relation (multiple target objects)
+ * ```typescript
+ * relation({ name: "linked", label: "Linked Items" })
+ *   .to("companies")
+ *   .to("contacts")
+ *   .to("deals")
+ *   .many()
+ * // → Can link to records from any of these objects
+ * ```
+ */
+type RelationAttribute = SingleRelationAttribute | MultiRelationAttribute;
+/**
+ * Check if a relation attribute is universal (can link to any object)
+ * Universal relations have `targets: [{ object: "*" }]`
+ */
+/**
+ * The object names a relation attribute can point at, universal marker
+ * stripped. Any other attribute type — and a relation row whose config lost
+ * its `targets` — yields no names.
+ */
+declare function relationTargetsOf(attribute: Attribute): string[];
+declare function isUniversalRelation(attr: RelationAttribute): boolean;
+/**
+ * Check if a relation attribute has bilateral synchronization enabled
+ */
+declare function isBilateralRelation(attr: RelationAttribute): attr is RelationAttribute & {
+  bilateral: BilateralConfig;
+};
+/**
+ * Infer the cardinality of the inverse relation
+ * - one → many (contact.company ↔ company.contacts)
+ * - many → many (contact.tags ↔ tag.contacts)
+ */
+declare function inferInverseCardinality(cardinality: "one" | "many"): "one" | "many";
+/**
+ * RichtextAttribute - Rich text content using semantic markdown
+ *
+ * Stores content as semantic markdown string (with directives like :::callout).
+ * Parsed at runtime to Tiptap JSON for editing.
+ * Use this for: Notes, articles, descriptions, long-form content.
+ *
+ * @example
+ * ```typescript
+ * richtext({ name: "content", label: "Content" }).required()
+ * ```
+ */
+interface RichtextAttribute extends BaseAttribute<string> {
+  type: "richtext";
+}
+type RichTextAttribute = RichtextAttribute;
+/**
+ * Return type for formula expressions
+ */
+type FormulaReturnType = ComputedReturnType;
+/**
+ * FormulaAttribute - Computed value based on other attributes
+ *
+ * Formulas are calculated at read-time and are always read-only.
+ * Users cannot directly edit formula values.
+ *
+ * @example Simple calculation
+ * ```typescript
+ * formula({ name: "total", label: "Total" })
+ *   .expression("price * quantity")
+ *   .returns("number")
+ *   .decimals(2)
+ * ```
+ *
+ * @example With functions
+ * ```typescript
+ * formula({ name: "fullName", label: "Full Name" })
+ *   .expression("CONCAT(firstName, ' ', lastName)")
+ *   .returns("text")
+ * ```
+ */
+interface FormulaAttribute extends Omit<BaseAttribute<never>, "defaultValue" | "required"> {
+  type: "formula";
+  /** Expression to evaluate (e.g., "price * quantity") */
+  expression: string;
+  /** Expected return type for formatting */
+  returnType: FormulaReturnType;
+  /** Decimal places for number results */
+  decimals?: number;
+  /** Source attribute for select-like computed options */
+  optionsSource?: ComputedOptionsSource;
+  /** Whether to allow relation references in the expression (e.g., "company.name") */
+  allowRelations?: boolean;
+  /** Formula is always not required (read-only) */
+  required: false;
+}
+/**
+ * Aggregation functions for rollup attributes
+ *
+ * Categories:
+ * - Numeric (sum, avg): Only for number and currency types
+ * - Date (earliest, latest): Only for date type
+ * - Count (count, countValues, countUniqueValues, countEmpty): Universal
+ * - Percent (percentEmpty, percentNotEmpty): Universal
+ * - Lookup (original): Returns all values as array, rendered as target type
+ */
+type RollupFunction = "sum" | "avg" | "earliest" | "latest" | "count" | "countValues" | "countUniqueValues" | "countEmpty" | "percentEmpty" | "percentNotEmpty" | "original";
+/**
+ * RollupAttribute - Aggregates values from related records
+ *
+ * Rollups are calculated and stored (denormalized) for performance.
+ * They are automatically recalculated when related records change.
+ * Users cannot directly edit rollup values.
+ *
+ * @example Sum of related amounts
+ * ```typescript
+ * rollup({ name: "totalOrders", label: "Total Orders" })
+ *   .from("orders")           // relation attribute name
+ *   .aggregate("amount")      // target attribute to sum
+ *   .using("sum")
+ *   .decimals(2)
+ * ```
+ *
+ * @example Count of related records
+ * ```typescript
+ * rollup({ name: "orderCount", label: "Number of Orders" })
+ *   .from("orders")
+ *   .using("count")
+ * ```
+ */
+interface RollupAttribute extends Omit<BaseAttribute<never>, "defaultValue" | "required"> {
+  type: "rollup";
+  /** Name of the relation attribute on this object */
+  relationAttribute: string;
+  /**
+   * Dot notation path for multi-level traversal (Phase 4+)
+   * @example "orders.items" - traverse through orders to items
+   */
+  relationPath?: string;
+  /** Attribute name on the target object to aggregate */
+  targetAttribute: string;
+  /** Aggregation function to apply */
+  function: RollupFunction;
+  /** Decimal places for numeric results */
+  decimals?: number;
+  /** Rollup is always not required (read-only) */
+  required: false;
+  /**
+   * Cached type of the target attribute for display purposes
+   * Used when function="original" to render values as the target type
+   */
+  targetAttributeType?: AttributeType;
+  /**
+   * Cached currency code of a currency target, from its `defaultCurrency`
+   * (#2644). The stored rollup value stays a bare number; this is the
+   * schema-derived channel that lets a single-code sum/avg render with its
+   * symbol. Absent → the value renders bare, exactly as before.
+   *
+   * Named for what it holds — an ISO 4217 CODE — rather than the siblings'
+   * `targetAttribute*` prefix: `targetAttributeCurrency` would read as a
+   * `Currency` value, which this deliberately is not.
+   */
+  targetCurrencyCode?: CurrencyCode;
+  /**
+   * Cached options from target attribute (for select/status/multiselect display)
+   * Required when function="original" and target is a select-like type
+   */
+  targetAttributeOptions?: Option[];
+  /** Source attribute for select-like computed options */
+  optionsSource?: ComputedOptionsSource;
+}
+/**
+ * DocumentAttribute - References structured documents.
+ *
+ * A DocumentAttribute references packs of anonymous files with typed edge
+ * properties.
+ *
+ * Every document attribute is multi by construction — the underlying storage
+ * (documents + files) supports 1 Doc → N files uniformly.
+ *
+ * @example
+ * ```typescript
+ * document({ name: "contracts", label: "Contrats" })
+ *   .accepts(["application/pdf"])
+ * ```
+ */
+interface DocumentAttribute extends BaseAttribute<string[]> {
+  type: "document";
+  /**
+   * Schema for typed properties on the record→document edge.
+   * Symmetric with `RelationAttribute.properties`; populated by `.qualifyWith(...)`.
+   * Stored on `record_reference_edges.properties`, not on the document itself.
+   */
+  properties?: PropertySchema;
+  /** MIME prefixes/globs (e.g. "image/*", "application/pdf") applied to every file of the pack. */
+  accepts?: string[];
+  /** Hard ceiling in bytes applied to every file of the pack. */
+  maxFileSize?: number;
+}
+/**
+ * Union of every attribute definition supported by Standards objects.
+ *
+ * Use this type when code needs to inspect or render attributes generically
+ * across primitive, relation, computed, user, and document fields.
+ */
+type Attribute = TextAttribute | RichtextAttribute | NumberAttribute | CheckboxAttribute | DateAttribute | PhoneAttribute | CurrencyAttribute | StatusAttribute | LocationAttribute | SelectAttribute | MultiselectAttribute | UserAttribute | RelationAttribute | FormulaAttribute | RollupAttribute | DocumentAttribute;
+/**
+ * Check if an attribute supports sorting based on its type.
+ */
+declare function isAttributeSortable(attr: {
+  type: AttributeType;
+}): boolean;
+//#endregion
+//#region src/types/migrations.d.ts
+type BuiltInTransform = "toString" | "toNumber" | "toDate" | "toBoolean" | "toISOString";
+type SchemaOperation = {
+  type: "add_attribute";
+  attribute: Attribute;
+} | {
+  type: "remove_attribute";
+  name: string;
+  backup_config?: Attribute;
+} | {
+  type: "rename_attribute";
+  from: string;
+  to: string;
+} | {
+  type: "change_type";
+  name: string;
+  from: AttributeType;
+  to: AttributeType;
+  transform?: BuiltInTransform;
+} | {
+  type: "update_config";
+  name: string;
+  from: Partial<Record<string, unknown>>;
+  to: Partial<Record<string, unknown>>;
+} | {
+  type: "remove_object";
+  backup: Record<string, unknown>;
+} | {
+  type: "rename_object";
+  from: string;
+  to: string;
+};
+interface MigrationDefinition {
+  version: number;
+  operations: SchemaOperation[];
+}
+//#endregion
+//#region src/exceptions.d.ts
+/**
+ * Error codes for schema exceptions
+ */
+declare const SchemaErrorCode: {
+  readonly DRAFT_REVISION_CONFLICT: "DRAFT_REVISION_CONFLICT";
+  readonly UNKNOWN: "SCHEMA_UNKNOWN_ERROR";
+  readonly OBJECT_NOT_FOUND: "SCHEMA_OBJECT_NOT_FOUND";
+  readonly ATTRIBUTE_NOT_FOUND: "SCHEMA_ATTRIBUTE_NOT_FOUND";
+  readonly RECORD_NOT_FOUND: "SCHEMA_RECORD_NOT_FOUND";
+  readonly SOURCE_NOT_FOUND: "SCHEMA_SOURCE_NOT_FOUND";
+  readonly ROLE_NOT_FOUND: "SCHEMA_ROLE_NOT_FOUND";
+  readonly MEMORY_NOT_FOUND: "SCHEMA_MEMORY_NOT_FOUND";
+  readonly SCHEMA_PLAN_NOT_FOUND: "SCHEMA_PLAN_NOT_FOUND";
+  readonly VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED";
+  readonly INVALID_ATTRIBUTE_NAME: "SCHEMA_INVALID_ATTRIBUTE_NAME";
+  readonly INVALID_OBJECT_NAME: "SCHEMA_INVALID_OBJECT_NAME";
+  /** A consumer declared, registered, bundled or sourced an object under a framework-native name (#3450). */
+  readonly RESERVED_OBJECT_NAME: "SCHEMA_RESERVED_OBJECT_NAME";
+  readonly PROTECTED_OBJECT: "SCHEMA_PROTECTED_OBJECT";
+  readonly PROTECTED_ATTRIBUTE: "SCHEMA_PROTECTED_ATTRIBUTE";
+  readonly PROTECTED_VIEW: "SCHEMA_PROTECTED_VIEW";
+  readonly PROTECTED_ROLE: "SCHEMA_PROTECTED_ROLE";
+  readonly FORBIDDEN: "SCHEMA_FORBIDDEN";
+  readonly ACCESS_DENIED: "SCHEMA_ACCESS_DENIED";
+  /**
+   * A workspace RULE refuses the write — the last owner cannot be removed.
+   *
+   * Not `INVARIANT_VIOLATION`, despite the name: that one is an internal
+   * "should never happen" assertion, a bug signal nobody outside the codebase
+   * can act on. This is the opposite — a rule the caller can act on, reached
+   * by a request that was entirely well-formed, whose message tells them how.
+   */
+  readonly WORKSPACE_INVARIANT: "SCHEMA_WORKSPACE_INVARIANT";
+  /** The resource's own state refuses the operation — a disarmed reflex run. */
+  readonly STATE_GATE: "SCHEMA_STATE_GATE";
+  /** The operation needs an actor and the request carried none. */
+  readonly ACTOR_CONTEXT_REQUIRED: "SCHEMA_ACTOR_CONTEXT_REQUIRED";
+  readonly CONNECTOR_AUTH_FAILED: "SCHEMA_CONNECTOR_AUTH_FAILED";
+  readonly CONNECTOR_INVALID_STATE: "SCHEMA_CONNECTOR_INVALID_STATE";
+  /**
+   * The provider issued tokens and the flow failed AFTER that — resolving the
+   * connected address. Distinct from CONNECTOR_AUTH_FAILED because the user is
+   * left holding a real grant: consent happened, and it may still be live on the
+   * provider side even though no connection row exists here.
+   */
+  readonly CONNECTOR_GRANT_ORPHANED: "SCHEMA_CONNECTOR_GRANT_ORPHANED";
+  readonly SYNC_FAILED: "SCHEMA_SYNC_FAILED";
+  readonly SYNC_CONFLICT: "SCHEMA_SYNC_CONFLICT";
+  readonly SYNC_CASCADE: "SCHEMA_SYNC_CASCADE";
+  readonly ORPHAN_SYSTEM_ATTRIBUTE: "SCHEMA_ORPHAN_SYSTEM_ATTRIBUTE";
+  readonly SYSTEM_ENTITY_IMMUTABLE: "SCHEMA_SYSTEM_ENTITY_IMMUTABLE";
+  readonly DESTRUCTIVE_NOT_ALLOWED: "SCHEMA_DESTRUCTIVE_NOT_ALLOWED";
+  readonly MIGRATION_TIMEOUT: "SCHEMA_MIGRATION_TIMEOUT";
+  readonly CHANGE_TYPE_NOT_SUPPORTED: "SCHEMA_CHANGE_TYPE_NOT_SUPPORTED";
+  readonly DUPLICATE: "SCHEMA_DUPLICATE";
+  readonly DUPLICATE_OBJECT: "SCHEMA_DUPLICATE_OBJECT";
+  readonly DUPLICATE_ATTRIBUTE: "SCHEMA_DUPLICATE_ATTRIBUTE";
+  readonly CONFLICT: "SCHEMA_CONFLICT";
+  readonly STORAGE_UPLOAD_FAILED: "SCHEMA_STORAGE_UPLOAD_FAILED";
+  readonly STORAGE_DOWNLOAD_FAILED: "SCHEMA_STORAGE_DOWNLOAD_FAILED";
+  readonly STORAGE_DELETE_FAILED: "SCHEMA_STORAGE_DELETE_FAILED";
+  readonly STORAGE_URL_FAILED: "SCHEMA_STORAGE_URL_FAILED";
+  readonly REPOSITORY_CREATE_FAILED: "SCHEMA_REPOSITORY_CREATE_FAILED";
+  readonly REPOSITORY_UPDATE_FAILED: "SCHEMA_REPOSITORY_UPDATE_FAILED";
+  readonly REPOSITORY_DELETE_FAILED: "SCHEMA_REPOSITORY_DELETE_FAILED";
+  readonly REPOSITORY_QUERY_FAILED: "SCHEMA_REPOSITORY_QUERY_FAILED";
+  readonly NOT_IMPLEMENTED: "SCHEMA_NOT_IMPLEMENTED";
+  readonly TIMEOUT: "SCHEMA_TIMEOUT";
+  readonly RECORD_REFERENCED: "SCHEMA_RECORD_REFERENCED";
+  readonly ATTRIBUTE_IN_USE: "SCHEMA_ATTRIBUTE_IN_USE";
+  readonly OBJECT_REFERENCED: "SCHEMA_OBJECT_REFERENCED";
+  readonly CONFIGURATION_REQUIRED: "CONFIGURATION_REQUIRED";
+  readonly SEARCH_ADAPTER_REQUIRED: "SEARCH_ADAPTER_REQUIRED";
+  readonly CRON_REGISTRATION_FAILED: "CRON_REGISTRATION_FAILED";
+  readonly SEARCH_BACKEND_FAILED: "SEARCH_BACKEND_FAILED";
+  readonly INVARIANT_VIOLATION: "INVARIANT_VIOLATION";
+  readonly TENANT_CONTEXT_MISSING: "TENANT_CONTEXT_MISSING";
+  readonly FEATURE_FLAGS_CONTEXT: "FEATURE_FLAGS_CONTEXT";
+  readonly REALTIME_RATE_LIMITED: "REALTIME_RATE_LIMITED";
+  readonly REALTIME_DELIVERY_FAILED: "REALTIME_DELIVERY_FAILED";
+  readonly REALTIME_SUBSCRIPTION_FAILED: "REALTIME_SUBSCRIPTION_FAILED";
+  readonly AGENT_UNKNOWN: "AGENT_UNKNOWN";
+  readonly AGENT_DEPTH_EXCEEDED: "AGENT_DEPTH_EXCEEDED";
+  readonly AGENT_COST_LIMIT_EXCEEDED: "AGENT_COST_LIMIT_EXCEEDED";
+  readonly AGENT_TREE_COST_LIMIT_EXCEEDED: "AGENT_TREE_COST_LIMIT_EXCEEDED";
+  readonly CREDITS_EXHAUSTED: "CREDITS_EXHAUSTED";
+  readonly QUOTA_EXCEEDED: "QUOTA_EXCEEDED";
+  readonly AGENT_SESSION_NOT_FOUND: "AGENT_SESSION_NOT_FOUND";
+  readonly AGENT_DEFINITION_NOT_FOUND: "AGENT_DEFINITION_NOT_FOUND";
+  readonly AGENT_RUN_CONFIG: "AGENT_RUN_CONFIG";
+  readonly AGENT_STREAMING: "AGENT_STREAMING";
+  readonly AGENT_MISSING_ACTOR: "AGENT_MISSING_ACTOR";
+  readonly AGENT_INVALID_STATE: "AGENT_INVALID_STATE";
+  readonly AGENT_COMPACTION_IMPOSSIBLE: "AGENT_COMPACTION_IMPOSSIBLE";
+  readonly AGENT_COMPACTION_TIMEOUT: "AGENT_COMPACTION_TIMEOUT";
+  readonly AGENT_LEASE_HELD: "AGENT_LEASE_HELD";
+  readonly AGENT_WORK_MODE_REQUIRED: "AGENT_WORK_MODE_REQUIRED";
+  readonly AGENT_MESSAGE_NOT_FOUND: "AGENT_MESSAGE_NOT_FOUND";
+  readonly AGENT_MESSAGE_NOT_EDITABLE: "AGENT_MESSAGE_NOT_EDITABLE";
+  readonly DEVICE_NOT_FOUND: "DEVICE_NOT_FOUND";
+  readonly DEVICE_OFFLINE: "DEVICE_OFFLINE";
+  readonly AI_UNKNOWN: "AI_UNKNOWN";
+  readonly AI_USAGE_LIMIT_EXCEEDED: "AI_USAGE_LIMIT_EXCEEDED";
+  readonly AI_INVALID_USAGE: "AI_INVALID_USAGE";
+  readonly AI_INVALID_MODEL: "AI_INVALID_MODEL";
+  readonly AI_INVALID_MODEL_INPUT: "AI_INVALID_MODEL_INPUT";
+  readonly AI_REPOSITORY_ERROR: "AI_REPOSITORY_ERROR";
+  readonly AI_GENERATION_FAILED: "AI_GENERATION_FAILED";
+  readonly AI_IMAGE_USAGE_PENDING: "AI_IMAGE_USAGE_PENDING";
+  readonly AI_IMAGE_GENERATION_INDETERMINATE: "AI_IMAGE_GENERATION_INDETERMINATE";
+  readonly AI_IMAGE_PUBLICATION_FAILED: "AI_IMAGE_PUBLICATION_FAILED";
+  readonly DOCUMENT_MIME_NOT_ACCEPTED: "DOCUMENT_MIME_NOT_ACCEPTED";
+  readonly DOCUMENT_MULTIPLE_NOT_ALLOWED: "DOCUMENT_MULTIPLE_NOT_ALLOWED";
+  readonly DOCUMENT_NOT_FOUND_FOR_OPERATION: "DOCUMENT_NOT_FOUND_FOR_OPERATION";
+  readonly DOCUMENT_STORAGE_FAILED: "DOCUMENT_STORAGE_FAILED";
+  readonly DOCUMENT_SIZE_EXCEEDED: "DOCUMENT_SIZE_EXCEEDED";
+  readonly DOCUMENT_OCR_FAILED: "DOCUMENT_OCR_FAILED";
+  readonly DOCUMENT_BLOB_EMPTY: "DOCUMENT_BLOB_EMPTY";
+  readonly DOCUMENT_FILE_TOO_LARGE: "DOCUMENT_FILE_TOO_LARGE";
+  readonly DOCUMENT_FILE_NOT_FOUND: "DOCUMENT_FILE_NOT_FOUND";
+  readonly DOCUMENT_FILE_ALREADY_PACKED: "DOCUMENT_FILE_ALREADY_PACKED";
+  readonly DOCUMENT_RECORD_NOT_FOUND: "DOCUMENT_RECORD_NOT_FOUND";
+  readonly DOCUMENT_RECORD_OBJECT_MISMATCH: "DOCUMENT_RECORD_OBJECT_MISMATCH";
+  readonly DOCUMENT_FOLDER_SERVICE_UNAVAILABLE: "DOCUMENT_FOLDER_SERVICE_UNAVAILABLE";
+  readonly DOCUMENT_FOLDER_PATH_NOT_FOUND: "DOCUMENT_FOLDER_PATH_NOT_FOUND";
+  readonly EMAIL_PROVIDER_API_FAILED: "EMAIL_PROVIDER_API_FAILED";
+  readonly EMAIL_SEND_FAILED: "EMAIL_SEND_FAILED";
+  readonly EMAIL_SENT_NOT_STORED: "EMAIL_SENT_NOT_STORED";
+  readonly EMAIL_BATCH_ITEM_FAILED: "EMAIL_BATCH_ITEM_FAILED";
+  readonly CALENDAR_PROVIDER_API_FAILED: "CALENDAR_PROVIDER_API_FAILED";
+  readonly REFLEX_INVALID_TRANSITION: "REFLEX_INVALID_TRANSITION";
+  readonly REFLEX_INVALID_TOKEN: "REFLEX_INVALID_TOKEN";
+  readonly REFLEX_CAPABILITY_DENIED: "REFLEX_CAPABILITY_DENIED";
+  readonly REFLEX_GATEWAY_UNAVAILABLE: "REFLEX_GATEWAY_UNAVAILABLE";
+  readonly REFLEX_BUNDLE_FAILED: "REFLEX_BUNDLE_FAILED";
+  readonly REFLEX_EGRESS_DENIED: "REFLEX_EGRESS_DENIED";
+  readonly REFLEX_PROTOCOL_VIOLATION: "REFLEX_PROTOCOL_VIOLATION";
+  readonly REFLEX_RUN_FAILED: "REFLEX_RUN_FAILED";
+  readonly REFLEX_RUN_TIMEOUT: "REFLEX_RUN_TIMEOUT";
+  readonly REFLEX_DEPENDENCY_DRIFT: "REFLEX_DEPENDENCY_DRIFT";
+  readonly REFLEX_NOT_READY: "REFLEX_NOT_READY";
+  readonly REFLEX_INVARIANT_VIOLATION: "REFLEX_INVARIANT_VIOLATION";
+  /** The embeddings feature is enabled but no Gateway credential is configured. */
+  readonly EMBEDDING_MODEL_UNAVAILABLE: "EMBEDDING_MODEL_UNAVAILABLE";
+  /** The provider returned vectors whose length differs from the configured dimensions. */
+  readonly EMBEDDING_DIMENSION_MISMATCH: "EMBEDDING_DIMENSION_MISMATCH";
+};
+type SchemaErrorCode = (typeof SchemaErrorCode)[keyof typeof SchemaErrorCode];
+/**
+ * Base error class for all schema-related errors
+ */
+declare class SchemaError extends Error {
+  readonly code: SchemaErrorCode;
+  readonly details?: Record<string, unknown>;
+  constructor(message: string, code?: SchemaErrorCode, details?: Record<string, unknown>);
+  toJSON(): {
+    name: string;
+    code: SchemaErrorCode;
+    message: string;
+    details: Record<string, unknown> | undefined;
+  };
+}
+/**
+ * Base class for "not found" errors
+ */
+declare class NotFoundError extends SchemaError {
+  /** Literal discriminator for `Effect.catchTag`; a widened `string` breaks narrowing. */
+  readonly _tag = "NotFoundError";
+  readonly resourceType: string;
+  readonly resourceId: string;
+  constructor(resourceType: string, resourceId: string, code?: SchemaErrorCode, message?: string);
+}
+/**
+ * Object not found error
+ */
+declare class ObjectNotFoundError extends NotFoundError {
+  constructor(objectId: string);
+}
+/**
+ * Attribute not found error
+ */
+declare class AttributeNotFoundError extends NotFoundError {
+  constructor(attributeId: string);
+}
+/**
+ * Record not found error
+ */
+declare class RecordNotFoundError extends NotFoundError {
+  constructor(recordId: string);
+}
+/**
+ * Schema plan not found error — raised when a `planId` sent by an approver
+ * (who never receives the plan payload itself, only its id) does not match
+ * any stored plan.
+ */
+declare class SchemaPlanNotFoundError extends NotFoundError {
+  constructor(planId: string);
+}
+/**
+ * Validation error with field-level details
+ */
+interface ValidationErrorDetail {
+  path: string[];
+  message: string;
+  code?: string;
+}
+/**
+ * Validation error thrown when data fails schema validation
+ */
+declare class ValidationError extends SchemaError {
+  /** Literal discriminator for `Effect.catchTag`; a widened `string` breaks narrowing. */
+  readonly _tag = "ValidationError";
+  readonly errors: ValidationErrorDetail[];
+  constructor(message: string, errors: ValidationErrorDetail[]);
+  /**
+   * Create a validation error from Zod-style errors
+   */
+  static fromZodErrors(errors: Array<{
+    path: (string | number)[];
+    message: string;
+  }>): ValidationError;
+}
+/**
+ * Error thrown when attempting to modify a protected (system) resource
+ */
+declare class ProtectedResourceError extends SchemaError {
+  readonly resourceType: "object" | "attribute" | "view";
+  readonly resourceName: string;
+  readonly operation: "delete" | "modify";
+  constructor(resourceType: "object" | "attribute" | "view", resourceName: string, operation: "delete" | "modify");
+}
+/**
+ * Error thrown during native object synchronization
+ */
+declare class SyncError extends SchemaError {
+  readonly objectName: string;
+  readonly cause?: Error;
+  constructor(objectName: string, message: string, cause?: Error);
+}
+/**
+ * Thrown when code tries to mutate a system entity at runtime.
+ * System entities are declared in code and immutable at runtime.
+ * HTTP status: 403 Forbidden.
+ */
+declare class SystemEntityImmutableError extends SchemaError {
+  readonly entityType: string;
+  readonly entityName: string;
+  constructor(entityType: string, entityName: string);
+}
+interface SyncConflictParams {
+  objectName: string;
+  attributeName?: string;
+  reason: string;
+}
+/**
+ * Thrown at boot when an auto-promote cannot proceed due to incompatible types
+ * or constraints. The dev must resolve manually (relax constraints, migrate
+ * values, or rename).
+ */
+declare class SyncConflictError extends SchemaError {
+  readonly objectName: string;
+  readonly attributeName?: string;
+  readonly reason: string;
+  constructor(params: SyncConflictParams);
+}
+/**
+ * Thrown at boot when an object is being demoted but still has system attributes
+ * declared in code. The dev forgot to remove those attributes too, or kept the
+ * object inconsistently.
+ */
+declare class SyncCascadeError extends SchemaError {
+  readonly objectName: string;
+  readonly conflictingAttributes: string[];
+  constructor(objectName: string, conflictingAttributes: string[]);
+}
+/**
+ * Thrown at boot when an attribute is system:true but its object parent is
+ * system:false. This invariant should never be violated — if seen, it's a bug
+ * in the boot reconciliation logic or in a manual DB mutation.
+ */
+declare class OrphanSystemAttributeError extends SchemaError {
+  readonly objectName: string;
+  readonly attributeName: string;
+  constructor(objectName: string, attributeName: string);
+}
+/**
+ * Thrown when a destructive operation is detected without the explicit
+ * STANDARDS_ALLOW_DESTRUCTIVE_SYNC=1 opt-in.
+ * HTTP status: 500 (boot fail, should never surface to HTTP).
+ *
+ * Which operations the opt-in governs is decided in one place —
+ * `requiresDestructiveSyncOptIn` in the runtime's sync classifier. Today that
+ * is object removal only: attribute removal is unconditional at boot, because a
+ * system attribute is code-controlled and its disappearance from the builder is
+ * an unambiguous drop.
+ *
+ * NOTE — Wiring status: defined but not thrown by the current sync.ts, which
+ * demotes instead. Reserved for the `standards diff` CLI gate, which will throw
+ * it when CI detects an unauthorized destructive deployment.
+ */
+declare class DestructiveSyncNotAllowedError extends SchemaError {
+  readonly operations: SchemaOperation[];
+  constructor(operations: SchemaOperation[]);
+}
+/**
+ * Thrown at boot when applying a migration in batches exceeds the maximum
+ * allowed duration (default 5 min, configurable via STANDARDS_MIGRATION_MAX_DURATION_MS).
+ * HTTP status: 500 (boot fail).
+ */
+declare class MigrationTimeoutError extends SchemaError {
+  readonly objectName: string;
+  readonly migrated: number;
+  readonly total: number;
+  readonly maxDurationMs: number;
+  constructor(objectName: string, migrated: number, total: number, maxDurationMs: number);
+}
+/**
+ * Thrown when the runtime admin API is called to change an attribute's type.
+ * Type changes must be declared in code via `.migration(N, m => m.changeType(...))`.
+ * HTTP status: 400 Bad Request.
+ */
+declare class ChangeTypeNotSupportedError extends SchemaError {
+  readonly objectName: string;
+  readonly attributeName: string;
+  constructor(objectName: string, attributeName: string);
+}
+/**
+ * Error thrown when attempting to create a duplicate resource.
+ *
+ * `resourceType` is free-form: pass `"object"`/`"attribute"` for schema
+ * resources (a specific code is selected automatically), or any domain label
+ * (`"tool"`, `"background job handler"`, …) for runtime registries, which fall
+ * back to the generic `DUPLICATE` code. The default message is
+ * `'<ResourceType> "<name>" already exists'`; pass a custom message when the
+ * domain reads better with different wording (e.g. "already registered for
+ * type X").
+ */
+declare class DuplicateError extends SchemaError {
+  readonly resourceType: string;
+  readonly resourceName: string;
+  constructor(resourceType: string, resourceName: string, message?: string);
+}
+/**
+ * A consumer tried to build, register, bundle or source an object under a name
+ * the framework owns (`skill`, `memory`, `drives`, `artifact`, `meeting`).
+ * Raised at declaration time so the collision fails in the consumer's own
+ * tests, never at boot: the platform's `wealth-manager` bundle once shipped
+ * `meeting` and hid the native calendar object from every tenant for three
+ * days (#3450).
+ */
+declare const RESERVED_NAME_CONTEXTS: {
+  readonly builder: "cannot be built by a consumer";
+  readonly registry: "cannot be registered by a consumer";
+  readonly bundle: "cannot be claimed by a bundle";
+  readonly source: "cannot be declared by a schema source";
+};
+declare class ReservedObjectNameError extends SchemaError {
+  readonly objectName: string;
+  constructor(objectName: string, context: keyof typeof RESERVED_NAME_CONTEXTS);
+}
+/**
+ * Check if an error is a SchemaError
+ */
+declare function isSchemaError(error: unknown): error is SchemaError;
+/**
+ * Check if an error is a NotFoundError
+ */
+declare function isNotFoundError(error: unknown): error is NotFoundError;
+/**
+ * Check if an error is a ValidationError
+ */
+declare function isValidationError(error: unknown): error is ValidationError;
+/**
+ * Check if an error is a ProtectedResourceError
+ */
+declare function isProtectedResourceError(error: unknown): error is ProtectedResourceError;
+/**
+ * Error thrown when a user lacks permission to perform an action.
+ *
+ * That, and nothing else (#2681) — its message is redacted, so it must not
+ * carry a refusal a permission grant would not lift: use `WORKSPACE_INVARIANT`,
+ * `STATE_GATE`, `ACTOR_CONTEXT_REQUIRED` or `SYSTEM_ENTITY_IMMUTABLE` instead.
+ */
+declare class ForbiddenError extends SchemaError {
+  /** Literal discriminator for `Effect.catchTag`; a widened `string` breaks narrowing. */
+  readonly _tag = "ForbiddenError";
+  readonly objectName: string;
+  readonly action: string;
+  readonly userId?: string;
+  constructor(objectName: string, action: string, userId?: string);
+}
+/**
+ * Error thrown when trying to modify a protected role
+ */
+declare class ProtectedRoleError extends SchemaError {
+  readonly roleName: string;
+  readonly operation: "delete" | "modify";
+  constructor(roleName: string, operation: "delete" | "modify");
+}
+/**
+ * Role not found error
+ */
+declare class RoleNotFoundError extends NotFoundError {
+  constructor(roleId: string);
+}
+/**
+ * Thrown when a record has been modified by another request between read and write.
+ * Clients should retry the operation with fresh data.
+ * Maps to HTTP 409 Conflict.
+ */
+declare class ConcurrentModificationError extends SchemaError {
+  constructor(recordId: string);
+}
+/**
+ * Storage operation type for error context
+ */
+type StorageOperation = "upload" | "download" | "delete" | "signedUrl";
+/**
+ * Error thrown when a storage operation fails
+ */
+declare class StorageError extends SchemaError {
+  readonly operation: StorageOperation;
+  readonly path?: string;
+  readonly cause?: string;
+  constructor(operation: StorageOperation, message: string, path?: string, cause?: string);
+}
+/**
+ * Error thrown when access to a resource is denied (e.g., tenant path mismatch)
+ */
+declare class AccessDeniedError extends SchemaError {
+  readonly resource: string;
+  readonly reason?: string;
+  constructor(resource: string, reason?: string);
+}
+/**
+ * Repository operation type for error context
+ */
+type RepositoryOperation = "create" | "update" | "delete" | "query";
+/**
+ * Error thrown when a repository operation fails
+ */
+declare class RepositoryError extends SchemaError {
+  readonly operation: RepositoryOperation;
+  readonly entity: string;
+  readonly cause?: string;
+  constructor(operation: RepositoryOperation, entity: string, message: string, cause?: string);
+}
+/**
+ * Error thrown when a search read call fails at the transport level — e.g. the
+ * Meili client received a non-JSON body (`JSON.parse` SyntaxError) or a network
+ * failure. Translates an otherwise un-fingerprintable bare exception into a
+ * typed error with a stable `code` and a user-safe message. The original
+ * failure text is preserved in `cause`/`details`, never in the message.
+ */
+declare class SearchBackendError extends SchemaError {
+  readonly scope: string;
+  readonly cause?: string;
+  constructor(scope: string, cause?: string);
+}
+/**
+ * Error thrown when a feature or method is not yet implemented
+ */
+declare class NotImplementedError extends SchemaError {
+  readonly feature: string;
+  readonly milestone?: string;
+  constructor(feature: string, milestone?: string);
+}
+/**
+ * Memory entry not found error
+ */
+declare class MemoryNotFoundError extends NotFoundError {
+  constructor(memoryId: string);
+}
+/**
+ * Reference information for a record that is blocking deletion.
+ */
+interface RecordReference {
+  /** Technical name of the object (e.g., "contacts") */
+  objectName: string;
+  /** Display label of the object (e.g., "Contacts") */
+  objectLabel: string;
+  /** Number of records referencing the target */
+  count: number;
+}
+/**
+ * Thrown when attempting to delete a record that is referenced by other records.
+ *
+ * This implements the "Restrict" behavior: deletion is blocked and the user
+ * must first remove or update the referencing records.
+ */
+declare class RecordReferencedError extends SchemaError {
+  readonly recordId: string;
+  readonly references: RecordReference[];
+  constructor(recordId: string, references: RecordReference[]);
+}
+/**
+ * Usage context where an attribute is being used.
+ */
+type AttributeUsage = "labelExpression" | "embeddingExpression" | "view" | "filter";
+/**
+ * Thrown when attempting to delete an attribute that is in use.
+ *
+ * Attributes cannot be deleted if they are referenced in:
+ * - The object's labelExpression template
+ * - A saved view's column configuration
+ * - A saved filter condition
+ */
+declare class AttributeInUseError extends SchemaError {
+  readonly attributeName: string;
+  readonly usage: AttributeUsage;
+  constructor(attributeName: string, usage: AttributeUsage);
+}
+/**
+ * Thrown when attempting to delete an object that is a relation target.
+ *
+ * Objects cannot be deleted if other objects have relation attributes
+ * pointing to them as a target.
+ */
+declare class ObjectReferencedError extends SchemaError {
+  readonly objectName: string;
+  readonly referencingObjects: string[];
+  constructor(objectName: string, referencingObjects: string[]);
+}
+/**
+ * Check if an error is a RecordReferencedError
+ */
+declare function isRecordReferencedError(error: unknown): error is RecordReferencedError;
+/**
+ * Check if an error is an AttributeInUseError
+ */
+declare function isAttributeInUseError(error: unknown): error is AttributeInUseError;
+/**
+ * Check if an error is an ObjectReferencedError
+ */
+declare function isObjectReferencedError(error: unknown): error is ObjectReferencedError;
+//#endregion
+export { BilateralConfig as $, indexBy as $t, StorageError as A, ComputedDependency as An, StatusGroup as At, isObjectReferencedError as B, ComputedFormulaLiteralNode as Bn, OptionPropertyAttribute as Bt, RepositoryOperation as C, assertAcyclicComputedDependencies as Cn, RichTextAttribute as Ct, SchemaErrorCode as D, ComputedFunctionName as Dn, SelectAttribute as Dt, SchemaError as E, COMPUTED_FUNCTION_NAMES as En, RollupFunction as Et, SystemEntityImmutableError as F, ComputedValueType as Fn, inferInverseCardinality as Ft, BuiltInTransform as G, resolvePropertyDefinitions as Gt, isRecordReferencedError as H, ComputedFormulaPathNode as Hn, PropertySchema as Ht, ValidationError as I, ComputedFormulaAstNode as In, isAttributeSortable as It, ATTRIBUTE_TYPES as J, Uuid as Jt, MigrationDefinition as K, TenantId as Kt, ValidationErrorDetail as L, ComputedFormulaBinaryNode as Ln, isBilateralRelation as Lt, SyncCascadeError as M, ComputedOptionsSource as Mn, TimeFormat as Mt, SyncConflictError as N, ComputedPlan as Nn, UserAttribute as Nt, SchemaPlanNotFoundError as O, ComputedFunctionSignature as On, SingleRelationAttribute as Ot, SyncError as P, ComputedReturnType as Pn, UserReferenceType as Pt, BaseAttribute as Q, generateId as Qt, isAttributeInUseError as R, ComputedFormulaBinaryOperator as Rn, isUniversalRelation as Rt, RepositoryError as S, ComputedFormulaCompileError as Sn, RelationTarget as St, RoleNotFoundError as T, COMPUTED_FUNCTIONS as Tn, RollupAttribute as Tt, isSchemaError as U, parseComputedFormula as Un, PropertyType as Ut, isProtectedResourceError as V, ComputedFormulaParseError as Vn, PropertyAttribute as Vt, isValidationError as W, hasOptions as Wt, AttributeGroup as X, asUserId as Xt, Attribute as Y, asTenantId as Yt, AttributeType as Z, deepEqual as Zt, ProtectedResourceError as _, CompileComputedFormulaInput as _n, Option as _t, ChangeTypeNotSupportedError as a, COMPUTED_FUNCTION_METADATA as an, DateRangeValue as at, RecordReference as b, ComputedCompileSchema as bn, RELATION_TARGET_ANY as bt, DuplicateError as c, ComputedFormulaResult as cn, FormulaAttribute as ct, MigrationTimeoutError as d, evaluateComputedFormulaWithResult as dn, LocationAttribute as dt, NonJsonValueError as en, CheckboxAttribute as et, NotFoundError as f, formatComputedResult as fn, LocationGranularity as ft, OrphanSystemAttributeError as g, rollupToFormulaExpression as gn, NumberUnit as gt, ObjectReferencedError as h, inferRollupReturnType as hn, NumberAttribute as ht, AttributeUsage as i, serializeStableJson as in, DateFormat as it, StorageOperation as j, ComputedFieldKind as jn, TextAttribute as jt, SearchBackendError as k, isComputedFunctionName as kn, StatusAttribute as kt, ForbiddenError as l, evaluateComputedAst as ln, FormulaReturnType as lt, ObjectNotFoundError as m, compileRollupAttribute as mn, MultiselectAttribute as mt, AttributeInUseError as n, sameStableValue as nn, CurrencyAttribute as nt, ConcurrentModificationError as o, ComputedFunctionCategory as on, DateValue as ot, NotImplementedError as p, isPlainRecord as pn, MultiRelationAttribute as pt, SchemaOperation as q, UserId as qt, AttributeNotFoundError as r, serializeCanonicalJson as rn, DateAttribute as rt, DestructiveSyncNotAllowedError as s, ComputedFunctionMetadata as sn, DocumentAttribute as st, AccessDeniedError as t, canonicalStringify as tn, Currency as tt, MemoryNotFoundError as u, evaluateComputedFormula as un, Location as ut, ProtectedRoleError as v, ComputedCompileAttribute as vn, Phone as vt, ReservedObjectNameError as w, compileComputedFormula as wn, RichtextAttribute as wt, RecordReferencedError as x, ComputedDependencyGraphNode as xn, RelationAttribute as xt, RecordNotFoundError as y, ComputedCompileObject as yn, PhoneAttribute as yt, isNotFoundError as z, ComputedFormulaCallNode as zn, relationTargetsOf as zt };