@stndrds/schema 1.0.0-alpha.302 → 1.0.0-alpha.303

package/dist/attributes-CJNqalP0.d.mts

@@ -0,0 +1,1350 @@
+import { IconName, CountryIso3, CurrencyCode, ColorId } from '@stndrds/constants';
+
+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;
+
+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;
+}
+
+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[];
+}
+
+/**
+ * Error codes for schema exceptions
+ */
+declare const SchemaErrorCode: {
+    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_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 {
+    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;
+
+/**
+ * The one stable JSON traversal: object keys sorted, array order preserved,
+ * `undefined` object entries omitted, no whitespace.
+ *
+ * There used to be two. The runtime's copy was written because `sameValue()`
+ * used `JSON.stringify`, which is key-order sensitive: Postgres jsonb
+ * round-trips a config with a different key order than the blueprint that
+ * produced it, so system-agent sync saw perpetual false drift and
+ * unregistered/re-registered every cron on each boot. Merging the two back was
+ * blocked for a year on one question — does a canonical hash omit an
+ * `undefined` object entry, or refuse it? — answered in #2750: it omits it,
+ * exactly as `JSON.stringify` and jsonb storage both do.
+ *
+ * What remains is not one strictness but three, because three callers ask three
+ * different questions of the same walk:
+ *
+ * | | `canonicalStringify` | `serializeCanonicalJson` | `serializeStableJson` |
+ * |---|---|---|---|
+ * | asks | "what is this value, publicly?" | "what is this value's identity?" | "are these two the same?" |
+ * | `undefined` entry | omit | omit | omit |
+ * | top-level / array `undefined`, `NaN` | `null` | refuse | `null` |
+ * | `function` / `symbol` / `bigint` | refuse | refuse | coerce to its string |
+ * | `Date`, `Map`, class instance | own entries (see #3406) | refuse | own entries |
+ * | enumerable accessor | read it | refuse | skip it |
+ * | error raised | `ValidationError` | `NonJsonValueError` | `NonJsonValueError` |
+ *
+ * A content hash must refuse what it cannot represent, or two different values
+ * hash alike. A drift comparison must tolerate: it runs at boot against data
+ * that already exists, and refusing there turns a cosmetic false-drift into a
+ * server that will not start. The public traversal is the older contract, kept
+ * byte-for-byte because `@stndrds/client` and `@stndrds/reflex` hash with it.
+ *
+ * On genuinely JSON-compatible input all three emit the same bytes, so every
+ * stored hash still matches — with one measured exception against
+ * `JSON.stringify`-based predecessors: an object with integer-like keys.
+ * Rebuilding it to sort assigns those keys in ascending numeric order, where
+ * this traversal orders them lexicographically (`{"2":…,"10":…}` vs
+ * `{"10":…,"2":…}`). No caller passes such a key.
+ */
+
+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 or unsupported value types
+ * (functions, symbols, bigint).
+ */
+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;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+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";
+    /** 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;
+
+export { type ComputedFieldKind as $, type Attribute as A, type BilateralConfig as B, type CheckboxAttribute as C, type DateAttribute as D, type RelationTarget as E, type FormulaAttribute as F, type RollupFunction as G, type UserReferenceType as H, ATTRIBUTE_TYPES as I, AccessDeniedError as J, type AttributeGroup as K, type LocationAttribute as L, type MultiselectAttribute as M, type NumberAttribute as N, type Option as O, type PhoneAttribute as P, AttributeInUseError as Q, type RichtextAttribute as R, type SelectAttribute as S, type TextAttribute as T, type UserAttribute as U, ValidationError as V, AttributeNotFoundError as W, type AttributeUsage as X, type BaseAttribute as Y, type BuiltInTransform as Z, ChangeTypeNotSupportedError as _, type CurrencyAttribute as a, isSchemaError as a$, type ComputedFormulaBinaryNode as a0, type ComputedFormulaBinaryOperator as a1, type ComputedFormulaCallNode as a2, type ComputedFormulaLiteralNode as a3, ComputedFormulaParseError as a4, type ComputedFormulaPathNode as a5, ConcurrentModificationError as a6, type DateFormat as a7, type DateValue as a8, DestructiveSyncNotAllowedError as a9, type SchemaOperation as aA, SchemaPlanNotFoundError as aB, SearchBackendError as aC, type StatusGroup as aD, StorageError as aE, type StorageOperation as aF, SyncCascadeError as aG, SyncConflictError as aH, SyncError as aI, SystemEntityImmutableError as aJ, type UserId as aK, type ValidationErrorDetail as aL, asTenantId as aM, asUserId as aN, canonicalStringify as aO, deepEqual as aP, generateId as aQ, hasOptions as aR, indexBy as aS, inferInverseCardinality as aT, isAttributeInUseError as aU, isAttributeSortable as aV, isBilateralRelation as aW, isNotFoundError as aX, isObjectReferencedError as aY, isProtectedResourceError as aZ, isRecordReferencedError as a_, DuplicateError as aa, ForbiddenError as ab, MemoryNotFoundError as ac, MigrationTimeoutError as ad, NonJsonValueError as ae, NotFoundError as af, NotImplementedError as ag, type NumberUnit as ah, ObjectNotFoundError as ai, ObjectReferencedError as aj, type OptionPropertyAttribute as ak, OrphanSystemAttributeError as al, type PropertyType as am, ProtectedResourceError as an, ProtectedRoleError as ao, RELATION_TARGET_ANY as ap, RecordNotFoundError as aq, type RecordReference as ar, RecordReferencedError as as, RepositoryError as at, type RepositoryOperation as au, ReservedObjectNameError as av, type RichTextAttribute as aw, RoleNotFoundError as ax, SchemaError as ay, SchemaErrorCode as az, type StatusAttribute as b, isUniversalRelation as b0, isValidationError as b1, parseComputedFormula as b2, relationTargetsOf as b3, resolvePropertyDefinitions as b4, sameStableValue as b5, serializeCanonicalJson as b6, serializeStableJson as b7, type MultiRelationAttribute as c, type RelationAttribute as d, type SingleRelationAttribute as e, type RollupAttribute as f, type Uuid as g, type MigrationDefinition as h, type ComputedValueType as i, type ComputedReturnType as j, type AttributeType as k, type ComputedOptionsSource as l, type ComputedDependency as m, type ComputedPlan as n, type ComputedFormulaAstNode as o, type TenantId as p, type LocationGranularity as q, type Location as r, type DateRangeValue as s, type DocumentAttribute as t, type Phone as u, type Currency as v, type PropertySchema as w, type TimeFormat as x, type PropertyAttribute as y, type FormulaReturnType as z };