@stndrds/schema 0.1.0-alpha.14

package/dist/runtime-Djz3fOBE.d.mts

@@ -0,0 +1,2078 @@
+import { ColorId, IconName, CountryIso3, CurrencyCode, MimeType } from '@andyoucreate/constants';
+import { z } from 'zod';
+
+/**
+ * UUID string type for all identifiers
+ */
+type Uuid = string;
+/**
+ * Tenant identifier for multi-tenant isolation
+ * Phase 1: Type defined but not yet used in interfaces
+ * Phase 2+: Will be added to ObjectRecord and services for SaaS mode
+ */
+type TenantId = string;
+/**
+ * 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;
+/**
+ * Generate a prefixed ID for better debugging and readability
+ *
+ * @param prefix - Prefix for the ID (e.g., "obj", "attr", "rec")
+ * @returns A prefixed UUID string
+ *
+ * @example
+ * ```typescript
+ * const objectId = generatePrefixedId("obj");
+ * // "obj_a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"
+ *
+ * const attrId = generatePrefixedId("attr");
+ * // "attr_a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"
+ * ```
+ */
+declare function generatePrefixedId(prefix: string): Uuid;
+
+type AttributeType = "text" | "textarea" | "number" | "checkbox" | "date" | "phone" | "currency" | "status" | "location" | "timestamp" | "select" | "multiselect" | "file" | "user" | "relation" | "rating";
+/**
+ * Status group categorization
+ */
+type StatusGroup = "idle" | "in_progress" | "finished";
+/**
+ * Unified option type for select-like fields
+ */
+interface Option {
+    id: string;
+    label: string;
+    value: string;
+    color?: ColorId;
+    icon?: IconName;
+    description?: string;
+    group?: StatusGroup;
+}
+/**
+ * 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;
+    name: string;
+    label: string;
+    type: AttributeType;
+    required: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    description?: string;
+    defaultValue?: DefaultValueType;
+    icon?: IconName;
+    order?: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface TextAttribute extends BaseAttribute<string> {
+    type: "text";
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+}
+type NumberUnit = "integer" | "decimal" | "percentage";
+interface NumberAttribute extends BaseAttribute<number> {
+    type: "number";
+    min?: number;
+    max?: number;
+    unit?: NumberUnit;
+    decimals?: number;
+}
+interface CheckboxAttribute extends BaseAttribute<boolean> {
+    type: "checkbox";
+}
+type DateFormat = "short" | "long" | "full" | "relative";
+type DateValue = string | "today";
+interface DateAttribute extends BaseAttribute<string> {
+    type: "date";
+    dateFormat?: DateFormat;
+    minDate?: DateValue;
+    maxDate?: DateValue;
+}
+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[];
+}
+/**
+ * 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;
+    enableAutocomplete?: boolean;
+    enableMap?: boolean;
+    defaultCountry?: CountryIso3;
+    allowedCountries?: CountryIso3[];
+    displayFormat?: "single_line" | "multi_line" | "compact";
+}
+interface TimestampAttribute extends BaseAttribute<number> {
+    type: "timestamp";
+    autoUpdate?: boolean;
+}
+/**
+ * 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[];
+}
+interface MultiselectAttribute extends BaseAttribute<string[]> {
+    type: "multiselect";
+    options: Option[];
+}
+type DocumentType = "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+type DocumentFace = "front" | "back" | "single";
+interface DocumentTypeConfig {
+    type: DocumentType;
+    label: string;
+    faces: DocumentFace[];
+    attributeMapping?: {
+        attributeId: string;
+        extractedKey: string;
+        face?: DocumentFace;
+        required?: boolean;
+    }[];
+}
+interface FileVerificationConfig {
+    enabled: boolean;
+    documentTypes: DocumentTypeConfig[];
+    autoExtract?: boolean;
+    autoValidate?: boolean;
+}
+interface FileAttribute extends BaseAttribute<string> {
+    type: "file";
+    maxFiles?: number;
+    maxSize?: number;
+    allowedTypes?: MimeType[] | readonly MimeType[];
+    verification?: FileVerificationConfig;
+}
+interface UserAttribute extends BaseAttribute<string> {
+    type: "user";
+    allowedRoles?: string[];
+}
+/**
+ * Target object for a relation - defines which objects can be linked
+ */
+interface RelationTarget {
+    /** Object name (e.g., "companies", "contacts") */
+    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>;
+}
+/**
+ * Strategy when a target record is deleted
+ * - "restrict": Prevent deletion if relations exist (default)
+ * - "cascade": Delete this record too
+ * - "set_null": Set the relation value to null
+ */
+type RelationOnDelete = "restrict" | "cascade" | "set_null";
+/**
+ * Base properties shared by both single and multi relation attributes
+ */
+interface RelationAttributeBase extends Omit<BaseAttribute<unknown>, "defaultValue"> {
+    type: "relation";
+    /** Target objects that can be linked */
+    targets: RelationTarget[];
+    /** Deletion strategy when target record is deleted */
+    onDelete?: RelationOnDelete;
+}
+/**
+ * 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[];
+    /** Minimum number of relations required */
+    minItems?: number;
+    /** 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;
+interface TextAreaAttribute extends BaseAttribute<string> {
+    type: "textarea";
+}
+interface RatingAttribute extends BaseAttribute<number> {
+    type: "rating";
+    max?: number;
+    iconType?: "star" | "heart" | "thumbs" | "number";
+}
+type Attribute = TextAttribute | TextAreaAttribute | NumberAttribute | CheckboxAttribute | DateAttribute | PhoneAttribute | CurrencyAttribute | StatusAttribute | LocationAttribute | TimestampAttribute | SelectAttribute | MultiselectAttribute | FileAttribute | UserAttribute | RelationAttribute | RatingAttribute;
+
+/**
+ * Timestamps for tracking creation and updates
+ */
+interface Timestamps {
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Object definition - Represents a database table/entity
+ */
+interface ObjectDefinition {
+    id?: Uuid;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    /**
+     * Name of the text attribute used as the object's title/display name.
+     * This attribute is used to represent the record in lists, relations, etc.
+     * Must reference an existing text attribute.
+     */
+    titleAttribute: string;
+    attributes: Attribute[];
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Links an attribute to an object
+ */
+interface ObjectAttribute {
+    objectId: Uuid;
+    attributeId: Uuid;
+    order?: number;
+    required?: boolean;
+}
+/**
+ * Completion status of a record based on data completeness.
+ *
+ * - `draft`: Record is missing one or more required attribute values.
+ *   Can be saved but is considered incomplete.
+ * - `complete`: All required attribute values are present and valid.
+ *   Record is ready for use.
+ *
+ * This is different from workflow status (e.g., "pending", "approved").
+ * Completion status is computed dynamically based on the object schema.
+ */
+type CompletionStatus = "draft" | "complete";
+/**
+ * Record - Instance of an Object (a row in the database)
+ */
+interface ObjectRecord extends Timestamps {
+    id: Uuid;
+    objectId: Uuid;
+    /**
+     * Completion status of the record.
+     * - `draft`: Missing required values, record is incomplete
+     * - `complete`: All required values present and valid
+     *
+     * Computed dynamically based on the object's schema.
+     */
+    completionStatus: CompletionStatus;
+    values: Record<string, unknown>;
+}
+
+/**
+ * Storage provider type
+ */
+type StorageProvider = "s3" | "gcs" | "azure" | "local" | "cloudflare-r2" | string;
+/**
+ * File visibility level
+ */
+type FileVisibility = "public" | "private" | "restricted";
+/**
+ * File - Represents uploaded file metadata and storage info
+ *
+ * ARCHITECTURE:
+ * - Fixed table (no custom attributes)
+ * - Manages file storage, permissions, and metadata
+ * - uploadedBy links to user_profiles table
+ * - Supports soft delete via deletedAt
+ *
+ * @example
+ * ```typescript
+ * const file: File = {
+ *   id: "file-123",
+ *   tenantId: "tenant-456",
+ *   name: "contract-2025.pdf",
+ *   originalName: "Contract Acme Corp 2025.pdf",
+ *   mimeType: "application/pdf",
+ *   size: 2458624,
+ *   storageProvider: "s3",
+ *   storagePath: "tenants/456/files/2025/11/contract-2025.pdf",
+ *   storageBucket: "my-app-files",
+ *   url: "https://cdn.example.com/files/file-123",
+ *   uploadedBy: "profile-789",
+ *   folderPath: "/contracts/2025",
+ *   tags: ["contract", "legal"],
+ *   visibility: "restricted",
+ *   allowedUsers: ["profile-789", "profile-456"],
+ *   createdAt: new Date(),
+ *   updatedAt: new Date(),
+ * };
+ * ```
+ */
+interface File extends Timestamps {
+    id: Uuid;
+    tenantId: Uuid;
+    /**
+     * File name (sanitized for storage)
+     */
+    name: string;
+    /**
+     * Original file name (as uploaded by user)
+     */
+    originalName: string;
+    /**
+     * MIME type (e.g., "application/pdf", "image/jpeg")
+     */
+    mimeType: MimeType | string;
+    /**
+     * File size in bytes
+     */
+    size: number;
+    /**
+     * Storage provider (s3, gcs, azure, local, etc.)
+     */
+    storageProvider: StorageProvider;
+    /**
+     * Path in the storage bucket
+     */
+    storagePath: string;
+    /**
+     * Storage bucket name (if applicable)
+     */
+    storageBucket?: string;
+    /**
+     * Public or signed URL to access the file
+     */
+    url: string;
+    /**
+     * User who uploaded the file (FK to user_profiles)
+     */
+    uploadedBy: Uuid;
+    /**
+     * Folder path for organization (e.g., "/contracts/2025")
+     */
+    folderPath?: string;
+    /**
+     * Tags for search and categorization
+     */
+    tags?: string[];
+    /**
+     * File visibility level
+     * - public: Anyone with the URL can access
+     * - private: Only uploadedBy can access
+     * - restricted: Only specific users (allowedUsers) can access
+     */
+    visibility: FileVisibility;
+    /**
+     * List of user IDs authorized to access this file (if visibility = "restricted")
+     */
+    allowedUsers?: Uuid[];
+    /**
+     * Soft delete timestamp (null = not deleted)
+     */
+    deletedAt?: Date;
+}
+/**
+ * Data required to create a new file record
+ */
+interface CreateFile {
+    tenantId: Uuid;
+    name: string;
+    originalName: string;
+    mimeType: MimeType | string;
+    size: number;
+    storageProvider: StorageProvider;
+    storagePath: string;
+    storageBucket?: string;
+    url: string;
+    uploadedBy: Uuid;
+    folderPath?: string;
+    tags?: string[];
+    visibility?: FileVisibility;
+    allowedUsers?: Uuid[];
+}
+/**
+ * Data for updating an existing file record
+ */
+interface UpdateFile {
+    name?: string;
+    folderPath?: string;
+    tags?: string[];
+    visibility?: FileVisibility;
+    allowedUsers?: Uuid[];
+}
+
+/**
+ * User role in the application
+ * Can be extended with custom roles as needed
+ */
+type UserRole = "admin" | "member" | "guest" | string;
+/**
+ * User status for account management
+ */
+type UserStatus = "active" | "pending" | "inactive" | "suspended";
+/**
+ * User Profile - Represents application user data (authorization)
+ *
+ * ARCHITECTURE:
+ * - authId links to external auth provider (Supabase, Clerk, Auth0, etc.)
+ * - email is denormalized from auth provider for performance
+ * - Auth provider handles authentication (passwords, sessions, OAuth)
+ * - This type handles authorization (roles, permissions, tenant membership)
+ *
+ * @example
+ * ```typescript
+ * const profile: UserProfile = {
+ *   id: "profile-123",
+ *   tenantId: "tenant-456",
+ *   authId: "supabase-auth-uuid-789",
+ *   email: "john@example.com",
+ *   firstName: "John",
+ *   lastName: "Doe",
+ *   role: "admin",
+ *   status: "active",
+ *   createdAt: new Date(),
+ *   updatedAt: new Date(),
+ * };
+ * ```
+ */
+interface UserProfile extends Timestamps {
+    id: Uuid;
+    tenantId: Uuid;
+    /**
+     * Link to external auth provider (Supabase auth.users.id, Clerk user ID, etc.)
+     * This is the bridge between authentication (provider) and authorization (your app)
+     */
+    authId: string;
+    /**
+     * Email address (denormalized from auth provider)
+     * Allows efficient querying and filtering without hitting auth provider API
+     */
+    email: string;
+    /**
+     * User's first name
+     */
+    firstName?: string;
+    /**
+     * User's last name
+     */
+    lastName?: string;
+    /**
+     * Avatar/profile picture URL
+     */
+    avatarUrl?: string;
+    /**
+     * User role for authorization
+     * Common values: "admin", "member", "guest"
+     * Can be extended with custom roles
+     */
+    role: UserRole;
+    /**
+     * Account status
+     * - active: Normal user, full access
+     * - pending: Awaiting activation/approval
+     * - inactive: Deactivated account
+     * - suspended: Temporarily blocked
+     */
+    status: UserStatus;
+    /**
+     * Last login timestamp (updated on each successful auth)
+     */
+    lastLoginAt?: Date;
+}
+/**
+ * Data required to create a new user profile
+ */
+interface CreateUserProfile {
+    tenantId: Uuid;
+    authId: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    avatarUrl?: string;
+    role?: UserRole;
+    status?: UserStatus;
+}
+/**
+ * Data for updating an existing user profile
+ */
+interface UpdateUserProfile {
+    firstName?: string;
+    lastName?: string;
+    avatarUrl?: string;
+    role?: UserRole;
+    status?: UserStatus;
+    lastLoginAt?: Date;
+}
+
+/**
+ * Registry for native objects defined in code
+ * Native objects are system objects that cannot be deleted/modified by clients
+ * They are defined by developers and synced to the database at startup
+ */
+declare class NativeObjectRegistryClass {
+    private objects;
+    /**
+     * Register one or more native objects
+     * Auto-builds if ObjectBuilder is passed instead of ObjectDefinition
+     * @param objects - Single object/builder or array of objects/builders to register
+     * @returns this (for chaining)
+     * @throws Error if object is invalid or already registered
+     *
+     * @example
+     * ```typescript
+     * // No .build() needed - registry auto-builds!
+     * const PRODUCT = object({ id: "obj-product", name: "products", label: "Product" })
+     *   .system()
+     *   .attribute(text({ id: "attr-name", name: "name", label: "Name" }));
+     *
+     * registry.register(PRODUCT);  // ← Auto-builds here
+     *
+     * // Can still explicitly .build() if you want
+     * registry.register(PRODUCT.build());
+     *
+     * // Register multiple
+     * registry.register([PRODUCT, ORDER, CUSTOMER]);
+     * ```
+     */
+    register(objects: ObjectDefinition | ObjectDefinition[] | {
+        build: () => ObjectDefinition;
+    } | Array<{
+        build: () => ObjectDefinition;
+    }>): this;
+    /**
+     * Validate and register a single object
+     * @internal
+     */
+    private validateAndRegister;
+    /**
+     * Get a native object by its name
+     * @param name - The object name
+     * @returns The object definition or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const product = registry.getByName("products");
+     * if (product) {
+     *   console.log(product.label); // "Product"
+     * }
+     * ```
+     */
+    getByName(name: string): ObjectDefinition | undefined;
+    /**
+     * Get a native object or throw if not found
+     * @param name - The object name
+     * @returns The object definition
+     * @throws Error if not found
+     */
+    getByNameOrThrow(name: string): ObjectDefinition;
+    /**
+     * Get all registered native objects
+     * @returns Array of all registered object definitions
+     */
+    getAll(): ObjectDefinition[];
+    /**
+     * Get all registered native object names
+     * @returns Array of object names
+     */
+    listNames(): string[];
+    /**
+     * Check if a native object is registered
+     * @param name - The object name
+     * @returns true if registered, false otherwise
+     */
+    has(name: string): boolean;
+    /**
+     * Get the number of registered objects
+     */
+    get size(): number;
+    /**
+     * Clear all registered objects (useful for testing)
+     * @internal
+     */
+    clear(): void;
+    /**
+     * Get registry summary for debugging
+     */
+    summary(): string;
+    /**
+     * Log registry summary to console
+     */
+    debug(): void;
+}
+/**
+ * Singleton instance of the registry
+ * Use this to register and retrieve native objects
+ *
+ * @example
+ * ```typescript
+ * import { registry } from "@andyoucreate/schema";
+ *
+ * // Register objects
+ * registry.register([PRODUCT, ORDER, CUSTOMER]);
+ *
+ * // Get object by name
+ * const product = registry.getByName("products");
+ *
+ * // List all
+ * console.log(registry.listNames()); // ["products", "orders", ...]
+ *
+ * // Debug
+ * registry.debug();
+ * ```
+ */
+declare const registry: NativeObjectRegistryClass;
+
+/**
+ * Create a Zod schema for a text attribute
+ */
+declare function createTextValidator(attr: TextAttribute): z.ZodString;
+/**
+ * Create a Zod schema for a number attribute
+ */
+declare function createNumberValidator(attr: NumberAttribute): z.ZodNumber;
+/**
+ * Create a Zod schema for a checkbox attribute
+ */
+declare function createCheckboxValidator(_attr: CheckboxAttribute): z.ZodBoolean;
+/**
+ * Create a Zod schema for a date attribute
+ */
+declare function createDateValidator(attr: DateAttribute): z.ZodString;
+/**
+ * Create a Zod schema for a phone attribute
+ */
+declare function createPhoneValidator(_attr: PhoneAttribute): z.ZodType<{
+    countryCode: string;
+    phoneNumber: string;
+}>;
+/**
+ * Create a Zod schema for a currency attribute
+ */
+declare function createCurrencyValidator(_attr: CurrencyAttribute): z.ZodType<{
+    code: string;
+    value: number;
+}>;
+/**
+ * Create a Zod schema for a status attribute
+ */
+declare function createStatusValidator(attr: StatusAttribute): z.ZodEnum<[string, ...string[]]>;
+/**
+ * Create a Zod schema for a select attribute
+ */
+declare function createSelectValidator(attr: SelectAttribute): z.ZodEnum<[string, ...string[]]>;
+/**
+ * Create a Zod schema for a multiselect attribute
+ */
+declare function createMultiselectValidator(attr: MultiselectAttribute): z.ZodArray<z.ZodEnum<[string, ...string[]]>>;
+/**
+ * Create a Zod schema for a location attribute
+ */
+type LocationShape = {
+    address?: string;
+    address2?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    latitude?: number;
+    longitude?: number;
+};
+declare function createLocationValidator(_attr: LocationAttribute): z.ZodType<LocationShape>;
+/**
+ * Create a Zod schema for a timestamp attribute
+ */
+declare function createTimestampValidator(_attr: TimestampAttribute): z.ZodNumber;
+/**
+ * Create a Zod schema for a file attribute
+ */
+declare function createFileValidator(_attr: FileAttribute): z.ZodString;
+/**
+ * Create a Zod schema for a user attribute
+ */
+declare function createUserValidator(_attr: UserAttribute): z.ZodString;
+/**
+ * Create a Zod schema for a single relation attribute (cardinality: "one")
+ */
+declare function createSingleRelationValidator(attr: SingleRelationAttribute): z.ZodUnion<[z.ZodString, z.ZodNull]>;
+/**
+ * Create a Zod schema for a multi relation attribute (cardinality: "many")
+ */
+declare function createMultiRelationValidator(attr: MultiRelationAttribute): z.ZodArray<z.ZodString>;
+/**
+ * Create a Zod schema for a relation attribute
+ * Dispatches to single or multi validator based on cardinality
+ */
+declare function createRelationValidator(attr: RelationAttribute): z.ZodUnion<[z.ZodString, z.ZodNull]> | z.ZodArray<z.ZodString>;
+/**
+ * Create a Zod schema for a rating attribute
+ */
+declare function createRatingValidator(attr: RatingAttribute): z.ZodNumber;
+/**
+ * Create a Zod schema for any attribute type
+ */
+declare function createAttributeValidator(attr: Attribute): z.ZodTypeAny;
+/**
+ * Create a Zod schema for an entire object
+ */
+declare function createObjectValidator(objectDef: ObjectDefinition): z.ZodType<Record<string, unknown>>;
+/**
+ * Validation result
+ */
+interface ValidationResult {
+    success: boolean;
+    data?: Record<string, unknown>;
+    errors?: Array<{
+        path: string[];
+        message: string;
+    }>;
+}
+/**
+ * Validate data against an attribute schema
+ */
+declare function validateAttribute(attr: Attribute, value: unknown): ValidationResult;
+/**
+ * Validate data against an object schema
+ */
+declare function validateObject(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
+/**
+ * Validate and throw if invalid
+ */
+declare function validateObjectOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Create a Zod schema for draft validation.
+ * All attributes become optional, but provided values are still validated.
+ */
+declare function createDraftValidator(objectDef: ObjectDefinition): z.ZodType<Record<string, unknown>>;
+/**
+ * Validate data in draft mode.
+ * - All attributes are treated as optional (no required validation)
+ * - Provided values are still validated for format/type correctness
+ *
+ * Use this when creating records that may be incomplete (drafts).
+ *
+ * @example
+ * ```typescript
+ * const result = validateDraft(PRODUCT, { name: "Draft" });
+ * // → success even if "price" is required but missing
+ *
+ * const result2 = validateDraft(PRODUCT, { price: -10 });
+ * // → fails because price must be >= 0 (format validation still applies)
+ * ```
+ */
+declare function validateDraft(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
+/**
+ * Validate draft data and throw if format validation fails.
+ */
+declare function validateDraftOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Get the list of required attributes that are missing values.
+ *
+ * @example
+ * ```typescript
+ * const missing = getMissingRequiredAttributes(PRODUCT, { name: "Test" });
+ * // → [priceAttribute, statusAttribute] if price and status are required but missing
+ * ```
+ */
+declare function getMissingRequiredAttributes(objectDef: ObjectDefinition, data: Record<string, unknown>): Attribute[];
+/**
+ * Check if a record is complete (all required attributes have valid values).
+ *
+ * @returns `true` if all required values are present and valid, `false` otherwise
+ */
+declare function isRecordComplete(objectDef: ObjectDefinition, data: Record<string, unknown>): boolean;
+/**
+ * Compute the completion status of a record based on its data.
+ *
+ * - `"complete"`: All required values are present and valid
+ * - `"draft"`: One or more required values are missing or invalid
+ *
+ * This function is used to dynamically determine the status when
+ * creating or updating records.
+ *
+ * @example
+ * ```typescript
+ * const status = computeRecordStatus(PRODUCT, {
+ *   name: "Nike Air Max",
+ *   price: 129.99,
+ *   status: "active"
+ * });
+ * // → "complete"
+ *
+ * const status2 = computeRecordStatus(PRODUCT, { name: "Draft Product" });
+ * // → "draft" (missing required fields)
+ * ```
+ */
+declare function computeRecordStatus(objectDef: ObjectDefinition, data: Record<string, unknown>): CompletionStatus;
+
+/**
+ * Object as stored in database (metadata)
+ */
+interface DBObject extends Timestamps {
+    id: Uuid;
+    tenantId: TenantId;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    system: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface CreateDBObject {
+    tenantId: TenantId;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateDBObject {
+    label?: string;
+    description?: string;
+    icon?: IconName;
+    metadata?: Record<string, unknown>;
+}
+interface UpsertDBObject extends CreateDBObject {
+    system: boolean;
+}
+/**
+ * Attribute as stored in database (metadata)
+ */
+interface DBAttribute extends Timestamps {
+    id: Uuid;
+    objectId: Uuid;
+    name: string;
+    label: string;
+    type: AttributeType;
+    description?: string;
+    icon?: IconName;
+    system: boolean;
+    required: boolean;
+    unique: boolean;
+    order: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    defaultValue?: unknown;
+    config: Record<string, unknown>;
+}
+interface CreateDBAttribute {
+    objectId: Uuid;
+    name: string;
+    label: string;
+    type: AttributeType;
+    description?: string;
+    icon?: IconName;
+    system?: boolean;
+    required?: boolean;
+    unique?: boolean;
+    order?: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    defaultValue?: unknown;
+    config?: Record<string, unknown>;
+}
+interface UpdateDBAttribute {
+    label?: string;
+    description?: string;
+    icon?: IconName;
+    required?: boolean;
+    order?: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    defaultValue?: unknown;
+    config?: Record<string, unknown>;
+}
+interface UpsertDBAttribute extends CreateDBAttribute {
+    objectId: Uuid;
+    name: string;
+}
+
+/**
+ * Object record creation data
+ */
+interface CreateObjectRecord {
+    tenantId: TenantId;
+    objectId: Uuid;
+    data: Record<string, unknown>;
+    /**
+     * Completion status of the record.
+     * - `draft`: Record is incomplete (missing required values)
+     * - `complete`: All required values are present and valid
+     */
+    completionStatus: "draft" | "complete";
+}
+/**
+ * Generic list options for pagination and sorting
+ */
+interface ListOptions {
+    limit?: number;
+    offset?: number;
+    orderBy?: string;
+    orderDirection?: "asc" | "desc";
+}
+/**
+ * Search options for full-text search
+ */
+interface SearchOptions extends ListOptions {
+    filters?: Record<string, unknown>;
+    highlight?: boolean;
+}
+/**
+ * File-specific list options
+ */
+interface FileListOptions extends ListOptions {
+    folderPath?: string;
+    mimeType?: string;
+    uploadedBy?: Uuid;
+    includeDeleted?: boolean;
+}
+/**
+ * Result of an operation
+ */
+interface OperationResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+
+/**
+ * Repository for objects table (metadata)
+ */
+interface ObjectsRepository {
+    /**
+     * Find object by ID
+     */
+    findById(id: Uuid): Promise<DBObject | null>;
+    /**
+     * Find object by name and tenant
+     */
+    findByName(tenantId: TenantId, name: string): Promise<DBObject | null>;
+    /**
+     * Find system/native object by name (system=true, for sync)
+     */
+    findSystemByName(name: string): Promise<DBObject | null>;
+    /**
+     * Create object
+     */
+    create(data: CreateDBObject): Promise<DBObject>;
+    /**
+     * Update object
+     */
+    update(id: Uuid, data: Partial<UpdateDBObject>): Promise<DBObject>;
+    /**
+     * Delete object
+     */
+    delete(id: Uuid): Promise<void>;
+    /**
+     * List all objects for a tenant
+     */
+    list(tenantId: TenantId): Promise<DBObject[]>;
+    /**
+     * Upsert object (create or update based on nativeObjectId)
+     */
+    upsert(data: UpsertDBObject): Promise<DBObject>;
+}
+/**
+ * Repository for attributes table (metadata)
+ */
+interface AttributesRepository {
+    /**
+     * Find attribute by ID
+     */
+    findById(id: Uuid): Promise<DBAttribute | null>;
+    /**
+     * Find attributes by object ID
+     */
+    findByObjectId(objectId: Uuid): Promise<DBAttribute[]>;
+    /**
+     * Create attribute
+     */
+    create(data: CreateDBAttribute): Promise<DBAttribute>;
+    /**
+     * Update attribute
+     */
+    update(id: Uuid, data: Partial<UpdateDBAttribute>): Promise<DBAttribute>;
+    /**
+     * Delete attribute
+     */
+    delete(id: Uuid): Promise<void>;
+    /**
+     * Delete multiple attributes by names (for sync cleanup)
+     */
+    deleteByNames(objectId: Uuid, excludeNames: string[]): Promise<number>;
+    /**
+     * Upsert attribute (create or update based on objectId + name)
+     */
+    upsert(data: UpsertDBAttribute): Promise<DBAttribute>;
+}
+/**
+ * Repository for user_profiles table
+ */
+interface UserProfilesRepository {
+    /**
+     * Find user profile by ID
+     */
+    findById(id: Uuid): Promise<UserProfile | null>;
+    /**
+     * Find user profile by auth ID (external auth provider)
+     */
+    findByAuthId(authId: string): Promise<UserProfile | null>;
+    /**
+     * Find user profile by email
+     */
+    findByEmail(tenantId: TenantId, email: string): Promise<UserProfile | null>;
+    /**
+     * Create user profile
+     */
+    create(data: CreateUserProfile): Promise<UserProfile>;
+    /**
+     * Update user profile
+     */
+    update(id: Uuid, data: UpdateUserProfile): Promise<UserProfile>;
+    /**
+     * Delete user profile
+     */
+    delete(id: Uuid): Promise<void>;
+    /**
+     * List all user profiles for a tenant
+     */
+    list(tenantId: TenantId, options?: ListOptions): Promise<UserProfile[]>;
+    /**
+     * Update last login timestamp
+     */
+    updateLastLogin(id: Uuid): Promise<void>;
+}
+/**
+ * Repository for files table
+ */
+interface FilesRepository {
+    /**
+     * Find file by ID
+     */
+    findById(id: Uuid): Promise<File | null>;
+    /**
+     * Create file
+     */
+    create(data: CreateFile): Promise<File>;
+    /**
+     * Update file
+     */
+    update(id: Uuid, data: UpdateFile): Promise<File>;
+    /**
+     * Delete file (soft delete)
+     */
+    delete(id: Uuid): Promise<void>;
+    /**
+     * Hard delete file (permanent)
+     */
+    hardDelete(id: Uuid): Promise<void>;
+    /**
+     * List files for a tenant
+     */
+    list(tenantId: TenantId, options?: FileListOptions): Promise<File[]>;
+    /**
+     * Find files by folder path
+     */
+    findByFolder(tenantId: TenantId, folderPath: string): Promise<File[]>;
+    /**
+     * Find files by uploader
+     */
+    findByUploader(uploadedBy: Uuid): Promise<File[]>;
+}
+/**
+ * Repository for object_records table (unified JSONB)
+ */
+interface ObjectRecordsRepository {
+    /**
+     * Find record by ID
+     */
+    findById(id: Uuid): Promise<ObjectRecord | null>;
+    /**
+     * Create record
+     */
+    create(data: CreateObjectRecord): Promise<ObjectRecord>;
+    /**
+     * Update record
+     */
+    update(id: Uuid, data: Partial<Record<string, unknown>>): Promise<ObjectRecord>;
+    /**
+     * Delete record
+     */
+    delete(id: Uuid): Promise<void>;
+    /**
+     * List records for an object
+     */
+    list(tenantId: TenantId, objectId: Uuid, options?: ListOptions): Promise<{
+        records: ObjectRecord[];
+        total: number;
+    }>;
+    /**
+     * Search records using PostgreSQL full-text search
+     */
+    search(tenantId: TenantId, objectId: Uuid, query: string, options?: SearchOptions): Promise<{
+        records: ObjectRecord[];
+        total: number;
+    }>;
+}
+
+/**
+ * Generic database adapter interface
+ * Any ORM (Drizzle, Prisma, Kysely, TypeORM) can implement this interface
+ * to work with @andyoucreate/schema runtime services
+ *
+ * @example
+ * ```typescript
+ * // Drizzle implementation
+ * import { createDrizzleAdapter } from "./adapters/drizzle";
+ * import { db } from "./db";
+ *
+ * const adapter = createDrizzleAdapter(db);
+ *
+ * // Prisma implementation
+ * import { createPrismaAdapter } from "./adapters/prisma";
+ * import { prisma } from "./db";
+ *
+ * const adapter = createPrismaAdapter(prisma);
+ * ```
+ */
+interface DatabaseAdapter {
+    objects: ObjectsRepository;
+    attributes: AttributesRepository;
+    userProfiles: UserProfilesRepository;
+    files: FilesRepository;
+    objectRecords: ObjectRecordsRepository;
+    transaction<T>(callback: (adapter: DatabaseAdapter) => Promise<T>): Promise<T>;
+}
+
+interface InternalObjectRecord extends ObjectRecord {
+    tenantId: TenantId;
+}
+interface MockStores {
+    objects: Map<Uuid, DBObject>;
+    attributes: Map<Uuid, DBAttribute>;
+    userProfiles: Map<Uuid, UserProfile>;
+    files: Map<Uuid, File>;
+    objectRecords: Map<Uuid, InternalObjectRecord>;
+}
+/**
+ * Create an in-memory mock adapter for testing and development
+ *
+ * This adapter stores all data in memory and is perfect for:
+ * - Unit tests
+ * - Integration tests
+ * - Local development without a database
+ * - Understanding the adapter interface
+ *
+ * @returns A DatabaseAdapter implementation using in-memory storage
+ *
+ * @example
+ * ```typescript
+ * import { createMockAdapter, RecordService } from "@andyoucreate/schema";
+ *
+ * // Create adapter
+ * const adapter = createMockAdapter();
+ *
+ * // Use with services
+ * const recordService = new RecordService(adapter, "tenant-123");
+ *
+ * // Create a record
+ * const product = await recordService.createRecord("obj-product", {
+ *   name: "Nike Air Max",
+ *   price: 129.99
+ * });
+ *
+ * // List records
+ * const { records, total } = await recordService.listRecords("obj-product");
+ * ```
+ */
+declare function createMockAdapter(): DatabaseAdapter & {
+    _stores: MockStores;
+    reset(): void;
+};
+
+/**
+ * Service for managing files
+ * Handles file metadata CRUD, permissions, and soft delete
+ */
+declare class FileService {
+    private adapter;
+    private tenantId;
+    constructor(adapter: DatabaseAdapter, tenantId: string);
+    /**
+     * Create a new file record (after upload to storage)
+     *
+     * @param data - File metadata
+     * @returns Created file record
+     *
+     * @example
+     * ```typescript
+     * const service = new FileService(adapter, "tenant-123");
+     *
+     * // After uploading to S3
+     * const file = await service.createFile({
+     *   tenantId: "tenant-123",
+     *   name: "contract-2025.pdf",
+     *   originalName: "Contract Acme Corp 2025.pdf",
+     *   mimeType: "application/pdf",
+     *   size: 2458624,
+     *   storageProvider: "s3",
+     *   storagePath: "tenants/123/files/2025/contract.pdf",
+     *   storageBucket: "my-app-files",
+     *   url: "https://cdn.example.com/files/file-123",
+     *   uploadedBy: "profile-456",
+     *   visibility: "private"
+     * });
+     * ```
+     */
+    createFile(data: CreateFile): Promise<File>;
+    /**
+     * Get file by ID
+     */
+    getFile(fileId: string): Promise<File | null>;
+    /**
+     * Get file by ID or throw
+     */
+    getFileOrThrow(fileId: string): Promise<File>;
+    /**
+     * Update file metadata
+     *
+     * @param fileId - File UUID
+     * @param data - Data to update
+     * @returns Updated file
+     */
+    updateFile(fileId: string, data: UpdateFile): Promise<File>;
+    /**
+     * Delete file (soft delete)
+     *
+     * @param fileId - File UUID
+     * @param options - Delete options
+     */
+    deleteFile(fileId: string, options?: {
+        hard?: boolean;
+        checkOwnership?: boolean;
+        userId?: string;
+    }): Promise<void>;
+    /**
+     * List files for the tenant
+     */
+    listFiles(options?: FileListOptions): Promise<File[]>;
+    /**
+     * List files by folder
+     */
+    listFilesByFolder(folderPath: string): Promise<File[]>;
+    /**
+     * List files uploaded by a specific user
+     */
+    listFilesByUploader(uploadedBy: string): Promise<File[]>;
+    /**
+     * Change file visibility
+     *
+     * @param fileId - File UUID
+     * @param visibility - New visibility level
+     * @param allowedUsers - Users allowed to access (if restricted)
+     */
+    changeVisibility(fileId: string, visibility: "public" | "private" | "restricted", allowedUsers?: string[]): Promise<File>;
+    /**
+     * Grant access to a file for specific users
+     *
+     * @param fileId - File UUID
+     * @param userIds - User IDs to grant access
+     */
+    grantAccess(fileId: string, userIds: string[]): Promise<File>;
+    /**
+     * Revoke access to a file for specific users
+     *
+     * @param fileId - File UUID
+     * @param userIds - User IDs to revoke access
+     */
+    revokeAccess(fileId: string, userIds: string[]): Promise<File>;
+    /**
+     * Check if user has access to a file
+     *
+     * @param fileId - File UUID
+     * @param userId - User ID to check
+     * @returns true if user can access the file
+     */
+    canAccess(fileId: string, userId: string): Promise<boolean>;
+    /**
+     * Move file to different folder
+     */
+    moveToFolder(fileId: string, newFolderPath: string): Promise<File>;
+    /**
+     * Add tags to file
+     */
+    addTags(fileId: string, tags: string[]): Promise<File>;
+    /**
+     * Remove tags from file
+     */
+    removeTags(fileId: string, tags: string[]): Promise<File>;
+}
+
+/**
+ * Input for creating a custom object
+ */
+interface CreateCustomObjectInput {
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    attributes?: (Attribute | {
+        build: () => Attribute;
+    })[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Input for adding an attribute to an object
+ */
+interface AddAttributeInput {
+    name: string;
+    label: string;
+    type: AttributeType;
+    required?: boolean;
+    unique?: boolean;
+    description?: string;
+    placeholder?: string;
+    icon?: IconName;
+    defaultValue?: unknown;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Service for managing object schemas
+ * Handles fusion of native objects (from registry) and custom objects (from database)
+ */
+declare class ObjectSchemaService {
+    private adapter;
+    private nativeRegistry;
+    constructor(adapter: DatabaseAdapter, nativeRegistry: typeof registry);
+    /**
+     * Create a new custom object
+     * Validates name format and ensures system=false
+     *
+     * @param definition - Object definition (attributes can be raw definitions or builders)
+     * @param tenantId - Tenant ID owning the object
+     * @returns Created ObjectDefinition
+     */
+    createCustomObject(definition: CreateCustomObjectInput, tenantId: string): Promise<ObjectDefinition>;
+    /**
+     * Add a custom attribute to an existing object
+     * Can be used on both custom and native objects
+     * Attributes added via API are always custom (system=false)
+     *
+     * @param objectId - Object UUID from database
+     * @param attribute - Attribute definition
+     * @returns Created Attribute
+     */
+    addAttributeToObject(objectId: string, attribute: AddAttributeInput): Promise<Attribute>;
+    /**
+     * Update an attribute
+     * Can only update custom attributes (system=false)
+     *
+     * @param attributeId - Attribute UUID
+     * @param updates - Partial attribute updates
+     * @returns Updated Attribute
+     */
+    updateAttribute(attributeId: string, updates: Partial<AddAttributeInput>): Promise<Attribute>;
+    /**
+     * Delete an attribute
+     * Can only delete custom attributes (system=false)
+     *
+     * @param attributeId - Attribute UUID
+     */
+    deleteAttribute(attributeId: string): Promise<void>;
+    /**
+     * List attributes for an object
+     *
+     * @param objectId - Object UUID
+     * @param options - Filter options
+     * @returns List of attributes
+     */
+    listAttributes(objectId: string, options?: {
+        systemOnly?: boolean;
+        customOnly?: boolean;
+    }): Promise<Attribute[]>;
+    /**
+     * Validate attribute name format (variable identifier)
+     * @internal
+     */
+    private validateAttributeName;
+    /**
+     * Get complete object schema (system + custom attributes)
+     * If object is native, merges registry definition with DB custom attributes
+     * If object is custom, returns DB definition only
+     *
+     * @param objectId - Object UUID from database
+     * @returns Complete ObjectDefinition with all attributes
+     *
+     * @example
+     * ```typescript
+     * const service = new ObjectSchemaService(adapter, registry);
+     * const productSchema = await service.getObjectSchema("obj-123");
+     *
+     * console.log(productSchema.attributes); // System + custom attributes
+     * ```
+     */
+    getObjectSchema(objectId: string): Promise<ObjectDefinition>;
+    /**
+     * Get object schema by name (for system/native objects)
+     */
+    getObjectSchemaByName(name: string): Promise<ObjectDefinition>;
+    /**
+     * List all object schemas for a tenant
+     */
+    listObjectSchemas(tenantId: string): Promise<ObjectDefinition[]>;
+    /**
+     * Merge native object from registry with custom attributes from DB
+     * @internal
+     */
+    private mergeNativeObject;
+    /**
+     * Convert DB object + attributes to ObjectDefinition
+     * @internal
+     */
+    private convertDBObjectToDefinition;
+    /**
+     * Convert DB attribute to Attribute type
+     * @internal
+     */
+    private convertDBAttributeToAttribute;
+}
+
+/**
+ * Service for managing object records (CRUD operations)
+ * Handles validation, dispatch to correct table, and data consistency
+ */
+declare class RecordService {
+    private adapter;
+    private tenantId;
+    private schemaService;
+    private relationService;
+    constructor(adapter: DatabaseAdapter, tenantId: string);
+    /**
+     * Create a new record with validation
+     *
+     * @param objectId - Object UUID
+     * @param data - Record data (attribute values)
+     * @param options - Creation options
+     * @returns Created record with computed completionStatus
+     *
+     * @example
+     * ```typescript
+     * const service = new RecordService(adapter, "tenant-123");
+     *
+     * // Create a complete record (strict validation)
+     * const product = await service.createRecord("obj-product", {
+     *   name: "Nike Air Max",
+     *   price: 129.99,
+     *   status: "active"
+     * });
+     * // → product.completionStatus = "complete"
+     *
+     * // Create a draft record (allows missing required fields)
+     * const draft = await service.createRecord("obj-product", {
+     *   name: "Draft Product"
+     * }, { allowDraft: true });
+     * // → draft.completionStatus = "draft"
+     * ```
+     */
+    createRecord(objectId: string, data: Record<string, unknown>, options?: {
+        /**
+         * Allow creating records with missing required fields.
+         * Format validation still applies to provided values.
+         * @default false
+         */
+        allowDraft?: boolean;
+        /**
+         * Skip all validation (format + relations).
+         * @default true
+         */
+        validate?: boolean;
+        /**
+         * Skip relation validation only.
+         * Useful for bulk imports where relations are validated separately.
+         * @default false
+         */
+        skipRelationValidation?: boolean;
+        skipSystemCheck?: boolean;
+    }): Promise<ObjectRecord>;
+    /**
+     * Get a record by ID
+     *
+     * @param recordId - Record UUID
+     * @param options - Query options
+     * @returns Record or null if not found
+     */
+    getRecord(recordId: string, options?: {
+        includeSchema?: boolean;
+    }): Promise<ObjectRecord | null>;
+    /**
+     * Get a record by ID or throw if not found
+     */
+    getRecordOrThrow(recordId: string): Promise<ObjectRecord>;
+    /**
+     * Update a record with validation
+     *
+     * The completion status is automatically recalculated after each update.
+     * A draft record becomes complete when all required fields are filled.
+     *
+     * @param recordId - Record UUID
+     * @param data - Partial data to update
+     * @param options - Update options
+     * @returns Updated record with recalculated completionStatus
+     *
+     * @example
+     * ```typescript
+     * // Update a draft record to make it complete
+     * const updated = await service.updateRecord(draftId, {
+     *   price: 99.99,
+     *   status: "active"
+     * });
+     * // → updated.completionStatus = "complete" if all required fields now present
+     * ```
+     */
+    updateRecord(recordId: string, data: Partial<Record<string, unknown>>, options?: {
+        /**
+         * Skip validation entirely (format + relations).
+         * @default true
+         */
+        validate?: boolean;
+        /**
+         * Allow partial updates without strict validation.
+         * Format validation still applies to provided values.
+         * @default false
+         */
+        partial?: boolean;
+        /**
+         * Skip relation validation only.
+         * @default false
+         */
+        skipRelationValidation?: boolean;
+    }): Promise<ObjectRecord>;
+    /**
+     * Delete a record
+     *
+     * @param recordId - Record UUID
+     * @param options - Delete options
+     */
+    deleteRecord(recordId: string, options?: {
+        checkSystem?: boolean;
+    }): Promise<void>;
+    /**
+     * List records for an object with pagination
+     *
+     * @param objectId - Object UUID
+     * @param options - List options
+     * @returns Records and total count
+     */
+    listRecords(objectId: string, options?: {
+        limit?: number;
+        offset?: number;
+        orderBy?: string;
+        orderDirection?: "asc" | "desc";
+    }): Promise<{
+        records: ObjectRecord[];
+        total: number;
+    }>;
+    /**
+     * Search records using full-text search
+     *
+     * @param objectId - Object UUID
+     * @param query - Search query
+     * @param options - Search options
+     * @returns Matching records and total count
+     */
+    searchRecords(objectId: string, query: string, options?: {
+        limit?: number;
+        offset?: number;
+        filters?: Record<string, unknown>;
+    }): Promise<{
+        records: ObjectRecord[];
+        total: number;
+    }>;
+    /**
+     * Validate data against object schema without saving
+     *
+     * @param objectId - Object UUID
+     * @param data - Data to validate
+     * @returns Validation result
+     */
+    validateData(objectId: string, data: Record<string, unknown>): Promise<ValidationResult>;
+    /**
+     * Compute the completion status for given data without saving.
+     * Useful for UI to show draft/complete status before submitting.
+     *
+     * @param objectId - Object UUID
+     * @param data - Data to check
+     * @returns Computed completion status
+     */
+    computeStatus(objectId: string, data: Record<string, unknown>): Promise<CompletionStatus>;
+    /**
+     * Refresh the completion status of an existing record.
+     * Useful when schema changes and you need to recompute statuses.
+     *
+     * @param recordId - Record UUID
+     * @returns Updated completion status
+     */
+    refreshRecordStatus(recordId: string): Promise<CompletionStatus>;
+}
+
+/**
+ * Result of relation validation
+ */
+interface RelationValidationResult {
+    valid: boolean;
+    errors: RelationValidationError[];
+}
+/**
+ * Individual relation validation error
+ */
+interface RelationValidationError {
+    /** Attribute name */
+    attribute: string;
+    /** Error message */
+    message: string;
+    /** Invalid record IDs */
+    invalidIds?: string[];
+}
+/**
+ * Resolved relation option
+ */
+interface RelationOption {
+    /** Record ID */
+    id: string;
+    /** Object ID */
+    objectId: string;
+    /** Object name */
+    objectName: string;
+    /** Display label (resolved from titleAttribute) */
+    label: string;
+    /** Additional record data */
+    data?: Record<string, unknown>;
+}
+/**
+ * Response for relation options
+ */
+interface RelationOptionsResponse {
+    options: RelationOption[];
+    hasMore: boolean;
+    total: number;
+}
+/**
+ * Parameters for fetching relation options
+ */
+interface GetRelationOptionsParams {
+    /** Search query */
+    query?: string;
+    /** Page number (1-based) */
+    page?: number;
+    /** Page size */
+    pageSize?: number;
+    /** Filter by specific target object */
+    targetObject?: string;
+}
+/**
+ * Service for validating relation attributes
+ * Ensures referenced records exist and belong to valid target objects
+ */
+declare class RelationService {
+    private adapter;
+    private schemaService;
+    constructor(adapter: DatabaseAdapter, nativeRegistry: typeof registry);
+    /**
+     * Validate all relation attributes in the data
+     *
+     * @param schema - Object schema containing attribute definitions
+     * @param data - Record data to validate
+     * @returns Validation result with errors if any
+     *
+     * @example
+     * ```typescript
+     * const result = await relationService.validateRelations(schema, {
+     *   company: "rec-123",
+     *   contacts: ["rec-456", "rec-789"]
+     * });
+     *
+     * if (!result.valid) {
+     *   console.log(result.errors);
+     *   // [{ attribute: "company", message: "Record not found", invalidIds: ["rec-123"] }]
+     * }
+     * ```
+     */
+    validateRelations(schema: ObjectDefinition, data: Record<string, unknown>): Promise<RelationValidationResult>;
+    /**
+     * Validate a single relation attribute value
+     */
+    private validateRelationAttribute;
+    /**
+     * Extract IDs from relation value based on cardinality
+     */
+    private extractIds;
+    /**
+     * Get valid object IDs from relation targets
+     */
+    private getValidObjectIds;
+    /**
+     * Validate relations and throw if invalid
+     */
+    validateRelationsOrThrow(schema: ObjectDefinition, data: Record<string, unknown>): Promise<void>;
+    /**
+     * Get available options for a relation attribute
+     * Searches across all target objects defined in the relation
+     *
+     * @param attribute - Relation attribute definition
+     * @param tenantId - Tenant ID for multi-tenant isolation
+     * @param params - Query parameters
+     *
+     * @example
+     * ```typescript
+     * const options = await relationService.getOptions(attribute, "tenant-1", {
+     *   query: "nike",
+     *   page: 1,
+     *   pageSize: 20
+     * });
+     * ```
+     */
+    getOptions(attribute: RelationAttribute, tenantId: string, params?: GetRelationOptionsParams): Promise<RelationOptionsResponse>;
+    /**
+     * Resolve record IDs to their display labels
+     * Useful for displaying current values in the UI
+     *
+     * @param ids - Record IDs to resolve
+     * @param tenantId - Tenant ID for multi-tenant isolation
+     *
+     * @example
+     * ```typescript
+     * const resolved = await relationService.resolveIds(["rec-1", "rec-2"], "tenant-1");
+     * // [{ id: "rec-1", label: "Nike Air Max", objectName: "products", ... }]
+     * ```
+     */
+    resolveIds(ids: string[], tenantId: string): Promise<RelationOption[]>;
+    /**
+     * Find a relation attribute by ID
+     */
+    findAttributeById(attributeId: string): Promise<RelationAttribute | null>;
+    /**
+     * Resolve display label from record values
+     * Uses displayTemplate if provided, otherwise falls back to titleAttribute
+     */
+    private resolveLabel;
+}
+
+/**
+ * Service for managing user profiles
+ * Handles user profile CRUD, auth provider sync, and role management
+ */
+declare class UserProfileService {
+    private adapter;
+    private tenantId;
+    constructor(adapter: DatabaseAdapter, tenantId: string);
+    /**
+     * Create a new user profile (typically after first auth)
+     *
+     * @param data - User profile creation data
+     * @returns Created user profile
+     *
+     * @example
+     * ```typescript
+     * const service = new UserProfileService(adapter, "tenant-123");
+     *
+     * // After Supabase auth
+     * const profile = await service.createProfile({
+     *   tenantId: "tenant-123",
+     *   authId: authUser.id,
+     *   email: authUser.email,
+     *   firstName: authUser.user_metadata.first_name,
+     *   lastName: authUser.user_metadata.last_name,
+     *   role: "member",
+     *   status: "active"
+     * });
+     * ```
+     */
+    createProfile(data: CreateUserProfile): Promise<UserProfile>;
+    /**
+     * Get user profile by ID
+     */
+    getProfile(profileId: string): Promise<UserProfile | null>;
+    /**
+     * Get user profile by ID or throw
+     */
+    getProfileOrThrow(profileId: string): Promise<UserProfile>;
+    /**
+     * Get user profile by auth provider ID
+     *
+     * @param authId - Auth provider user ID (Supabase, Clerk, etc.)
+     * @returns User profile or null
+     */
+    getProfileByAuthId(authId: string): Promise<UserProfile | null>;
+    /**
+     * Get or create user profile (idempotent operation)
+     * Useful for auth callbacks - ensures profile exists
+     *
+     * @param authId - Auth provider user ID
+     * @param data - Profile data to create if doesn't exist
+     * @returns Existing or newly created profile
+     *
+     * @example
+     * ```typescript
+     * // In Supabase auth callback
+     * const profile = await service.getOrCreateProfile(
+     *   authUser.id,
+     *   {
+     *     tenantId: "tenant-123",
+     *     authId: authUser.id,
+     *     email: authUser.email,
+     *     role: "member",
+     *     status: "active"
+     *   }
+     * );
+     * ```
+     */
+    getOrCreateProfile(authId: string, data: CreateUserProfile): Promise<UserProfile>;
+    /**
+     * Update user profile
+     */
+    updateProfile(profileId: string, data: UpdateUserProfile): Promise<UserProfile>;
+    /**
+     * Delete user profile
+     *
+     * @param profileId - Profile UUID
+     * @param options - Delete options
+     */
+    deleteProfile(profileId: string, options?: {
+        checkAdmin?: boolean;
+    }): Promise<void>;
+    /**
+     * List all user profiles for the tenant
+     */
+    listProfiles(options?: ListOptions): Promise<UserProfile[]>;
+    /**
+     * Update last login timestamp
+     *
+     * @param profileId - Profile UUID
+     *
+     * @example
+     * ```typescript
+     * // After successful auth
+     * await service.updateLastLogin(profile.id);
+     * ```
+     */
+    updateLastLogin(profileId: string): Promise<void>;
+    /**
+     * Change user role
+     *
+     * @param profileId - Profile UUID
+     * @param newRole - New role
+     */
+    changeRole(profileId: string, newRole: string): Promise<UserProfile>;
+    /**
+     * Change user status
+     *
+     * @param profileId - Profile UUID
+     * @param newStatus - New status
+     */
+    changeStatus(profileId: string, newStatus: "active" | "pending" | "inactive" | "suspended"): Promise<UserProfile>;
+    /**
+     * Get user by email
+     */
+    getProfileByEmail(email: string): Promise<UserProfile | null>;
+    /**
+     * Check if user has role
+     */
+    hasRole(profileId: string, role: string): Promise<boolean>;
+    /**
+     * Check if user is admin
+     */
+    isAdmin(profileId: string): Promise<boolean>;
+}
+
+/**
+ * Result of sync operation
+ */
+interface SyncResult {
+    success: boolean;
+    objectsSynced: number;
+    attributesSynced: number;
+    objectsCreated: number;
+    objectsUpdated: number;
+    attributesCreated: number;
+    attributesUpdated: number;
+    attributesDeleted: number;
+    errors: Array<{
+        objectName: string;
+        error: string;
+    }>;
+}
+/**
+ * Sync options
+ */
+interface SyncOptions {
+    dryRun?: boolean;
+    verbose?: boolean;
+    tenantId?: string;
+}
+/**
+ * Sync native objects from registry to database
+ *
+ * This function:
+ * 1. Reads all registered native objects from the registry
+ * 2. Upserts them into the database (objects + attributes tables)
+ * 3. Marks them as system=true for protection
+ * 4. Removes attributes that were deleted from code
+ *
+ * @param adapter - Database adapter implementing DatabaseAdapter interface
+ * @param nativeRegistry - Registry containing native objects
+ * @param options - Sync options (dryRun, verbose, tenantId)
+ * @returns Sync result with statistics
+ *
+ * @example
+ * ```typescript
+ * import { syncNativeObjects } from "@andyoucreate/schema/runtime";
+ * import { registry } from "./objects/native";
+ * import { drizzleAdapter } from "./db/adapter";
+ *
+ * const result = await syncNativeObjects(drizzleAdapter, registry, {
+ *   verbose: true,
+ *   tenantId: "default"
+ * });
+ *
+ * if (result.success) {
+ *   console.log(`✓ Synced ${result.objectsSynced} objects`);
+ * } else {
+ *   console.error("Sync errors:", result.errors);
+ * }
+ * ```
+ */
+declare function syncNativeObjects(adapter: DatabaseAdapter, nativeRegistry: typeof registry, options?: SyncOptions): Promise<SyncResult>;
+/**
+ * Verify that all native objects are synced to database
+ *
+ * @param adapter - Database adapter
+ * @param nativeRegistry - Registry containing native objects
+ * @returns true if all objects are synced, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const isSynced = await verifyNativeObjectsSync(adapter, registry);
+ * if (!isSynced) {
+ *   console.warn("Native objects not synced, running sync...");
+ *   await syncNativeObjects(adapter, registry);
+ * }
+ * ```
+ */
+declare function verifyNativeObjectsSync(adapter: DatabaseAdapter, nativeRegistry: typeof registry): Promise<boolean>;
+/**
+ * Get sync statistics without modifying database
+ *
+ * @param adapter - Database adapter
+ * @param nativeRegistry - Registry containing native objects
+ * @returns Sync result (dry run)
+ */
+declare function getSyncPreview(adapter: DatabaseAdapter, nativeRegistry: typeof registry): Promise<SyncResult>;
+
+export { type TenantId as $, type Attribute as A, type BaseAttribute as B, type Currency as C, type DateAttribute as D, type File as E, type FileAttribute as F, type CreateFile as G, type UpdateFile as H, type Timestamps as I, type ObjectAttribute as J, type CompletionStatus as K, type Location as L, type MultiselectAttribute as M, type NumberAttribute as N, type Option as O, type Phone as P, type ObjectRecord as Q, type RelationOnDelete as R, type StatusAttribute as S, type TextAttribute as T, type UserAttribute as U, type UserRole as V, type UserStatus as W, type UserProfile as X, type CreateUserProfile as Y, type UpdateUserProfile as Z, type Uuid as _, type SelectAttribute as a, type UpsertDBAttribute as a$, generateId as a0, generatePrefixedId as a1, registry as a2, createTextValidator as a3, createNumberValidator as a4, createCheckboxValidator as a5, createDateValidator as a6, createPhoneValidator as a7, createCurrencyValidator as a8, createStatusValidator as a9, type UserProfilesRepository as aA, type FilesRepository as aB, type ObjectRecordsRepository as aC, FileService as aD, type CreateCustomObjectInput as aE, type AddAttributeInput as aF, ObjectSchemaService as aG, RecordService as aH, type RelationValidationResult as aI, type RelationValidationError as aJ, type RelationOption as aK, type RelationOptionsResponse as aL, type GetRelationOptionsParams as aM, RelationService as aN, UserProfileService as aO, type SyncResult as aP, type SyncOptions as aQ, syncNativeObjects as aR, verifyNativeObjectsSync as aS, getSyncPreview as aT, type DBObject as aU, type CreateDBObject as aV, type UpdateDBObject as aW, type UpsertDBObject as aX, type DBAttribute as aY, type CreateDBAttribute as aZ, type UpdateDBAttribute as a_, createSelectValidator as aa, createMultiselectValidator as ab, createLocationValidator as ac, createTimestampValidator as ad, createFileValidator as ae, createUserValidator as af, createSingleRelationValidator as ag, createMultiRelationValidator as ah, createRelationValidator as ai, createRatingValidator as aj, createAttributeValidator as ak, createObjectValidator as al, type ValidationResult as am, validateAttribute as an, validateObject as ao, validateObjectOrThrow as ap, createDraftValidator as aq, validateDraft as ar, validateDraftOrThrow as as, getMissingRequiredAttributes as at, isRecordComplete as au, computeRecordStatus as av, type DatabaseAdapter as aw, createMockAdapter as ax, type ObjectsRepository as ay, type AttributesRepository as az, type TextAreaAttribute as b, type CreateObjectRecord as b0, type ListOptions as b1, type SearchOptions as b2, type FileListOptions as b3, type OperationResult as b4, type CheckboxAttribute as c, type PhoneAttribute as d, type CurrencyAttribute as e, type LocationAttribute as f, type TimestampAttribute as g, type SingleRelationAttribute as h, type MultiRelationAttribute as i, type RelationTarget as j, type RatingAttribute as k, type ObjectDefinition as l, type AttributeType as m, type StatusGroup as n, type AttributeGroup as o, type NumberUnit as p, type DateFormat as q, type DateValue as r, type LocationGranularity as s, type DocumentType as t, type DocumentFace as u, type DocumentTypeConfig as v, type FileVerificationConfig as w, type RelationAttribute as x, type StorageProvider as y, type FileVisibility as z };