@stndrds/schema 0.1.0-alpha.14

package/dist/runtime-B6yjtoR3.d.mts

@@ -0,0 +1,4142 @@
+import { ColorId, IconName, CountryIso3, CurrencyCode, MimeType } from '@andyoucreate/constants';
+import { z } from 'zod';
+
+/**
+ * UUID string type for all identifiers
+ */
+type Uuid = string;
+/**
+ * Tenant identifier for multi-tenant isolation
+ * Phase 1: Type defined but not yet used in interfaces
+ * Phase 2+: Will be added to ObjectRecord and services for SaaS mode
+ */
+type TenantId = string;
+/**
+ * Generate a unique UUID v4
+ * Uses crypto.randomUUID() when available (Node.js 19+, modern browsers)
+ * Falls back to a manual implementation for older environments
+ *
+ * @returns A UUID v4 string
+ *
+ * @example
+ * ```typescript
+ * const id = generateId();
+ * // "a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"
+ * ```
+ */
+declare function generateId(): Uuid;
+/**
+ * Generate a prefixed ID for better debugging and readability
+ *
+ * @param prefix - Prefix for the ID (e.g., "obj", "attr", "rec")
+ * @returns A prefixed UUID string
+ *
+ * @example
+ * ```typescript
+ * const objectId = generatePrefixedId("obj");
+ * // "obj_a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"
+ *
+ * const attrId = generatePrefixedId("attr");
+ * // "attr_a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"
+ * ```
+ */
+declare function generatePrefixedId(prefix: string): Uuid;
+
+type AttributeType = "text" | "textarea" | "number" | "checkbox" | "date" | "phone" | "currency" | "status" | "location" | "timestamp" | "select" | "multiselect" | "file" | "user" | "relation" | "rating";
+/**
+ * Status group categorization
+ */
+type StatusGroup = "idle" | "in_progress" | "finished";
+/**
+ * Unified option type for select-like fields
+ */
+interface Option {
+    id: string;
+    label: string;
+    value: string;
+    color?: ColorId;
+    icon?: IconName;
+    description?: string;
+    group?: StatusGroup;
+}
+/**
+ * Attribute grouping for UI organization
+ */
+interface AttributeGroup {
+    id: string;
+    label: string;
+    description?: string;
+    attributeIds: string[];
+    collapsible?: boolean;
+    collapsed?: boolean;
+    order?: number;
+}
+interface BaseAttribute<DefaultValueType = unknown> {
+    id: Uuid;
+    name: string;
+    label: string;
+    type: AttributeType;
+    required: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    description?: string;
+    defaultValue?: DefaultValueType;
+    icon?: IconName;
+    order?: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface TextAttribute extends BaseAttribute<string> {
+    type: "text";
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+}
+type NumberUnit = "integer" | "decimal" | "percentage";
+interface NumberAttribute extends BaseAttribute<number> {
+    type: "number";
+    min?: number;
+    max?: number;
+    unit?: NumberUnit;
+    decimals?: number;
+}
+interface CheckboxAttribute extends BaseAttribute<boolean> {
+    type: "checkbox";
+}
+type DateFormat = "short" | "long" | "full" | "relative";
+type DateValue = string | "today";
+interface DateAttribute extends BaseAttribute<string> {
+    type: "date";
+    dateFormat?: DateFormat;
+    minDate?: DateValue;
+    maxDate?: DateValue;
+}
+interface Phone {
+    countryCode: CountryIso3;
+    phoneNumber: string;
+}
+interface PhoneAttribute extends BaseAttribute<Phone> {
+    type: "phone";
+    defaultCountryCode?: CountryIso3;
+}
+interface Currency {
+    code: CurrencyCode;
+    value: number;
+}
+interface CurrencyAttribute extends BaseAttribute<Currency> {
+    type: "currency";
+    defaultCurrency?: CurrencyCode;
+    allowedCurrencies?: CurrencyCode[];
+}
+/**
+ * StatusAttribute - For workflow states with semantic grouping (idle/in_progress/finished)
+ * Use this for: Task status, Order status, Project phases, Process states
+ * Use SelectAttribute for: Categories, Types, simple choices without workflow
+ */
+interface StatusAttribute extends BaseAttribute<string> {
+    type: "status";
+    options: Option[];
+}
+interface Location {
+    address?: string;
+    address2?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: CountryIso3;
+    latitude?: number;
+    longitude?: number;
+}
+type LocationGranularity = "full" | "address" | "city" | "state" | "country" | "coordinates";
+interface LocationAttribute extends BaseAttribute<Location> {
+    type: "location";
+    granularity: LocationGranularity;
+    enableAutocomplete?: boolean;
+    enableMap?: boolean;
+    defaultCountry?: CountryIso3;
+    allowedCountries?: CountryIso3[];
+    displayFormat?: "single_line" | "multi_line" | "compact";
+}
+interface TimestampAttribute extends BaseAttribute<number> {
+    type: "timestamp";
+    autoUpdate?: boolean;
+}
+/**
+ * SelectAttribute - For simple single-choice selection
+ * Use this for: Categories, Document types, Departments, Priorities
+ * Options can be grouped (e.g., countries by continent) but no workflow logic
+ */
+interface SelectAttribute extends BaseAttribute<string> {
+    type: "select";
+    options: Option[];
+}
+interface MultiselectAttribute extends BaseAttribute<string[]> {
+    type: "multiselect";
+    options: Option[];
+}
+type DocumentType = "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+type DocumentFace = "front" | "back" | "single";
+interface DocumentTypeConfig {
+    type: DocumentType;
+    label: string;
+    faces: DocumentFace[];
+    attributeMapping?: {
+        attributeId: string;
+        extractedKey: string;
+        face?: DocumentFace;
+        required?: boolean;
+    }[];
+}
+interface FileVerificationConfig {
+    enabled: boolean;
+    documentTypes: DocumentTypeConfig[];
+    autoExtract?: boolean;
+    autoValidate?: boolean;
+}
+interface FileAttribute extends BaseAttribute<string> {
+    type: "file";
+    maxFiles?: number;
+    maxSize?: number;
+    allowedTypes?: MimeType[] | readonly MimeType[];
+    verification?: FileVerificationConfig;
+}
+interface UserAttribute extends BaseAttribute<string> {
+    type: "user";
+    allowedRoles?: string[];
+}
+/**
+ * Target object for a relation - defines which objects can be linked
+ */
+interface RelationTarget {
+    /** Object name (e.g., "companies", "contacts") */
+    object: string;
+    /**
+     * Display template for the label using mustache-like syntax
+     * @example "{name}" or "{firstName} {lastName} — {email}"
+     */
+    displayTemplate?: string;
+    /**
+     * Optional filter to restrict available records
+     * @example { status: "active" }
+     */
+    filter?: Record<string, unknown>;
+}
+/**
+ * Strategy when a target record is deleted
+ * - "restrict": Prevent deletion if relations exist (default)
+ * - "cascade": Delete this record too
+ * - "set_null": Set the relation value to null
+ */
+type RelationOnDelete = "restrict" | "cascade" | "set_null";
+/**
+ * Base properties shared by both single and multi relation attributes
+ */
+interface RelationAttributeBase extends Omit<BaseAttribute<unknown>, "defaultValue"> {
+    type: "relation";
+    /** Target objects that can be linked */
+    targets: RelationTarget[];
+    /** Deletion strategy when target record is deleted */
+    onDelete?: RelationOnDelete;
+}
+/**
+ * Single relation attribute (one-to-one or many-to-one)
+ * Stores a single record ID or null
+ */
+interface SingleRelationAttribute extends RelationAttributeBase {
+    cardinality: "one";
+    defaultValue?: string | null;
+}
+/**
+ * Multi relation attribute (one-to-many or many-to-many)
+ * Stores an array of record IDs
+ */
+interface MultiRelationAttribute extends RelationAttributeBase {
+    cardinality: "many";
+    defaultValue?: string[];
+    /** Minimum number of relations required */
+    minItems?: number;
+    /** Maximum number of relations allowed */
+    maxItems?: number;
+}
+/**
+ * RelationAttribute links to other objects/records
+ * Discriminated union by cardinality for type-safe value handling
+ *
+ * @example Single relation (many-to-one)
+ * ```typescript
+ * relation({ name: "company", label: "Company" })
+ *   .to("companies")
+ *   .required()
+ * // → Value: "rec-uuid-123" | null
+ * ```
+ *
+ * @example Multi relation (many-to-many)
+ * ```typescript
+ * relation({ name: "contacts", label: "Contacts" })
+ *   .to("contacts", { displayTemplate: "{firstName} {lastName}" })
+ *   .many()
+ *   .maxItems(5)
+ * // → Value: ["rec-1", "rec-2", ...]
+ * ```
+ *
+ * @example Polymorphic relation (multiple target objects)
+ * ```typescript
+ * relation({ name: "linked", label: "Linked Items" })
+ *   .to("companies")
+ *   .to("contacts")
+ *   .to("deals")
+ *   .many()
+ * // → Can link to records from any of these objects
+ * ```
+ */
+type RelationAttribute = SingleRelationAttribute | MultiRelationAttribute;
+interface TextAreaAttribute extends BaseAttribute<string> {
+    type: "textarea";
+}
+interface RatingAttribute extends BaseAttribute<number> {
+    type: "rating";
+    max?: number;
+    iconType?: "star" | "heart" | "thumbs" | "number";
+}
+type Attribute = TextAttribute | TextAreaAttribute | NumberAttribute | CheckboxAttribute | DateAttribute | PhoneAttribute | CurrencyAttribute | StatusAttribute | LocationAttribute | TimestampAttribute | SelectAttribute | MultiselectAttribute | FileAttribute | UserAttribute | RelationAttribute | RatingAttribute;
+
+/**
+ * Timestamps for tracking creation and updates
+ */
+interface Timestamps {
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Object definition - Represents a database table/entity
+ */
+interface ObjectDefinition {
+    id?: Uuid;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    /**
+     * 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[];
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Field definition within a form group
+ */
+interface Field {
+    /** Attribute name to display */
+    attribute: string;
+    /** Grid span (1-12 columns) */
+    span?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+    /** Override label for this view */
+    label?: string;
+    /** Force read-only display */
+    readOnly?: boolean;
+}
+/**
+ * Display mode for groups
+ * - "section": Display as a collapsible section with fields stacked (default)
+ * - "inline": Display as a single line with a dropdown for editing
+ */
+type GroupDisplayMode = "section" | "inline";
+/**
+ * Group of fields for organizing forms
+ */
+interface Group {
+    id: string;
+    label: string;
+    description?: string;
+    fields: Field[];
+    collapsible?: boolean;
+    collapsed?: boolean;
+    order?: number;
+    /**
+     * Display mode for the group
+     * - "section": Fields displayed in a collapsible section (default)
+     * - "inline": Fields displayed as a single composite field with dropdown
+     */
+    display?: GroupDisplayMode;
+    /**
+     * Template for the inline display value
+     * Uses {attributeName} syntax for interpolation
+     * Only used when display is "inline"
+     * @example "{billing_street}, {billing_city} {billing_postal_code}"
+     */
+    displayTemplate?: string;
+}
+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;
+    description?: string;
+    icon?: IconName;
+    labelExpression: string;
+    system: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface CreateDBObject {
+    tenantId: TenantId;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    labelExpression: string;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateDBObject {
+    label?: 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;
+    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;
+    orderBy?: string;
+    orderDirection?: "asc" | "desc";
+}
+/**
+ * Search options for full-text search
+ */
+interface SearchOptions extends ListOptions {
+    filters?: Record<string, unknown>;
+    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;
+        filters?: Record<string, unknown>;
+    }): Promise<{
+        records: ObjectRecord[];
+        total: number;
+    }>;
+    /**
+     * Validate data against object schema without saving
+     *
+     * @param objectId - Object UUID
+     * @param data - Data to validate
+     * @returns Validation result
+     */
+    validateData(objectId: string, data: Record<string, unknown>): Promise<ValidationResult>;
+    /**
+     * Compute the completion status for given data without saving.
+     * Useful for UI to show draft/complete status before submitting.
+     *
+     * @param objectId - Object UUID
+     * @param data - Data to check
+     * @returns Computed completion status
+     */
+    computeStatus(objectId: string, data: Record<string, unknown>): Promise<CompletionStatus>;
+    /**
+     * Refresh the completion status of an existing record.
+     * Useful when schema changes and you need to recompute statuses.
+     *
+     * @param recordId - Record UUID
+     * @returns Updated completion status
+     */
+    refreshRecordStatus(recordId: string): Promise<CompletionStatus>;
+}
+
+/**
+ * Result of relation validation
+ */
+interface RelationValidationResult {
+    valid: boolean;
+    errors: RelationValidationError[];
+}
+/**
+ * Individual relation validation error
+ */
+interface RelationValidationError {
+    /** Attribute name */
+    attribute: string;
+    /** Error message */
+    message: string;
+    /** Invalid record IDs */
+    invalidIds?: string[];
+}
+/**
+ * Resolved relation option
+ */
+interface RelationOption {
+    /** Record ID */
+    id: string;
+    /** Object ID */
+    objectId: string;
+    /** Object name (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 Timestamps as $, type Attribute as A, type BaseAttribute as B, type Currency as C, type DateAttribute as D, type StorageProvider as E, type FileAttribute as F, type Group as G, type FileVisibility as H, type File as I, type CreateFile as J, type UpdateFile as K, type Location as L, type MultiselectAttribute as M, type NumberAttribute as N, type Option as O, type Phone as P, type GeocodingSuggestion as Q, type RelationOnDelete as R, type StatusAttribute as S, type TextAttribute as T, type UserAttribute as U, type ViewDefinition as V, type GeocodingAutocompleteParams as W, type ReverseGeocodingParams as X, type GeocodingParams as Y, type GeocodingAdapter as Z, NoopGeocodingAdapter as _, type SelectAttribute as a, validateAttribute as a$, type ObjectAttribute as a0, type CompletionStatus as a1, type ObjectRecord as a2, type UserRole as a3, type UserStatus as a4, type UserProfile as a5, type CreateUserProfile as a6, type UpdateUserProfile as a7, type GroupDisplayMode as a8, type TabType as a9, relationConfigSchema as aA, ratingConfigSchema as aB, attributeConfigSchemas as aC, getAttributeConfigSchema as aD, validateAttributeConfig as aE, parseAttributeConfig as aF, safeParseAttributeConfig as aG, createTextValidator as aH, createNumberValidator as aI, createCheckboxValidator as aJ, createDateValidator as aK, createPhoneValidator as aL, createCurrencyValidator as aM, createStatusValidator as aN, createSelectValidator as aO, createMultiselectValidator as aP, createLocationValidator as aQ, createTimestampValidator as aR, createFileValidator as aS, createUserValidator as aT, createSingleRelationValidator as aU, createMultiRelationValidator as aV, createRelationValidator as aW, createRatingValidator as aX, createAttributeValidator as aY, createObjectValidator as aZ, type ValidationResult as a_, type FormTab as aa, type TableTab as ab, type CustomTab as ac, isFormTab as ad, isTableTab as ae, isCustomTab as af, type Uuid as ag, type TenantId as ah, generateId as ai, generatePrefixedId as aj, registry as ak, viewRegistry as al, textConfigSchema as am, textareaConfigSchema as an, numberConfigSchema as ao, checkboxConfigSchema as ap, dateConfigSchema as aq, phoneConfigSchema as ar, currencyConfigSchema as as, statusConfigSchema as at, locationConfigSchema as au, timestampConfigSchema as av, selectConfigSchema as aw, multiselectConfigSchema as ax, fileConfigSchema as ay, userConfigSchema as az, type TextAreaAttribute as b, type SearchOptions as b$, validateObject as b0, validateObjectOrThrow as b1, createDraftValidator as b2, validateDraft as b3, validateDraftOrThrow as b4, getMissingRequiredAttributes as b5, isRecordComplete as b6, computeRecordStatus as b7, type DatabaseAdapter as b8, type AttributeChange as b9, RelationService as bA, UserProfileService as bB, type CreateViewInput as bC, type UpdateViewInput as bD, ViewService as bE, type SyncResult as bF, type SyncOptions as bG, syncNativeObjects as bH, verifyNativeObjectsSync as bI, getSyncPreview as bJ, type FullSyncResult as bK, type FullSyncOptions as bL, syncAll as bM, DEFAULT_LABEL_FALLBACK as bN, renderLabelExpression as bO, isLabelExpression as bP, extractAttributeNames as bQ, type DBObject as bR, type CreateDBObject as bS, type UpdateDBObject as bT, type UpsertDBObject as bU, type DBAttribute as bV, type CreateDBAttribute as bW, type UpdateDBAttribute as bX, type UpsertDBAttribute as bY, type CreateObjectRecord as bZ, type ListOptions as b_, type HookContext as ba, type HookDefinition as bb, type HookHandler as bc, type HookType as bd, NoopHookRegistry as be, type HookRegistry as bf, createMockAdapter as bg, type ObjectsRepository as bh, type AttributesRepository as bi, type UserProfilesRepository as bj, type FilesRepository as bk, type ObjectRecordsRepository as bl, type ViewsRepository as bm, FileService as bn, GeocodingService as bo, GlobalSearchService as bp, type CreateCustomObjectInput as bq, type AddAttributeInput as br, ObjectSchemaService as bs, type RecordServiceOptions as bt, RecordService as bu, type RelationValidationResult as bv, type RelationValidationError as bw, type RelationOption as bx, type RelationOptionsResponse as by, type GetRelationOptionsParams as bz, type CheckboxAttribute as c, type GlobalSearchOptions as c0, type GlobalSearchResultItem as c1, type FileListOptions as c2, type DBView as c3, type CreateDBView as c4, type UpdateDBView as c5, type UpsertDBView as c6, type OperationResult as c7, type ViewSyncResult as c8, type ViewSyncOptions as c9, syncNativeViews as ca, verifyNativeViewsSync as cb, getViewSyncPreview as cc, 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 Tab as n, type AttributeType as o, type StatusGroup as p, type AttributeGroup as q, type NumberUnit as r, type DateFormat as s, type DateValue as t, type LocationGranularity as u, type DocumentType as v, type DocumentFace as w, type DocumentTypeConfig as x, type FileVerificationConfig as y, type RelationAttribute as z };