@stndrds/schema 0.1.0-alpha.14

package/dist/runtime-Cq8jfk3c.d.mts

@@ -0,0 +1,4277 @@
+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;
+    pluralLabel?: string;
+    description?: string;
+    icon?: IconName;
+    /**
+     * Template expression used to compute the object's display label.
+     * Supports variable interpolation and pipes for formatting.
+     *
+     * @example
+     * ```typescript
+     * // Simple attribute reference
+     * labelExpression: "{{ name }}"
+     *
+     * // Multiple attributes
+     * labelExpression: "{{ firstName }} {{ lastName }}"
+     *
+     * // With pipes for formatting
+     * labelExpression: "{{ code | UPPER }} - {{ name | capitalize }}"
+     * ```
+     *
+     * Available pipes: UPPER, LOWER, capitalize, trim
+     */
+    labelExpression: 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;
+    /**
+     * Display label computed from the object's labelExpression.
+     * Computed dynamically based on record values.
+     *
+     * @example "John Doe" (from "{{ firstName }} {{ lastName }}")
+     */
+    label: string;
+    /**
+     * 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[];
+}
+
+/** Operators for text-based attributes */
+type TextFilterOperator = "is" | "is_not" | "contains" | "not_contains" | "starts_with" | "ends_with" | "is_empty" | "is_not_empty";
+/** Operators for number-based attributes */
+type NumberFilterOperator = "eq" | "neq" | "lt" | "gt" | "lte" | "gte" | "is_empty" | "is_not_empty";
+/** Operators for checkbox */
+type CheckboxFilterOperator = "is_checked" | "is_not_checked";
+/** Operators for date-based attributes */
+type DateFilterOperator = "is" | "is_not" | "before" | "after" | "on_or_before" | "on_or_after" | "is_within" | "is_empty" | "is_not_empty";
+/** Operators for select-based attributes (supports single or multi-value filtering) */
+type SelectFilterOperator = "is" | "is_not" | "any_of" | "none_of" | "is_empty" | "is_not_empty";
+/** Operators for multiselect-based attributes */
+type MultiselectFilterOperator = "contains" | "not_contains" | "is_empty" | "is_not_empty";
+/** Operators for relation-based attributes (supports single or multi-value filtering) */
+type RelationFilterOperator = "any_of" | "none_of" | "contains" | "not_contains" | "is_empty" | "is_not_empty";
+/** All possible filter operators */
+type FilterOperator = TextFilterOperator | NumberFilterOperator | CheckboxFilterOperator | DateFilterOperator | SelectFilterOperator | MultiselectFilterOperator | RelationFilterOperator;
+/** Relative date value for "is_within" operator */
+interface RelativeDateValue {
+    amount: number;
+    unit: "days" | "weeks" | "months" | "years";
+    direction: "past" | "future";
+}
+/** Currency filter value with amount and optional currency code */
+interface CurrencyFilterValue {
+    value: number | null;
+    code?: string;
+}
+/** Phone filter value with number and optional country code */
+interface PhoneFilterValue {
+    phoneNumber: string | null;
+    countryCode?: string;
+}
+/** Filter value can be various types depending on the attribute */
+type FilterValue = string | number | boolean | string[] | RelativeDateValue | CurrencyFilterValue | PhoneFilterValue | null;
+/** A single filter rule */
+interface FilterRule {
+    /** Attribute name to filter on */
+    attribute: string;
+    /** Filter operator */
+    operator: FilterOperator;
+    /** Filter value (null for operators like is_empty) */
+    value: FilterValue;
+}
+/** Combinator for filter rules */
+type FilterCombinator = "and" | "or";
+/** Complete filter state (simple mode) */
+interface FilterState {
+    /** How to combine rules */
+    combinator: FilterCombinator;
+    /** List of filter rules */
+    rules: FilterRule[];
+}
+/**
+ * A filter group containing rules (used in advanced mode)
+ * Groups can be nested up to 2 levels deep
+ */
+interface FilterGroup {
+    /** Unique identifier for this group */
+    id: string;
+    /** How to combine rules within this group */
+    combinator: FilterCombinator;
+    /** List of filter rules in this group */
+    rules: FilterRule[];
+}
+/**
+ * Advanced filter state with nested groups
+ * Structure: AdvancedFilterState -> FilterGroup[] -> FilterRule[]
+ * Maximum 2 levels of nesting
+ */
+interface AdvancedFilterState {
+    /** How to combine groups at the top level */
+    combinator: FilterCombinator;
+    /** List of filter groups */
+    groups: FilterGroup[];
+}
+/**
+ * Type guard to check if a filter state is advanced
+ */
+declare function isAdvancedFilterState(state: FilterState | AdvancedFilterState): state is AdvancedFilterState;
+/**
+ * Convert simple filter state to advanced filter state
+ */
+declare function toAdvancedFilterState(state: FilterState): AdvancedFilterState;
+/**
+ * Convert advanced filter state to simple filter state (flattens groups)
+ * Note: This loses group structure - use with caution
+ */
+declare function toSimpleFilterState(state: AdvancedFilterState): FilterState;
+/** Sort direction */
+type SortDirection = "asc" | "desc";
+/** A single sort rule */
+interface SortRule {
+    /** Attribute name to sort by */
+    attribute: string;
+    /** Sort direction */
+    direction: SortDirection;
+}
+/** Complete query state with search, filters, sorts, and pagination */
+interface QueryState {
+    /** Full-text search query */
+    search?: string;
+    /** Filter configuration (simple mode) */
+    filters?: FilterState;
+    /** Advanced filter configuration (grouped mode) */
+    advancedFilters?: AdvancedFilterState;
+    /** Sort configuration (multiple sorts supported) */
+    sorts?: SortRule[];
+    /** Pagination */
+    limit?: number;
+    offset?: number;
+}
+/** Mapping of attribute types to their valid operators */
+declare const OPERATORS_BY_TYPE: Record<AttributeType, readonly FilterOperator[]>;
+/** Check if an operator requires a value */
+type NoValueOperator = "is_empty" | "is_not_empty" | "is_checked" | "is_not_checked";
+/** Operators that don't require a value */
+declare const NO_VALUE_OPERATORS: readonly NoValueOperator[];
+/**
+ * Check if an operator requires a value
+ */
+declare function isNoValueOperator(operator: FilterOperator): operator is NoValueOperator;
+
+/**
+ * Autocomplete suggestion from geocoding service
+ */
+interface GeocodingSuggestion {
+    /** Unique identifier from the provider */
+    id: string;
+    /** Human-readable label for display */
+    label: string;
+    /** Structured location data */
+    location: Location;
+    /** Optional match score/confidence (0-1) */
+    score?: number;
+    /** Optional additional metadata from the provider */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Parameters for autocomplete search
+ */
+interface GeocodingAutocompleteParams {
+    /** Search query */
+    query: string;
+    /** Restrict results to specific countries */
+    countries?: CountryIso3[];
+    /** Preferred language for results (ISO 639-1) */
+    language?: string;
+    /** Maximum number of results */
+    limit?: number;
+    /** Bias results toward a specific location */
+    biasLocation?: {
+        latitude: number;
+        longitude: number;
+    };
+    /** Session token for billing optimization (some providers) */
+    sessionToken?: string;
+    /**
+     * Level of address detail expected
+     * Adapters can use this to filter/optimize results
+     * - "full": Full address with street, city, postal code, etc.
+     * - "address": Street address without postal code
+     * - "city": City level only
+     * - "state": State/region level only
+     * - "country": Country level only
+     * - "coordinates": Only coordinates (lat/lng)
+     */
+    granularity?: LocationGranularity;
+}
+/**
+ * Parameters for reverse geocoding
+ */
+interface ReverseGeocodingParams {
+    /** Latitude */
+    latitude: number;
+    /** Longitude */
+    longitude: number;
+    /** Preferred language for results */
+    language?: string;
+}
+/**
+ * Parameters for geocoding a structured address
+ */
+interface GeocodingParams {
+    /** Structured address components */
+    address: Partial<Location>;
+    /** Preferred language for results */
+    language?: string;
+}
+/**
+ * Abstract geocoding adapter interface
+ * Implement this interface for different geocoding providers
+ *
+ * @example Google Maps implementation
+ * ```typescript
+ * class GoogleMapsGeocodingAdapter implements GeocodingAdapter {
+ *   async autocomplete(params) {
+ *     const response = await fetch(
+ *       `https://maps.googleapis.com/maps/api/place/autocomplete/json?input=${params.query}&key=${this.apiKey}`
+ *     );
+ *     // Transform response to GeocodingSuggestion[]
+ *   }
+ * }
+ * ```
+ *
+ * @example Mapbox implementation
+ * ```typescript
+ * class MapboxGeocodingAdapter implements GeocodingAdapter {
+ *   async autocomplete(params) {
+ *     const response = await fetch(
+ *       `https://api.mapbox.com/geocoding/v5/mapbox.places/${params.query}.json?access_token=${this.token}`
+ *     );
+ *     // Transform response to GeocodingSuggestion[]
+ *   }
+ * }
+ * ```
+ */
+interface GeocodingAdapter {
+    /**
+     * Autocomplete address search
+     * Returns suggestions as the user types
+     */
+    autocomplete(params: GeocodingAutocompleteParams): Promise<GeocodingSuggestion[]>;
+    /**
+     * Reverse geocode coordinates to an address
+     * Optional - some providers may not support this
+     */
+    reverse?(params: ReverseGeocodingParams): Promise<GeocodingSuggestion | null>;
+    /**
+     * Geocode a structured address to coordinates
+     * Optional - some providers may not support this
+     */
+    geocode?(params: GeocodingParams): Promise<GeocodingSuggestion | null>;
+}
+/**
+ * No-op geocoding adapter
+ * Returns empty results when no geocoding provider is configured
+ */
+declare class NoopGeocodingAdapter implements GeocodingAdapter {
+    autocomplete(): Promise<GeocodingSuggestion[]>;
+    reverse(): Promise<null>;
+    geocode(): Promise<null>;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Inline attribute group configuration
+ * Groups multiple attributes into a single composite field with dropdown editing
+ */
+interface AttributeGroupField {
+    /** Unique identifier for the group */
+    id: string;
+    /** Display label for the composite field */
+    label: string;
+    /** Description shown in the dropdown */
+    description?: string;
+    /** Attribute names to include in this group */
+    attributes: string[];
+    /**
+     * Template for the display value
+     * Uses {attributeName} syntax for interpolation
+     * @example "{billing_street}, {billing_city} {billing_postal_code}"
+     */
+    displayTemplate?: string;
+}
+/**
+ * Field definition within a form group
+ * Can be either a single attribute or an inline attribute group
+ */
+interface Field {
+    /** Attribute name to display (for single attribute fields) */
+    attribute?: string;
+    /** Inline attribute group (groups multiple attributes into one composite field) */
+    attributeGroup?: AttributeGroupField;
+    /** Grid span (1-12 columns) */
+    span?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+    /** Override label for this view (only for single attribute fields) */
+    label?: string;
+    /** Force read-only display */
+    readOnly?: boolean;
+}
+/**
+ * Group of fields for organizing forms
+ */
+interface Group {
+    id: string;
+    label: string;
+    description?: string;
+    fields: Field[];
+    collapsible?: boolean;
+    collapsed?: boolean;
+    order?: number;
+}
+type TabType = "form" | "table" | "custom";
+/**
+ * Base properties shared by all tab types
+ */
+interface BaseTab {
+    id: string;
+    name: string;
+    label: string;
+    icon?: IconName;
+    order?: number;
+    /** If true, tab is defined by developer (protected) */
+    system?: boolean;
+}
+/**
+ * Form tab - displays attributes organized in groups
+ */
+interface FormTab extends BaseTab {
+    type: "form";
+    groups: Group[];
+}
+/**
+ * Table tab - displays records from a relation attribute
+ */
+interface TableTab extends BaseTab {
+    type: "table";
+    /** Name of the relation attribute */
+    relation: string;
+    /** Columns to display (attribute names from target object) */
+    columns: string[];
+    /** Allow creating new records */
+    allowCreate?: boolean;
+    /** Allow inline editing */
+    allowEdit?: boolean;
+    /** Allow deleting records */
+    allowDelete?: boolean;
+    /** Default filters */
+    filters?: Record<string, unknown>;
+    /** Default sort */
+    sort?: {
+        field: string;
+        order: "asc" | "desc";
+    };
+}
+/**
+ * Custom tab - renders a developer-defined component
+ */
+interface CustomTab extends BaseTab {
+    type: "custom";
+    /** Component identifier to render */
+    component: string;
+    /** Props to pass to the component */
+    props?: Record<string, unknown>;
+}
+/**
+ * Union of all tab types
+ */
+type Tab = FormTab | TableTab | CustomTab;
+/**
+ * View definition - organizes object attributes into tabs/pages
+ *
+ * @example
+ * ```typescript
+ * const companyView: ViewDefinition = {
+ *   name: "detail",
+ *   label: "Company Detail",
+ *   object: "companies",
+ *   tabs: [
+ *     { type: "form", name: "general", label: "Info", groups: [...] },
+ *     { type: "table", name: "contacts", label: "Contacts", relation: "contacts", columns: [...] }
+ *   ],
+ *   default: true,
+ *   system: true
+ * };
+ * ```
+ */
+interface ViewDefinition {
+    id?: Uuid;
+    /** Technical name (kebab-case) */
+    name: string;
+    /** Display label */
+    label: string;
+    /** Description */
+    description?: string;
+    /** Icon */
+    icon?: IconName;
+    /** Object this view belongs to (object name) */
+    object: string;
+    /** Tabs in this view */
+    tabs: Tab[];
+    /** Default view for this object */
+    default?: boolean;
+    /** System view (defined by developer, protected) */
+    system?: boolean;
+    /** Extensible metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Check if a tab is a form tab
+ */
+declare function isFormTab(tab: Tab): tab is FormTab;
+/**
+ * Check if a tab is a table tab
+ */
+declare function isTableTab(tab: Tab): tab is TableTab;
+/**
+ * Check if a tab is a custom tab
+ */
+declare function isCustomTab(tab: Tab): tab is CustomTab;
+
+/**
+ * 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;
+
+/**
+ * Registry for native view definitions
+ *
+ * Views registered here are considered "system" views, defined by the developer.
+ * They are protected from modification by end-users and synced to the database
+ * at application startup.
+ *
+ * @example
+ * ```typescript
+ * import { view, group, viewRegistry } from "@andyoucreate/schema";
+ *
+ * const COMPANY_DETAIL = view("detail", "Detail")
+ *   .for("companies")
+ *   .system()
+ *   .tab("general", "Info")
+ *     .form(group("main", "Main").fields("name", "status"))
+ *   .build();
+ *
+ * viewRegistry.register(COMPANY_DETAIL);
+ * ```
+ */
+declare class ViewRegistry {
+    private views;
+    private byObject;
+    /**
+     * Register a native view
+     * @param viewOrViews - Single view or array of views
+     * @throws Error if view is not marked as system
+     * @throws Error if view with same name already exists for the object
+     */
+    register(viewOrViews: ViewDefinition | ViewDefinition[]): this;
+    private registerSingle;
+    /**
+     * Get all views for an object
+     */
+    getByObjectName(objectName: string): ViewDefinition[];
+    /**
+     * Get a specific view by object and view name
+     */
+    get(objectName: string, viewName: string): ViewDefinition | undefined;
+    /**
+     * Get a view or throw if not found
+     */
+    getOrThrow(objectName: string, viewName: string): ViewDefinition;
+    /**
+     * Get all registered views
+     */
+    getAll(): ViewDefinition[];
+    /**
+     * Check if a view exists
+     */
+    has(objectName: string, viewName: string): boolean;
+    /**
+     * Check if any views exist for an object
+     */
+    hasObject(objectName: string): boolean;
+    /**
+     * Get number of registered views
+     */
+    get size(): number;
+    /**
+     * List all object names that have views
+     */
+    listObjectNames(): string[];
+    /**
+     * Get default view for an object (if any)
+     */
+    getDefault(objectName: string): ViewDefinition | undefined;
+    /**
+     * Clear all registered views (for testing)
+     */
+    clear(): void;
+    /**
+     * Generate summary string for debugging
+     */
+    summary(): string;
+    /**
+     * Log summary to console
+     */
+    debug(): void;
+    private makeKey;
+}
+/**
+ * Global registry for native views
+ */
+declare const viewRegistry: ViewRegistry;
+
+/**
+ * Text attribute config schema
+ */
+declare const textConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    pattern: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    pattern?: string | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    pattern?: string | undefined;
+}>;
+/**
+ * Textarea attribute config schema
+ */
+declare const textareaConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Number attribute config schema
+ */
+declare const numberConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodOptional<z.ZodEnum<["integer", "decimal", "percentage"]>>;
+    decimals: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    unit?: "percentage" | "integer" | "decimal" | undefined;
+    decimals?: number | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    unit?: "percentage" | "integer" | "decimal" | undefined;
+    decimals?: number | undefined;
+}>;
+/**
+ * Checkbox attribute config schema
+ */
+declare const checkboxConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Date attribute config schema
+ */
+declare const dateConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    dateFormat: z.ZodOptional<z.ZodEnum<["short", "long", "full", "relative"]>>;
+    minDate: z.ZodOptional<z.ZodString>;
+    maxDate: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    dateFormat?: "short" | "long" | "full" | "relative" | undefined;
+    minDate?: string | undefined;
+    maxDate?: string | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    dateFormat?: "short" | "long" | "full" | "relative" | undefined;
+    minDate?: string | undefined;
+    maxDate?: string | undefined;
+}>;
+/**
+ * Phone attribute config schema
+ */
+declare const phoneConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    defaultCountryCode: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    defaultCountryCode?: string | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    defaultCountryCode?: string | undefined;
+}>;
+/**
+ * Currency attribute config schema
+ */
+declare const currencyConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    defaultCurrency: z.ZodOptional<z.ZodString>;
+    allowedCurrencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    defaultCurrency?: string | undefined;
+    allowedCurrencies?: string[] | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    defaultCurrency?: string | undefined;
+    allowedCurrencies?: string[] | undefined;
+}>;
+/**
+ * Status attribute config schema
+ */
+declare const statusConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodEnum<["idle", "in_progress", "finished"]>>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }, {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    options: {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Location attribute config schema
+ */
+declare const locationConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    granularity: z.ZodEnum<["full", "address", "city", "state", "country", "coordinates"]>;
+    enableAutocomplete: z.ZodOptional<z.ZodBoolean>;
+    enableMap: z.ZodOptional<z.ZodBoolean>;
+    defaultCountry: z.ZodOptional<z.ZodString>;
+    allowedCountries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    displayFormat: z.ZodOptional<z.ZodEnum<["single_line", "multi_line", "compact"]>>;
+}, "strip", z.ZodTypeAny, {
+    granularity: "full" | "address" | "city" | "state" | "country" | "coordinates";
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    enableAutocomplete?: boolean | undefined;
+    enableMap?: boolean | undefined;
+    defaultCountry?: string | undefined;
+    allowedCountries?: string[] | undefined;
+    displayFormat?: "single_line" | "multi_line" | "compact" | undefined;
+}, {
+    granularity: "full" | "address" | "city" | "state" | "country" | "coordinates";
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    enableAutocomplete?: boolean | undefined;
+    enableMap?: boolean | undefined;
+    defaultCountry?: string | undefined;
+    allowedCountries?: string[] | undefined;
+    displayFormat?: "single_line" | "multi_line" | "compact" | undefined;
+}>;
+/**
+ * Timestamp attribute config schema
+ */
+declare const timestampConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    autoUpdate: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    autoUpdate?: boolean | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    autoUpdate?: boolean | undefined;
+}>;
+/**
+ * Select attribute config schema
+ */
+declare const selectConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodEnum<["idle", "in_progress", "finished"]>>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }, {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    options: {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Multiselect attribute config schema
+ */
+declare const multiselectConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodEnum<["idle", "in_progress", "finished"]>>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }, {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    options: {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+/**
+ * File attribute config schema
+ */
+declare const fileConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    maxFiles: z.ZodOptional<z.ZodNumber>;
+    maxSize: z.ZodOptional<z.ZodNumber>;
+    allowedTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    verification: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        documentTypes: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["id_card", "passport", "incorporation_certificate", "driver_license", "birth_certificate", "residence_permit", "bank_statement", "proof_of_address", "custom"]>;
+            label: z.ZodString;
+            faces: z.ZodArray<z.ZodEnum<["front", "back", "single"]>, "many">;
+            attributeMapping: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                attributeId: z.ZodString;
+                extractedKey: z.ZodString;
+                face: z.ZodOptional<z.ZodEnum<["front", "back", "single"]>>;
+                required: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }, {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            type: "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+            faces: ("front" | "back" | "single")[];
+            attributeMapping?: {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }[] | undefined;
+        }, {
+            label: string;
+            type: "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+            faces: ("front" | "back" | "single")[];
+            attributeMapping?: {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }[] | undefined;
+        }>, "many">;
+        autoExtract: z.ZodOptional<z.ZodBoolean>;
+        autoValidate: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        documentTypes: {
+            label: string;
+            type: "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+            faces: ("front" | "back" | "single")[];
+            attributeMapping?: {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }[] | undefined;
+        }[];
+        autoExtract?: boolean | undefined;
+        autoValidate?: boolean | undefined;
+    }, {
+        enabled: boolean;
+        documentTypes: {
+            label: string;
+            type: "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+            faces: ("front" | "back" | "single")[];
+            attributeMapping?: {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }[] | undefined;
+        }[];
+        autoExtract?: boolean | undefined;
+        autoValidate?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    maxFiles?: number | undefined;
+    maxSize?: number | undefined;
+    allowedTypes?: string[] | undefined;
+    verification?: {
+        enabled: boolean;
+        documentTypes: {
+            label: string;
+            type: "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+            faces: ("front" | "back" | "single")[];
+            attributeMapping?: {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }[] | undefined;
+        }[];
+        autoExtract?: boolean | undefined;
+        autoValidate?: boolean | undefined;
+    } | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    maxFiles?: number | undefined;
+    maxSize?: number | undefined;
+    allowedTypes?: string[] | undefined;
+    verification?: {
+        enabled: boolean;
+        documentTypes: {
+            label: string;
+            type: "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+            faces: ("front" | "back" | "single")[];
+            attributeMapping?: {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }[] | undefined;
+        }[];
+        autoExtract?: boolean | undefined;
+        autoValidate?: boolean | undefined;
+    } | undefined;
+}>;
+/**
+ * User attribute config schema
+ */
+declare const userConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    allowedRoles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    allowedRoles?: string[] | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    allowedRoles?: string[] | undefined;
+}>;
+/**
+ * Relation attribute config schema
+ */
+declare const relationConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    targets: z.ZodArray<z.ZodObject<{
+        object: z.ZodString;
+        displayTemplate: z.ZodOptional<z.ZodString>;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        filter?: Record<string, unknown> | undefined;
+        displayTemplate?: string | undefined;
+    }, {
+        object: string;
+        filter?: Record<string, unknown> | undefined;
+        displayTemplate?: string | undefined;
+    }>, "many">;
+    onDelete: z.ZodOptional<z.ZodEnum<["restrict", "cascade", "set_null"]>>;
+    cardinality: z.ZodEnum<["one", "many"]>;
+    minItems: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    cardinality: "one" | "many";
+    targets: {
+        object: string;
+        filter?: Record<string, unknown> | undefined;
+        displayTemplate?: string | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    onDelete?: "restrict" | "cascade" | "set_null" | undefined;
+    minItems?: number | undefined;
+    maxItems?: number | undefined;
+}, {
+    cardinality: "one" | "many";
+    targets: {
+        object: string;
+        filter?: Record<string, unknown> | undefined;
+        displayTemplate?: string | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    onDelete?: "restrict" | "cascade" | "set_null" | undefined;
+    minItems?: number | undefined;
+    maxItems?: number | undefined;
+}>;
+/**
+ * Rating attribute config schema
+ */
+declare const ratingConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    max: z.ZodOptional<z.ZodNumber>;
+    iconType: z.ZodOptional<z.ZodEnum<["star", "heart", "thumbs", "number"]>>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    max?: number | undefined;
+    iconType?: "number" | "heart" | "star" | "thumbs" | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    max?: number | undefined;
+    iconType?: "number" | "heart" | "star" | "thumbs" | undefined;
+}>;
+/**
+ * Map of attribute type to config schema
+ */
+declare const attributeConfigSchemas: Record<AttributeType, z.ZodObject<z.ZodRawShape>>;
+/**
+ * Get the config schema for a specific attribute type
+ */
+declare function getAttributeConfigSchema(type: AttributeType): z.ZodObject<z.ZodRawShape>;
+/**
+ * Validate attribute config for a specific type
+ * Returns the validated config with only allowed properties
+ */
+declare function validateAttributeConfig(type: AttributeType, config: Record<string, unknown>): {
+    success: true;
+    data: Record<string, unknown>;
+} | {
+    success: false;
+    errors: string[];
+};
+/**
+ * Validate and strip unknown properties from attribute config
+ * This ensures only allowed properties are stored in the database
+ */
+declare function parseAttributeConfig(type: AttributeType, config: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Safely parse attribute config, returning undefined for invalid configs
+ */
+declare function safeParseAttributeConfig(type: AttributeType, config: Record<string, unknown>): Record<string, unknown> | undefined;
+/**
+ * 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;
+    pluralLabel?: string;
+    description?: string;
+    icon?: IconName;
+    labelExpression: string;
+    system: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface CreateDBObject {
+    tenantId: TenantId;
+    name: string;
+    label: string;
+    pluralLabel?: string;
+    description?: string;
+    icon?: IconName;
+    labelExpression: string;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateDBObject {
+    label?: string;
+    pluralLabel?: string;
+    description?: string;
+    icon?: IconName;
+    labelExpression?: string;
+    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;
+    type?: AttributeType;
+    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>;
+    /**
+     * Computed display label from labelExpression.
+     * Stored for performance - avoids recomputation on every read.
+     */
+    label: string;
+    /**
+     * 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;
+    /** @deprecated Use sorts instead */
+    orderBy?: string;
+    /** @deprecated Use sorts instead */
+    orderDirection?: "asc" | "desc";
+    /** Multiple sort rules */
+    sorts?: SortRule[];
+    /** Filter state */
+    filters?: FilterState;
+}
+/**
+ * Search options for full-text search
+ */
+interface SearchOptions extends ListOptions {
+    highlight?: boolean;
+}
+/**
+ * Global search options
+ */
+interface GlobalSearchOptions extends ListOptions {
+    /**
+     * Limit results to specific object names
+     */
+    objectNames?: string[];
+    /**
+     * Whether to include object metadata in results
+     */
+    includeObjectInfo?: boolean;
+}
+/**
+ * Global search result item
+ */
+interface GlobalSearchResultItem {
+    objectId: string;
+    objectName: string;
+    objectLabel: string;
+    /** Computed label from labelExpression */
+    label: string;
+    recordId: string;
+    values: Record<string, unknown>;
+    completionStatus: "draft" | "complete";
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * File-specific list options
+ */
+interface FileListOptions extends ListOptions {
+    folderPath?: string;
+    mimeType?: string;
+    uploadedBy?: Uuid;
+    includeDeleted?: boolean;
+}
+/**
+ * View as stored in database
+ */
+interface DBView extends Timestamps {
+    id: Uuid;
+    tenantId: TenantId;
+    objectId?: Uuid;
+    objectName: string;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    tabs: Tab[];
+    default: boolean;
+    system: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface CreateDBView {
+    tenantId: TenantId;
+    objectId?: Uuid;
+    objectName: string;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    tabs: Tab[];
+    default?: boolean;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateDBView {
+    label?: string;
+    description?: string;
+    icon?: IconName;
+    tabs?: Tab[];
+    default?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface UpsertDBView {
+    tenantId: TenantId;
+    objectName: string;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    tabs: Tab[];
+    default?: boolean;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * 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;
+    }>;
+    /**
+     * Global search across all object records for a tenant
+     * Searches in all objects or a subset specified by objectNames
+     */
+    globalSearch(tenantId: TenantId, query: string, options?: GlobalSearchOptions): Promise<{
+        results: GlobalSearchResultItem[];
+        total: number;
+    }>;
+}
+/**
+ * Repository for views table
+ */
+interface ViewsRepository {
+    /**
+     * Find view by ID
+     */
+    findById(id: Uuid): Promise<DBView | null>;
+    /**
+     * Find view by name for an object and tenant
+     */
+    findByName(tenantId: TenantId, objectName: string, viewName: string): Promise<DBView | null>;
+    /**
+     * Find all views for an object and tenant
+     */
+    findByObjectName(tenantId: TenantId, objectName: string): Promise<DBView[]>;
+    /**
+     * Find all views for a tenant
+     */
+    findAllForTenant(tenantId: TenantId): Promise<DBView[]>;
+    /**
+     * Find system view by name (for sync)
+     */
+    findSystemByName(objectName: string, viewName: string): Promise<DBView | null>;
+    /**
+     * Find all system views for an object
+     */
+    findSystemByObjectName(objectName: string): Promise<DBView[]>;
+    /**
+     * Create view
+     */
+    create(data: CreateDBView): Promise<DBView>;
+    /**
+     * Update view
+     */
+    update(id: Uuid, data: Partial<UpdateDBView>): Promise<DBView>;
+    /**
+     * Delete view
+     */
+    delete(id: Uuid): Promise<void>;
+    /**
+     * Delete views not in the list (for sync cleanup)
+     * @returns Number of deleted views
+     */
+    deleteNotIn(objectName: string, keepViewNames: string[]): Promise<number>;
+    /**
+     * Upsert view (create or update based on objectName + name)
+     */
+    upsert(data: UpsertDBView): Promise<DBView>;
+}
+
+/**
+ * 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;
+    views: ViewsRepository;
+    userProfiles: UserProfilesRepository;
+    files: FilesRepository;
+    objectRecords: ObjectRecordsRepository;
+    transaction<T>(callback: (adapter: DatabaseAdapter) => Promise<T>): Promise<T>;
+}
+
+/**
+ * Types of hooks supported by the system
+ */
+type HookType = "beforeCreate" | "afterCreate" | "beforeUpdate" | "afterUpdate" | "beforeDelete" | "afterDelete";
+/**
+ * Change information for a specific attribute
+ */
+interface AttributeChange<T = unknown> {
+    oldValue: T | undefined;
+    newValue: T | undefined;
+    changed: boolean;
+}
+/**
+ * Context passed to hooks - abstract, no framework dependencies
+ *
+ * This interface is designed to be extended by framework-specific implementations
+ * (e.g., TriggerContext in schema-nestjs adds NestJS services)
+ */
+interface HookContext<T = unknown> {
+    objectId: string;
+    objectName: string;
+    recordId: string;
+    tenantId: string;
+    record: ObjectRecord;
+    oldValues: Record<string, unknown>;
+    newValues: Record<string, unknown>;
+    changedAttributes: string[];
+    /**
+     * Get change information for a specific attribute
+     * @param attributeName - The name of the attribute to check
+     * @returns Change information including old value, new value, and whether it changed
+     */
+    getChange<V = T>(attributeName: string): AttributeChange<V>;
+    metadata: Record<string, unknown>;
+    timestamp: Date;
+}
+/**
+ * Generic hook handler function
+ */
+type HookHandler = (ctx: HookContext) => Promise<void> | void;
+/**
+ * Definition of a hook for registration
+ */
+interface HookDefinition {
+    type: HookType;
+    objectName: string;
+    /** Attribute name to watch, or '*' for all attributes */
+    attributeName?: string | "*";
+    /** Execution priority (lower = earlier), default 0 */
+    priority?: number;
+    handler: HookHandler;
+}
+
+/**
+ * Abstract interface for hook registry
+ *
+ * This interface is implemented by TriggerRegistry in schema-nestjs
+ * to provide NestJS-specific functionality like dependency injection
+ * and automatic discovery of trigger classes.
+ */
+interface HookRegistry {
+    /**
+     * Execute all hooks of a given type for an object
+     *
+     * @param type - The type of hook to execute (beforeUpdate, afterUpdate, etc.)
+     * @param objectName - The name of the object being modified
+     * @param ctx - The hook context containing record data and changes
+     */
+    execute(type: HookType, objectName: string, ctx: HookContext): Promise<void>;
+    /**
+     * Register a hook manually (optional)
+     * Not all implementations need to support this (e.g., decorator-based discovery)
+     */
+    register?(hook: HookDefinition): void;
+}
+/**
+ * No-op implementation of HookRegistry
+ *
+ * Used as default when no registry is provided to RecordService.
+ * This allows the schema package to work independently without triggers.
+ */
+declare class NoopHookRegistry implements HookRegistry {
+    execute(): Promise<void>;
+}
+
+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>;
+    views: Map<Uuid, DBView>;
+}
+/**
+ * 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>;
+}
+
+/**
+ * Geocoding service for address autocomplete and geocoding operations
+ *
+ * @example
+ * ```typescript
+ * import { GeocodingService } from "@andyoucreate/schema";
+ * import { GoogleMapsAdapter } from "./adapters/google-maps";
+ *
+ * const geocoding = new GeocodingService(new GoogleMapsAdapter({ apiKey: "..." }));
+ *
+ * const suggestions = await geocoding.autocomplete({
+ *   query: "40 Quai des Belges",
+ *   countries: ["FRA"],
+ *   limit: 5,
+ * });
+ * ```
+ */
+declare class GeocodingService {
+    private readonly adapter;
+    constructor(adapter: GeocodingAdapter);
+    /**
+     * Search for address suggestions as the user types
+     */
+    autocomplete(params: GeocodingAutocompleteParams): Promise<GeocodingSuggestion[]>;
+    /**
+     * Reverse geocode coordinates to an address
+     */
+    reverse(params: ReverseGeocodingParams): Promise<GeocodingSuggestion | null>;
+    /**
+     * Geocode a structured address to coordinates
+     */
+    geocode(params: GeocodingParams): Promise<GeocodingSuggestion | null>;
+}
+
+/**
+ * Service for global search across all object records
+ * Allows searching across all objects or a subset of objects for a tenant
+ *
+ * @example
+ * ```typescript
+ * const service = new GlobalSearchService(adapter, "tenant-123");
+ *
+ * // Search across all objects
+ * const { results, total } = await service.search("nike");
+ *
+ * // Search only in specific objects
+ * const { results, total } = await service.search("nike", {
+ *   objectNames: ["products", "orders"],
+ *   limit: 20
+ * });
+ * ```
+ */
+declare class GlobalSearchService {
+    private adapter;
+    private tenantId;
+    constructor(adapter: DatabaseAdapter, tenantId: string);
+    /**
+     * Search across all object records for the tenant
+     *
+     * @param query - Search query string
+     * @param options - Search options (pagination, object filters)
+     * @returns Matching records with object metadata and total count
+     *
+     * @example
+     * ```typescript
+     * // Basic search
+     * const { results, total } = await service.search("nike air");
+     *
+     * // With pagination
+     * const { results, total } = await service.search("nike", {
+     *   limit: 10,
+     *   offset: 20
+     * });
+     *
+     * // Filter by object types
+     * const { results, total } = await service.search("nike", {
+     *   objectNames: ["products", "orders"]
+     * });
+     * ```
+     */
+    search(query: string, options?: GlobalSearchOptions): Promise<{
+        results: GlobalSearchResultItem[];
+        total: number;
+    }>;
+    /**
+     * Search and group results by object type
+     *
+     * @param query - Search query string
+     * @param options - Search options
+     * @returns Results grouped by object name
+     */
+    searchGrouped(query: string, options?: Omit<GlobalSearchOptions, "limit" | "offset">): Promise<{
+        groups: Array<{
+            objectName: string;
+            objectLabel: string;
+            results: GlobalSearchResultItem[];
+            count: number;
+        }>;
+        total: number;
+    }>;
+}
+
+/**
+ * Input for creating a custom object
+ */
+interface CreateCustomObjectInput {
+    name: string;
+    label: string;
+    /**
+     * Template expression for computing record display labels.
+     * Example: "{{ name }}" or "{{ firstName }} {{ lastName }}"
+     */
+    labelExpression: 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
+     * @param tenantId - Tenant ID (required for relation validation)
+     * @returns Created Attribute
+     */
+    addAttributeToObject(objectId: string, attribute: AddAttributeInput, tenantId?: string): Promise<Attribute>;
+    /**
+     * Update an attribute
+     * Can only update custom attributes (system=false)
+     *
+     * @param attributeId - Attribute UUID
+     * @param updates - Partial attribute updates
+     * @param tenantId - Tenant ID (required for relation validation)
+     * @returns Updated Attribute
+     */
+    updateAttribute(attributeId: string, updates: Partial<AddAttributeInput>, tenantId?: string): 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)
+     * @deprecated Use getObjectSchemaByNameForTenant for custom objects support
+     */
+    getObjectSchemaByName(name: string): Promise<ObjectDefinition>;
+    /**
+     * Get object schema by name for a tenant (supports both native and custom objects)
+     */
+    getObjectSchemaByNameForTenant(name: string, tenantId: 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;
+    /**
+     * Validate attribute input and return parsed config
+     * Validates: name format, config schema, relation targets
+     * @internal
+     */
+    private validateAttributeInput;
+    /**
+     * Build and validate attribute config from input
+     * Uses Zod schema to validate and strip unknown properties
+     * @internal
+     */
+    private buildAttributeConfig;
+    /**
+     * Validate that relation target objects exist
+     * @internal
+     */
+    private validateRelationTargets;
+    /**
+     * Convert DB attribute to Attribute type
+     * @internal
+     */
+    private convertDBAttributeToAttribute;
+}
+
+/**
+ * Options for RecordService constructor
+ */
+interface RecordServiceOptions {
+    /**
+     * Hook registry for executing triggers before/after operations.
+     * If not provided, a no-op registry is used (no hooks executed).
+     */
+    hookRegistry?: HookRegistry;
+}
+/**
+ * Service for managing object records (CRUD operations)
+ * Handles validation, dispatch to correct table, and data consistency
+ *
+ * Supports optional hook system for triggers on attribute changes.
+ */
+declare class RecordService {
+    private adapter;
+    private tenantId;
+    private schemaService;
+    private relationService;
+    private hookRegistry;
+    constructor(adapter: DatabaseAdapter, tenantId: string, options?: RecordServiceOptions);
+    /**
+     * Compute display label from schema expression
+     * @internal
+     */
+    private computeLabel;
+    /**
+     * Create a new record with validation
+     *
+     * Triggers beforeCreate and afterCreate hooks if a HookRegistry is configured.
+     *
+     * @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;
+        /**
+         * Skip hook execution.
+         * @default false
+         */
+        skipHooks?: boolean;
+        /**
+         * Additional metadata to pass to hooks (e.g., userId, requestId).
+         */
+        hookMetadata?: Record<string, unknown>;
+    }): 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.
+     *
+     * Triggers beforeUpdate and afterUpdate hooks if a HookRegistry is configured.
+     *
+     * @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;
+        /**
+         * Skip hook execution.
+         * @default false
+         */
+        skipHooks?: boolean;
+        /**
+         * Additional metadata to pass to hooks (e.g., userId, requestId).
+         */
+        hookMetadata?: Record<string, unknown>;
+    }): Promise<ObjectRecord>;
+    /**
+     * Build hook context for update operations
+     * @internal
+     */
+    private buildHookContext;
+    /**
+     * Build hook context for create operations (no existing record)
+     * @internal
+     */
+    private buildCreateHookContext;
+    /**
+     * Build hook context for delete operations
+     * @internal
+     */
+    private buildDeleteHookContext;
+    /**
+     * Delete a record
+     *
+     * Triggers beforeDelete and afterDelete hooks if a HookRegistry is configured.
+     *
+     * @param recordId - Record UUID
+     * @param options - Delete options
+     */
+    deleteRecord(recordId: string, options?: {
+        checkSystem?: boolean;
+        /**
+         * Skip hook execution.
+         * @default false
+         */
+        skipHooks?: boolean;
+        /**
+         * Additional metadata to pass to hooks (e.g., userId, requestId).
+         */
+        hookMetadata?: Record<string, unknown>;
+    }): 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;
+    }): 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 (technical name) */
+    objectName: string;
+    /** Object label (display name) */
+    objectLabel: string;
+    /** Object icon */
+    objectIcon?: string;
+    /** Display label (computed from labelExpression) */
+    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>;
+}
+
+/**
+ * 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>;
+}
+
+/**
+ * Input for creating a custom view
+ */
+interface CreateViewInput {
+    name: string;
+    label: string;
+    objectName: string;
+    description?: string;
+    icon?: IconName;
+    tabs: Tab[];
+    default?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Input for updating a view
+ */
+interface UpdateViewInput {
+    label?: string;
+    description?: string;
+    icon?: IconName;
+    tabs?: Tab[];
+    default?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Service for managing views
+ * Handles fusion of native views (from registry) and custom views (from database)
+ */
+declare class ViewService {
+    private adapter;
+    private nativeViews;
+    constructor(adapter: DatabaseAdapter, nativeViews: typeof viewRegistry);
+    /**
+     * Get all views for an object (native + custom)
+     *
+     * @param objectName - Object name
+     * @param tenantId - Tenant ID
+     * @returns All views for the object
+     */
+    getViewsForObject(objectName: string, tenantId: string): Promise<ViewDefinition[]>;
+    /**
+     * Get a specific view by name
+     *
+     * @param objectName - Object name
+     * @param viewName - View name
+     * @param tenantId - Tenant ID
+     * @returns View definition or null
+     */
+    getView(objectName: string, viewName: string, tenantId: string): Promise<ViewDefinition | null>;
+    /**
+     * Get the default view for an object
+     *
+     * Priority:
+     * 1. Custom view marked as default
+     * 2. Native view marked as default
+     * 3. First available view
+     *
+     * @param objectName - Object name
+     * @param tenantId - Tenant ID
+     * @returns Default view or null
+     */
+    getDefaultView(objectName: string, tenantId: string): Promise<ViewDefinition | null>;
+    /**
+     * Create a custom view
+     *
+     * @param input - View definition
+     * @param tenantId - Tenant ID
+     * @returns Created view
+     */
+    createView(input: CreateViewInput, tenantId: string): Promise<ViewDefinition>;
+    /**
+     * Update a custom view
+     *
+     * @param viewId - View ID
+     * @param input - Update data
+     * @returns Updated view
+     */
+    updateView(viewId: string, input: UpdateViewInput): Promise<ViewDefinition>;
+    /**
+     * Delete a custom view
+     *
+     * @param viewId - View ID
+     */
+    deleteView(viewId: string): Promise<void>;
+    /**
+     * Set a view as default for its object
+     *
+     * @param viewId - View ID
+     * @param tenantId - Tenant ID
+     * @returns Updated view
+     */
+    setDefaultView(viewId: string, tenantId: string): Promise<ViewDefinition>;
+    /**
+     * Validate view name format (kebab-case)
+     */
+    private validateViewName;
+    /**
+     * Convert database view to ViewDefinition
+     */
+    private convertDBViewToDefinition;
+}
+
+/**
+ * Result of view sync operation
+ */
+interface ViewSyncResult {
+    success: boolean;
+    viewsSynced: number;
+    viewsCreated: number;
+    viewsUpdated: number;
+    viewsDeleted: number;
+    errors: Array<{
+        viewName: string;
+        objectName: string;
+        error: string;
+    }>;
+}
+/**
+ * Options for view sync
+ */
+interface ViewSyncOptions {
+    dryRun?: boolean;
+    verbose?: boolean;
+    tenantId?: string;
+}
+/**
+ * Sync native views from registry to database
+ *
+ * This function:
+ * 1. Reads all registered native views from the registry
+ * 2. Upserts them into the database (views table)
+ * 3. Marks them as system=true for protection
+ * 4. Removes views that were deleted from code
+ *
+ * @param adapter - Database adapter implementing DatabaseAdapter interface
+ * @param nativeViewRegistry - Registry containing native views
+ * @param options - Sync options (dryRun, verbose, tenantId)
+ * @returns Sync result with statistics
+ *
+ * @example
+ * ```typescript
+ * import { syncNativeViews, viewRegistry } from "@andyoucreate/schema";
+ * import { drizzleAdapter } from "./db/adapter";
+ *
+ * const result = await syncNativeViews(drizzleAdapter, viewRegistry, {
+ *   verbose: true,
+ *   tenantId: "default"
+ * });
+ *
+ * if (result.success) {
+ *   console.log(`✓ Synced ${result.viewsSynced} views`);
+ * }
+ * ```
+ */
+declare function syncNativeViews(adapter: DatabaseAdapter, nativeViewRegistry: typeof viewRegistry, options?: ViewSyncOptions): Promise<ViewSyncResult>;
+/**
+ * Verify that all native views are synced to database
+ *
+ * @param adapter - Database adapter
+ * @param nativeViewRegistry - Registry containing native views
+ * @returns true if all views are synced, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const isSynced = await verifyNativeViewsSync(adapter, viewRegistry);
+ * if (!isSynced) {
+ *   console.warn("Native views not synced, running sync...");
+ *   await syncNativeViews(adapter, viewRegistry);
+ * }
+ * ```
+ */
+declare function verifyNativeViewsSync(adapter: DatabaseAdapter, nativeViewRegistry: typeof viewRegistry): Promise<boolean>;
+/**
+ * Get sync preview without modifying database
+ *
+ * @param adapter - Database adapter
+ * @param nativeViewRegistry - Registry containing native views
+ * @returns Sync result (dry run)
+ */
+declare function getViewSyncPreview(adapter: DatabaseAdapter, nativeViewRegistry: typeof viewRegistry): Promise<ViewSyncResult>;
+
+/**
+ * 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>;
+/**
+ * Result of full sync operation (objects + views)
+ */
+interface FullSyncResult {
+    success: boolean;
+    objects: SyncResult;
+    views: ViewSyncResult;
+}
+/**
+ * Options for full sync
+ */
+interface FullSyncOptions extends SyncOptions, ViewSyncOptions {
+}
+/**
+ * Sync all native objects and views from registries to database
+ *
+ * This is a convenience function that:
+ * 1. Syncs native objects first (views may depend on objects)
+ * 2. Syncs native views
+ *
+ * @param adapter - Database adapter
+ * @param objectRegistry - Registry containing native objects
+ * @param nativeViewRegistry - Registry containing native views
+ * @param options - Sync options
+ * @returns Combined sync result
+ *
+ * @example
+ * ```typescript
+ * import { syncAll, registry, viewRegistry } from "@andyoucreate/schema";
+ * import { adapter } from "./db";
+ *
+ * const result = await syncAll(adapter, registry, viewRegistry, {
+ *   verbose: true,
+ *   tenantId: "default"
+ * });
+ *
+ * if (result.success) {
+ *   console.log(`✓ Synced ${result.objects.objectsSynced} objects, ${result.views.viewsSynced} views`);
+ * }
+ * ```
+ */
+declare function syncAll(adapter: DatabaseAdapter, objectRegistry: typeof registry, nativeViewRegistry: typeof viewRegistry, options?: FullSyncOptions): Promise<FullSyncResult>;
+
+/**
+ * Default fallback value when expression resolves to empty string
+ */
+declare const DEFAULT_LABEL_FALLBACK = "(Untitled)";
+/**
+ * Render a label expression template with values
+ *
+ * Supports:
+ * - Variable interpolation: `{{ fieldName }}`
+ * - Dot notation: `{{ user.firstName }}`
+ * - Pipes: `{{ name | UPPER }}`, `{{ name | capitalize | trim }}`
+ *
+ * @param template - The label expression template (e.g., "{{ firstName }} {{ lastName }}")
+ * @param values - Record values to interpolate
+ * @param fallback - Fallback value if result is empty (default: "(Untitled)")
+ * @returns The rendered label string
+ *
+ * @example
+ * ```typescript
+ * const label = renderLabelExpression(
+ *   "{{ firstName }} {{ lastName | UPPER }}",
+ *   { firstName: "John", lastName: "Doe" }
+ * );
+ * // → "John DOE"
+ *
+ * // With missing values
+ * const label = renderLabelExpression(
+ *   "{{ name }}",
+ *   { }
+ * );
+ * // → "(Untitled)"
+ * ```
+ */
+declare function renderLabelExpression(template: string, values: Record<string, unknown>, fallback?: string): string;
+/**
+ * Check if a string is a valid label expression template
+ * A valid template contains at least one {{ variable }} block with a non-empty variable
+ */
+declare function isLabelExpression(value: string): boolean;
+/**
+ * Extract attribute names referenced in a label expression
+ * Useful for validation or dependency tracking
+ *
+ * @example
+ * extractAttributeNames("{{ firstName }} {{ lastName | UPPER }}")
+ * // → ["firstName", "lastName"]
+ */
+declare function extractAttributeNames(template: string): string[];
+
+export { type MultiselectFilterOperator as $, type Attribute as A, type BaseAttribute as B, type Currency as C, type DateAttribute as D, type RelationAttribute as E, type FileAttribute as F, type Group as G, type StorageProvider as H, type FileVisibility as I, type File as J, type CreateFile as K, type Location as L, type MultiselectAttribute as M, type NumberAttribute as N, type Option as O, type Phone as P, type UpdateFile as Q, type RelationOnDelete as R, type StatusAttribute as S, type TextAttribute as T, type UserAttribute as U, type ViewDefinition as V, type TextFilterOperator as W, type NumberFilterOperator as X, type CheckboxFilterOperator as Y, type DateFilterOperator as Z, type SelectFilterOperator as _, type SelectAttribute as a, relationConfigSchema as a$, type RelationFilterOperator as a0, type FilterOperator as a1, type RelativeDateValue as a2, type CurrencyFilterValue as a3, type PhoneFilterValue as a4, type FilterValue as a5, type FilterRule as a6, type FilterCombinator as a7, type FilterState as a8, type FilterGroup as a9, type TabType as aA, type FormTab as aB, type TableTab as aC, type CustomTab as aD, isFormTab as aE, isTableTab as aF, isCustomTab as aG, type Uuid as aH, type TenantId as aI, generateId as aJ, generatePrefixedId as aK, registry as aL, viewRegistry as aM, textConfigSchema as aN, textareaConfigSchema as aO, numberConfigSchema as aP, checkboxConfigSchema as aQ, dateConfigSchema as aR, phoneConfigSchema as aS, currencyConfigSchema as aT, statusConfigSchema as aU, locationConfigSchema as aV, timestampConfigSchema as aW, selectConfigSchema as aX, multiselectConfigSchema as aY, fileConfigSchema as aZ, userConfigSchema as a_, type AdvancedFilterState as aa, isAdvancedFilterState as ab, toAdvancedFilterState as ac, toSimpleFilterState as ad, type SortDirection as ae, type SortRule as af, type QueryState as ag, OPERATORS_BY_TYPE as ah, type NoValueOperator as ai, NO_VALUE_OPERATORS as aj, isNoValueOperator as ak, type GeocodingSuggestion as al, type GeocodingAutocompleteParams as am, type ReverseGeocodingParams as an, type GeocodingParams as ao, type GeocodingAdapter as ap, NoopGeocodingAdapter as aq, type Timestamps as ar, type ObjectAttribute as as, type CompletionStatus as at, type ObjectRecord as au, type UserRole as av, type UserStatus as aw, type UserProfile as ax, type CreateUserProfile as ay, type UpdateUserProfile as az, type TextAreaAttribute as b, RelationService as b$, ratingConfigSchema as b0, attributeConfigSchemas as b1, getAttributeConfigSchema as b2, validateAttributeConfig as b3, parseAttributeConfig as b4, safeParseAttributeConfig as b5, createTextValidator as b6, createNumberValidator as b7, createCheckboxValidator as b8, createDateValidator as b9, type AttributeChange as bA, type HookContext as bB, type HookDefinition as bC, type HookHandler as bD, type HookType as bE, NoopHookRegistry as bF, type HookRegistry as bG, createMockAdapter as bH, type ObjectsRepository as bI, type AttributesRepository as bJ, type UserProfilesRepository as bK, type FilesRepository as bL, type ObjectRecordsRepository as bM, type ViewsRepository as bN, FileService as bO, GeocodingService as bP, GlobalSearchService as bQ, type CreateCustomObjectInput as bR, type AddAttributeInput as bS, ObjectSchemaService as bT, type RecordServiceOptions as bU, RecordService as bV, type RelationValidationResult as bW, type RelationValidationError as bX, type RelationOption as bY, type RelationOptionsResponse as bZ, type GetRelationOptionsParams as b_, createPhoneValidator as ba, createCurrencyValidator as bb, createStatusValidator as bc, createSelectValidator as bd, createMultiselectValidator as be, createLocationValidator as bf, createTimestampValidator as bg, createFileValidator as bh, createUserValidator as bi, createSingleRelationValidator as bj, createMultiRelationValidator as bk, createRelationValidator as bl, createRatingValidator as bm, createAttributeValidator as bn, createObjectValidator as bo, type ValidationResult as bp, validateAttribute as bq, validateObject as br, validateObjectOrThrow as bs, createDraftValidator as bt, validateDraft as bu, validateDraftOrThrow as bv, getMissingRequiredAttributes as bw, isRecordComplete as bx, computeRecordStatus as by, type DatabaseAdapter as bz, type CheckboxAttribute as c, UserProfileService as c0, type CreateViewInput as c1, type UpdateViewInput as c2, ViewService as c3, type SyncResult as c4, type SyncOptions as c5, syncNativeObjects as c6, verifyNativeObjectsSync as c7, getSyncPreview as c8, type FullSyncResult as c9, type ViewSyncOptions as cA, syncNativeViews as cB, verifyNativeViewsSync as cC, getViewSyncPreview as cD, type FullSyncOptions as ca, syncAll as cb, DEFAULT_LABEL_FALLBACK as cc, renderLabelExpression as cd, isLabelExpression as ce, extractAttributeNames as cf, type DBObject as cg, type CreateDBObject as ch, type UpdateDBObject as ci, type UpsertDBObject as cj, type DBAttribute as ck, type CreateDBAttribute as cl, type UpdateDBAttribute as cm, type UpsertDBAttribute as cn, type CreateObjectRecord as co, type ListOptions as cp, type SearchOptions as cq, type GlobalSearchOptions as cr, type GlobalSearchResultItem as cs, type FileListOptions as ct, type DBView as cu, type CreateDBView as cv, type UpdateDBView as cw, type UpsertDBView as cx, type OperationResult as cy, type ViewSyncResult as cz, 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 Field as m, type AttributeGroupField as n, type Tab as o, type AttributeType as p, type StatusGroup as q, type AttributeGroup as r, type NumberUnit as s, type DateFormat as t, type DateValue as u, type LocationGranularity as v, type DocumentType as w, type DocumentFace as x, type DocumentTypeConfig as y, type FileVerificationConfig as z };