@stndrds/schema 0.1.0-alpha.14

package/dist/runtime-Cp-B26Nj.d.mts

@@ -0,0 +1,2890 @@
+import { ColorId, IconName, CountryIso3, CurrencyCode, MimeType } from '@andyoucreate/constants';
+import { z } from 'zod';
+
+/**
+ * UUID string type for all identifiers
+ */
+type Uuid = string;
+/**
+ * Tenant identifier for multi-tenant isolation
+ * Phase 1: Type defined but not yet used in interfaces
+ * Phase 2+: Will be added to ObjectRecord and services for SaaS mode
+ */
+type TenantId = string;
+/**
+ * Generate a unique UUID v4
+ * Uses crypto.randomUUID() when available (Node.js 19+, modern browsers)
+ * Falls back to a manual implementation for older environments
+ *
+ * @returns A UUID v4 string
+ *
+ * @example
+ * ```typescript
+ * const id = generateId();
+ * // "a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"
+ * ```
+ */
+declare function generateId(): Uuid;
+/**
+ * Generate a prefixed ID for better debugging and readability
+ *
+ * @param prefix - Prefix for the ID (e.g., "obj", "attr", "rec")
+ * @returns A prefixed UUID string
+ *
+ * @example
+ * ```typescript
+ * const objectId = generatePrefixedId("obj");
+ * // "obj_a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"
+ *
+ * const attrId = generatePrefixedId("attr");
+ * // "attr_a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"
+ * ```
+ */
+declare function generatePrefixedId(prefix: string): Uuid;
+
+type AttributeType = "text" | "textarea" | "number" | "checkbox" | "date" | "phone" | "currency" | "status" | "location" | "timestamp" | "select" | "multiselect" | "file" | "user" | "relation" | "rating";
+/**
+ * Status group categorization
+ */
+type StatusGroup = "idle" | "in_progress" | "finished";
+/**
+ * Unified option type for select-like fields
+ */
+interface Option {
+    id: string;
+    label: string;
+    value: string;
+    color?: ColorId;
+    icon?: IconName;
+    description?: string;
+    group?: StatusGroup;
+}
+/**
+ * Attribute grouping for UI organization
+ */
+interface AttributeGroup {
+    id: string;
+    label: string;
+    description?: string;
+    attributeIds: string[];
+    collapsible?: boolean;
+    collapsed?: boolean;
+    order?: number;
+}
+interface BaseAttribute<DefaultValueType = unknown> {
+    id: Uuid;
+    name: string;
+    label: string;
+    type: AttributeType;
+    required: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    description?: string;
+    defaultValue?: DefaultValueType;
+    icon?: IconName;
+    order?: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface TextAttribute extends BaseAttribute<string> {
+    type: "text";
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+}
+type NumberUnit = "integer" | "decimal" | "percentage";
+interface NumberAttribute extends BaseAttribute<number> {
+    type: "number";
+    min?: number;
+    max?: number;
+    unit?: NumberUnit;
+    decimals?: number;
+}
+interface CheckboxAttribute extends BaseAttribute<boolean> {
+    type: "checkbox";
+}
+type DateFormat = "short" | "long" | "full" | "relative";
+type DateValue = string | "today";
+interface DateAttribute extends BaseAttribute<string> {
+    type: "date";
+    dateFormat?: DateFormat;
+    minDate?: DateValue;
+    maxDate?: DateValue;
+}
+interface Phone {
+    countryCode: CountryIso3;
+    phoneNumber: string;
+}
+interface PhoneAttribute extends BaseAttribute<Phone> {
+    type: "phone";
+    defaultCountryCode?: CountryIso3;
+}
+interface Currency {
+    code: CurrencyCode;
+    value: number;
+}
+interface CurrencyAttribute extends BaseAttribute<Currency> {
+    type: "currency";
+    defaultCurrency?: CurrencyCode;
+    allowedCurrencies?: CurrencyCode[];
+}
+/**
+ * StatusAttribute - For workflow states with semantic grouping (idle/in_progress/finished)
+ * Use this for: Task status, Order status, Project phases, Process states
+ * Use SelectAttribute for: Categories, Types, simple choices without workflow
+ */
+interface StatusAttribute extends BaseAttribute<string> {
+    type: "status";
+    options: Option[];
+}
+interface Location {
+    address?: string;
+    address2?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: CountryIso3;
+    latitude?: number;
+    longitude?: number;
+}
+type LocationGranularity = "full" | "address" | "city" | "state" | "country" | "coordinates";
+interface LocationAttribute extends BaseAttribute<Location> {
+    type: "location";
+    granularity: LocationGranularity;
+    enableAutocomplete?: boolean;
+    enableMap?: boolean;
+    defaultCountry?: CountryIso3;
+    allowedCountries?: CountryIso3[];
+    displayFormat?: "single_line" | "multi_line" | "compact";
+}
+interface TimestampAttribute extends BaseAttribute<number> {
+    type: "timestamp";
+    autoUpdate?: boolean;
+}
+/**
+ * SelectAttribute - For simple single-choice selection
+ * Use this for: Categories, Document types, Departments, Priorities
+ * Options can be grouped (e.g., countries by continent) but no workflow logic
+ */
+interface SelectAttribute extends BaseAttribute<string> {
+    type: "select";
+    options: Option[];
+}
+interface MultiselectAttribute extends BaseAttribute<string[]> {
+    type: "multiselect";
+    options: Option[];
+}
+type DocumentType = "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+type DocumentFace = "front" | "back" | "single";
+interface DocumentTypeConfig {
+    type: DocumentType;
+    label: string;
+    faces: DocumentFace[];
+    attributeMapping?: {
+        attributeId: string;
+        extractedKey: string;
+        face?: DocumentFace;
+        required?: boolean;
+    }[];
+}
+interface FileVerificationConfig {
+    enabled: boolean;
+    documentTypes: DocumentTypeConfig[];
+    autoExtract?: boolean;
+    autoValidate?: boolean;
+}
+interface FileAttribute extends BaseAttribute<string> {
+    type: "file";
+    maxFiles?: number;
+    maxSize?: number;
+    allowedTypes?: MimeType[] | readonly MimeType[];
+    verification?: FileVerificationConfig;
+}
+interface UserAttribute extends BaseAttribute<string> {
+    type: "user";
+    allowedRoles?: string[];
+}
+/**
+ * Target object for a relation - defines which objects can be linked
+ */
+interface RelationTarget {
+    /** Object name (e.g., "companies", "contacts") */
+    object: string;
+    /**
+     * Display template for the label using mustache-like syntax
+     * @example "{name}" or "{firstName} {lastName} — {email}"
+     */
+    displayTemplate?: string;
+    /**
+     * Optional filter to restrict available records
+     * @example { status: "active" }
+     */
+    filter?: Record<string, unknown>;
+}
+/**
+ * Strategy when a target record is deleted
+ * - "restrict": Prevent deletion if relations exist (default)
+ * - "cascade": Delete this record too
+ * - "set_null": Set the relation value to null
+ */
+type RelationOnDelete = "restrict" | "cascade" | "set_null";
+/**
+ * Base properties shared by both single and multi relation attributes
+ */
+interface RelationAttributeBase extends Omit<BaseAttribute<unknown>, "defaultValue"> {
+    type: "relation";
+    /** Target objects that can be linked */
+    targets: RelationTarget[];
+    /** Deletion strategy when target record is deleted */
+    onDelete?: RelationOnDelete;
+}
+/**
+ * Single relation attribute (one-to-one or many-to-one)
+ * Stores a single record ID or null
+ */
+interface SingleRelationAttribute extends RelationAttributeBase {
+    cardinality: "one";
+    defaultValue?: string | null;
+}
+/**
+ * Multi relation attribute (one-to-many or many-to-many)
+ * Stores an array of record IDs
+ */
+interface MultiRelationAttribute extends RelationAttributeBase {
+    cardinality: "many";
+    defaultValue?: string[];
+    /** Minimum number of relations required */
+    minItems?: number;
+    /** Maximum number of relations allowed */
+    maxItems?: number;
+}
+/**
+ * RelationAttribute links to other objects/records
+ * Discriminated union by cardinality for type-safe value handling
+ *
+ * @example Single relation (many-to-one)
+ * ```typescript
+ * relation({ name: "company", label: "Company" })
+ *   .to("companies")
+ *   .required()
+ * // → Value: "rec-uuid-123" | null
+ * ```
+ *
+ * @example Multi relation (many-to-many)
+ * ```typescript
+ * relation({ name: "contacts", label: "Contacts" })
+ *   .to("contacts", { displayTemplate: "{firstName} {lastName}" })
+ *   .many()
+ *   .maxItems(5)
+ * // → Value: ["rec-1", "rec-2", ...]
+ * ```
+ *
+ * @example Polymorphic relation (multiple target objects)
+ * ```typescript
+ * relation({ name: "linked", label: "Linked Items" })
+ *   .to("companies")
+ *   .to("contacts")
+ *   .to("deals")
+ *   .many()
+ * // → Can link to records from any of these objects
+ * ```
+ */
+type RelationAttribute = SingleRelationAttribute | MultiRelationAttribute;
+interface TextAreaAttribute extends BaseAttribute<string> {
+    type: "textarea";
+}
+interface RatingAttribute extends BaseAttribute<number> {
+    type: "rating";
+    max?: number;
+    iconType?: "star" | "heart" | "thumbs" | "number";
+}
+type Attribute = TextAttribute | TextAreaAttribute | NumberAttribute | CheckboxAttribute | DateAttribute | PhoneAttribute | CurrencyAttribute | StatusAttribute | LocationAttribute | TimestampAttribute | SelectAttribute | MultiselectAttribute | FileAttribute | UserAttribute | RelationAttribute | RatingAttribute;
+
+/**
+ * Timestamps for tracking creation and updates
+ */
+interface Timestamps {
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Object definition - Represents a database table/entity
+ */
+interface ObjectDefinition {
+    id?: Uuid;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    /**
+     * Name of the text attribute used as the object's title/display name.
+     * This attribute is used to represent the record in lists, relations, etc.
+     * Must reference an existing text attribute.
+     */
+    titleAttribute: string;
+    attributes: Attribute[];
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Links an attribute to an object
+ */
+interface ObjectAttribute {
+    objectId: Uuid;
+    attributeId: Uuid;
+    order?: number;
+    required?: boolean;
+}
+/**
+ * Completion status of a record based on data completeness.
+ *
+ * - `draft`: Record is missing one or more required attribute values.
+ *   Can be saved but is considered incomplete.
+ * - `complete`: All required attribute values are present and valid.
+ *   Record is ready for use.
+ *
+ * This is different from workflow status (e.g., "pending", "approved").
+ * Completion status is computed dynamically based on the object schema.
+ */
+type CompletionStatus = "draft" | "complete";
+/**
+ * Record - Instance of an Object (a row in the database)
+ */
+interface ObjectRecord extends Timestamps {
+    id: Uuid;
+    objectId: Uuid;
+    /**
+     * Completion status of the record.
+     * - `draft`: Missing required values, record is incomplete
+     * - `complete`: All required values present and valid
+     *
+     * Computed dynamically based on the object's schema.
+     */
+    completionStatus: CompletionStatus;
+    values: Record<string, unknown>;
+}
+
+/**
+ * Storage provider type
+ */
+type StorageProvider = "s3" | "gcs" | "azure" | "local" | "cloudflare-r2" | string;
+/**
+ * File visibility level
+ */
+type FileVisibility = "public" | "private" | "restricted";
+/**
+ * File - Represents uploaded file metadata and storage info
+ *
+ * ARCHITECTURE:
+ * - Fixed table (no custom attributes)
+ * - Manages file storage, permissions, and metadata
+ * - uploadedBy links to user_profiles table
+ * - Supports soft delete via deletedAt
+ *
+ * @example
+ * ```typescript
+ * const file: File = {
+ *   id: "file-123",
+ *   tenantId: "tenant-456",
+ *   name: "contract-2025.pdf",
+ *   originalName: "Contract Acme Corp 2025.pdf",
+ *   mimeType: "application/pdf",
+ *   size: 2458624,
+ *   storageProvider: "s3",
+ *   storagePath: "tenants/456/files/2025/11/contract-2025.pdf",
+ *   storageBucket: "my-app-files",
+ *   url: "https://cdn.example.com/files/file-123",
+ *   uploadedBy: "profile-789",
+ *   folderPath: "/contracts/2025",
+ *   tags: ["contract", "legal"],
+ *   visibility: "restricted",
+ *   allowedUsers: ["profile-789", "profile-456"],
+ *   createdAt: new Date(),
+ *   updatedAt: new Date(),
+ * };
+ * ```
+ */
+interface File extends Timestamps {
+    id: Uuid;
+    tenantId: Uuid;
+    /**
+     * File name (sanitized for storage)
+     */
+    name: string;
+    /**
+     * Original file name (as uploaded by user)
+     */
+    originalName: string;
+    /**
+     * MIME type (e.g., "application/pdf", "image/jpeg")
+     */
+    mimeType: MimeType | string;
+    /**
+     * File size in bytes
+     */
+    size: number;
+    /**
+     * Storage provider (s3, gcs, azure, local, etc.)
+     */
+    storageProvider: StorageProvider;
+    /**
+     * Path in the storage bucket
+     */
+    storagePath: string;
+    /**
+     * Storage bucket name (if applicable)
+     */
+    storageBucket?: string;
+    /**
+     * Public or signed URL to access the file
+     */
+    url: string;
+    /**
+     * User who uploaded the file (FK to user_profiles)
+     */
+    uploadedBy: Uuid;
+    /**
+     * Folder path for organization (e.g., "/contracts/2025")
+     */
+    folderPath?: string;
+    /**
+     * Tags for search and categorization
+     */
+    tags?: string[];
+    /**
+     * File visibility level
+     * - public: Anyone with the URL can access
+     * - private: Only uploadedBy can access
+     * - restricted: Only specific users (allowedUsers) can access
+     */
+    visibility: FileVisibility;
+    /**
+     * List of user IDs authorized to access this file (if visibility = "restricted")
+     */
+    allowedUsers?: Uuid[];
+    /**
+     * Soft delete timestamp (null = not deleted)
+     */
+    deletedAt?: Date;
+}
+/**
+ * Data required to create a new file record
+ */
+interface CreateFile {
+    tenantId: Uuid;
+    name: string;
+    originalName: string;
+    mimeType: MimeType | string;
+    size: number;
+    storageProvider: StorageProvider;
+    storagePath: string;
+    storageBucket?: string;
+    url: string;
+    uploadedBy: Uuid;
+    folderPath?: string;
+    tags?: string[];
+    visibility?: FileVisibility;
+    allowedUsers?: Uuid[];
+}
+/**
+ * Data for updating an existing file record
+ */
+interface UpdateFile {
+    name?: string;
+    folderPath?: string;
+    tags?: string[];
+    visibility?: FileVisibility;
+    allowedUsers?: Uuid[];
+}
+
+/**
+ * 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;
+}
+/**
+ * Group of fields for organizing forms
+ */
+interface Group {
+    id: string;
+    label: string;
+    description?: string;
+    fields: Field[];
+    collapsible?: boolean;
+    collapsed?: boolean;
+    order?: number;
+}
+type TabType = "form" | "table" | "custom";
+/**
+ * Base properties shared by all tab types
+ */
+interface BaseTab {
+    id: string;
+    name: string;
+    label: string;
+    icon?: IconName;
+    order?: number;
+    /** If true, tab is defined by developer (protected) */
+    system?: boolean;
+}
+/**
+ * Form tab - displays attributes organized in groups
+ */
+interface FormTab extends BaseTab {
+    type: "form";
+    groups: Group[];
+}
+/**
+ * Table tab - displays records from a relation attribute
+ */
+interface TableTab extends BaseTab {
+    type: "table";
+    /** Name of the relation attribute */
+    relation: string;
+    /** Columns to display (attribute names from target object) */
+    columns: string[];
+    /** Allow creating new records */
+    allowCreate?: boolean;
+    /** Allow inline editing */
+    allowEdit?: boolean;
+    /** Allow deleting records */
+    allowDelete?: boolean;
+    /** Default filters */
+    filters?: Record<string, unknown>;
+    /** Default sort */
+    sort?: {
+        field: string;
+        order: "asc" | "desc";
+    };
+}
+/**
+ * Custom tab - renders a developer-defined component
+ */
+interface CustomTab extends BaseTab {
+    type: "custom";
+    /** Component identifier to render */
+    component: string;
+    /** Props to pass to the component */
+    props?: Record<string, unknown>;
+}
+/**
+ * Union of all tab types
+ */
+type Tab = FormTab | TableTab | CustomTab;
+/**
+ * View definition - organizes object attributes into tabs/pages
+ *
+ * @example
+ * ```typescript
+ * const companyView: ViewDefinition = {
+ *   name: "detail",
+ *   label: "Company Detail",
+ *   object: "companies",
+ *   tabs: [
+ *     { type: "form", name: "general", label: "Info", groups: [...] },
+ *     { type: "table", name: "contacts", label: "Contacts", relation: "contacts", columns: [...] }
+ *   ],
+ *   default: true,
+ *   system: true
+ * };
+ * ```
+ */
+interface ViewDefinition {
+    id?: Uuid;
+    /** Technical name (kebab-case) */
+    name: string;
+    /** Display label */
+    label: string;
+    /** Description */
+    description?: string;
+    /** Icon */
+    icon?: IconName;
+    /** Object this view belongs to (object name) */
+    object: string;
+    /** Tabs in this view */
+    tabs: Tab[];
+    /** Default view for this object */
+    default?: boolean;
+    /** System view (defined by developer, protected) */
+    system?: boolean;
+    /** Extensible metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Check if a tab is a form tab
+ */
+declare function isFormTab(tab: Tab): tab is FormTab;
+/**
+ * Check if a tab is a table tab
+ */
+declare function isTableTab(tab: Tab): tab is TableTab;
+/**
+ * Check if a tab is a custom tab
+ */
+declare function isCustomTab(tab: Tab): tab is CustomTab;
+
+/**
+ * Registry for native objects defined in code
+ * Native objects are system objects that cannot be deleted/modified by clients
+ * They are defined by developers and synced to the database at startup
+ */
+declare class NativeObjectRegistryClass {
+    private objects;
+    /**
+     * Register one or more native objects
+     * Auto-builds if ObjectBuilder is passed instead of ObjectDefinition
+     * @param objects - Single object/builder or array of objects/builders to register
+     * @returns this (for chaining)
+     * @throws Error if object is invalid or already registered
+     *
+     * @example
+     * ```typescript
+     * // No .build() needed - registry auto-builds!
+     * const PRODUCT = object({ id: "obj-product", name: "products", label: "Product" })
+     *   .system()
+     *   .attribute(text({ id: "attr-name", name: "name", label: "Name" }));
+     *
+     * registry.register(PRODUCT);  // ← Auto-builds here
+     *
+     * // Can still explicitly .build() if you want
+     * registry.register(PRODUCT.build());
+     *
+     * // Register multiple
+     * registry.register([PRODUCT, ORDER, CUSTOMER]);
+     * ```
+     */
+    register(objects: ObjectDefinition | ObjectDefinition[] | {
+        build: () => ObjectDefinition;
+    } | Array<{
+        build: () => ObjectDefinition;
+    }>): this;
+    /**
+     * Validate and register a single object
+     * @internal
+     */
+    private validateAndRegister;
+    /**
+     * Get a native object by its name
+     * @param name - The object name
+     * @returns The object definition or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const product = registry.getByName("products");
+     * if (product) {
+     *   console.log(product.label); // "Product"
+     * }
+     * ```
+     */
+    getByName(name: string): ObjectDefinition | undefined;
+    /**
+     * Get a native object or throw if not found
+     * @param name - The object name
+     * @returns The object definition
+     * @throws Error if not found
+     */
+    getByNameOrThrow(name: string): ObjectDefinition;
+    /**
+     * Get all registered native objects
+     * @returns Array of all registered object definitions
+     */
+    getAll(): ObjectDefinition[];
+    /**
+     * Get all registered native object names
+     * @returns Array of object names
+     */
+    listNames(): string[];
+    /**
+     * Check if a native object is registered
+     * @param name - The object name
+     * @returns true if registered, false otherwise
+     */
+    has(name: string): boolean;
+    /**
+     * Get the number of registered objects
+     */
+    get size(): number;
+    /**
+     * Clear all registered objects (useful for testing)
+     * @internal
+     */
+    clear(): void;
+    /**
+     * Get registry summary for debugging
+     */
+    summary(): string;
+    /**
+     * Log registry summary to console
+     */
+    debug(): void;
+}
+/**
+ * Singleton instance of the registry
+ * Use this to register and retrieve native objects
+ *
+ * @example
+ * ```typescript
+ * import { registry } from "@andyoucreate/schema";
+ *
+ * // Register objects
+ * registry.register([PRODUCT, ORDER, CUSTOMER]);
+ *
+ * // Get object by name
+ * const product = registry.getByName("products");
+ *
+ * // List all
+ * console.log(registry.listNames()); // ["products", "orders", ...]
+ *
+ * // Debug
+ * registry.debug();
+ * ```
+ */
+declare const registry: NativeObjectRegistryClass;
+
+/**
+ * Registry for native view definitions
+ *
+ * Views registered here are considered "system" views, defined by the developer.
+ * They are protected from modification by end-users and synced to the database
+ * at application startup.
+ *
+ * @example
+ * ```typescript
+ * import { view, group, viewRegistry } from "@andyoucreate/schema";
+ *
+ * const COMPANY_DETAIL = view("detail", "Detail")
+ *   .for("companies")
+ *   .system()
+ *   .tab("general", "Info")
+ *     .form(group("main", "Main").fields("name", "status"))
+ *   .build();
+ *
+ * viewRegistry.register(COMPANY_DETAIL);
+ * ```
+ */
+declare class ViewRegistry {
+    private views;
+    private byObject;
+    /**
+     * Register a native view
+     * @param viewOrViews - Single view or array of views
+     * @throws Error if view is not marked as system
+     * @throws Error if view with same name already exists for the object
+     */
+    register(viewOrViews: ViewDefinition | ViewDefinition[]): this;
+    private registerSingle;
+    /**
+     * Get all views for an object
+     */
+    getByObjectName(objectName: string): ViewDefinition[];
+    /**
+     * Get a specific view by object and view name
+     */
+    get(objectName: string, viewName: string): ViewDefinition | undefined;
+    /**
+     * Get a view or throw if not found
+     */
+    getOrThrow(objectName: string, viewName: string): ViewDefinition;
+    /**
+     * Get all registered views
+     */
+    getAll(): ViewDefinition[];
+    /**
+     * Check if a view exists
+     */
+    has(objectName: string, viewName: string): boolean;
+    /**
+     * Check if any views exist for an object
+     */
+    hasObject(objectName: string): boolean;
+    /**
+     * Get number of registered views
+     */
+    get size(): number;
+    /**
+     * List all object names that have views
+     */
+    listObjectNames(): string[];
+    /**
+     * Get default view for an object (if any)
+     */
+    getDefault(objectName: string): ViewDefinition | undefined;
+    /**
+     * Clear all registered views (for testing)
+     */
+    clear(): void;
+    /**
+     * Generate summary string for debugging
+     */
+    summary(): string;
+    /**
+     * Log summary to console
+     */
+    debug(): void;
+    private makeKey;
+}
+/**
+ * Global registry for native views
+ */
+declare const viewRegistry: ViewRegistry;
+
+/**
+ * Create a Zod schema for a text attribute
+ */
+declare function createTextValidator(attr: TextAttribute): z.ZodString;
+/**
+ * Create a Zod schema for a number attribute
+ */
+declare function createNumberValidator(attr: NumberAttribute): z.ZodNumber;
+/**
+ * Create a Zod schema for a checkbox attribute
+ */
+declare function createCheckboxValidator(_attr: CheckboxAttribute): z.ZodBoolean;
+/**
+ * Create a Zod schema for a date attribute
+ */
+declare function createDateValidator(attr: DateAttribute): z.ZodString;
+/**
+ * Create a Zod schema for a phone attribute
+ */
+declare function createPhoneValidator(_attr: PhoneAttribute): z.ZodType<{
+    countryCode: string;
+    phoneNumber: string;
+}>;
+/**
+ * Create a Zod schema for a currency attribute
+ */
+declare function createCurrencyValidator(_attr: CurrencyAttribute): z.ZodType<{
+    code: string;
+    value: number;
+}>;
+/**
+ * Create a Zod schema for a status attribute
+ */
+declare function createStatusValidator(attr: StatusAttribute): z.ZodEnum<[string, ...string[]]>;
+/**
+ * Create a Zod schema for a select attribute
+ */
+declare function createSelectValidator(attr: SelectAttribute): z.ZodEnum<[string, ...string[]]>;
+/**
+ * Create a Zod schema for a multiselect attribute
+ */
+declare function createMultiselectValidator(attr: MultiselectAttribute): z.ZodArray<z.ZodEnum<[string, ...string[]]>>;
+/**
+ * Create a Zod schema for a location attribute
+ */
+type LocationShape = {
+    address?: string;
+    address2?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    latitude?: number;
+    longitude?: number;
+};
+declare function createLocationValidator(_attr: LocationAttribute): z.ZodType<LocationShape>;
+/**
+ * Create a Zod schema for a timestamp attribute
+ */
+declare function createTimestampValidator(_attr: TimestampAttribute): z.ZodNumber;
+/**
+ * Create a Zod schema for a file attribute
+ */
+declare function createFileValidator(_attr: FileAttribute): z.ZodString;
+/**
+ * Create a Zod schema for a user attribute
+ */
+declare function createUserValidator(_attr: UserAttribute): z.ZodString;
+/**
+ * Create a Zod schema for a single relation attribute (cardinality: "one")
+ */
+declare function createSingleRelationValidator(attr: SingleRelationAttribute): z.ZodUnion<[z.ZodString, z.ZodNull]>;
+/**
+ * Create a Zod schema for a multi relation attribute (cardinality: "many")
+ */
+declare function createMultiRelationValidator(attr: MultiRelationAttribute): z.ZodArray<z.ZodString>;
+/**
+ * Create a Zod schema for a relation attribute
+ * Dispatches to single or multi validator based on cardinality
+ */
+declare function createRelationValidator(attr: RelationAttribute): z.ZodUnion<[z.ZodString, z.ZodNull]> | z.ZodArray<z.ZodString>;
+/**
+ * Create a Zod schema for a rating attribute
+ */
+declare function createRatingValidator(attr: RatingAttribute): z.ZodNumber;
+/**
+ * Create a Zod schema for any attribute type
+ */
+declare function createAttributeValidator(attr: Attribute): z.ZodTypeAny;
+/**
+ * Create a Zod schema for an entire object
+ */
+declare function createObjectValidator(objectDef: ObjectDefinition): z.ZodType<Record<string, unknown>>;
+/**
+ * Validation result
+ */
+interface ValidationResult {
+    success: boolean;
+    data?: Record<string, unknown>;
+    errors?: Array<{
+        path: string[];
+        message: string;
+    }>;
+}
+/**
+ * Validate data against an attribute schema
+ */
+declare function validateAttribute(attr: Attribute, value: unknown): ValidationResult;
+/**
+ * Validate data against an object schema
+ */
+declare function validateObject(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
+/**
+ * Validate and throw if invalid
+ */
+declare function validateObjectOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Create a Zod schema for draft validation.
+ * All attributes become optional, but provided values are still validated.
+ */
+declare function createDraftValidator(objectDef: ObjectDefinition): z.ZodType<Record<string, unknown>>;
+/**
+ * Validate data in draft mode.
+ * - All attributes are treated as optional (no required validation)
+ * - Provided values are still validated for format/type correctness
+ *
+ * Use this when creating records that may be incomplete (drafts).
+ *
+ * @example
+ * ```typescript
+ * const result = validateDraft(PRODUCT, { name: "Draft" });
+ * // → success even if "price" is required but missing
+ *
+ * const result2 = validateDraft(PRODUCT, { price: -10 });
+ * // → fails because price must be >= 0 (format validation still applies)
+ * ```
+ */
+declare function validateDraft(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
+/**
+ * Validate draft data and throw if format validation fails.
+ */
+declare function validateDraftOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Get the list of required attributes that are missing values.
+ *
+ * @example
+ * ```typescript
+ * const missing = getMissingRequiredAttributes(PRODUCT, { name: "Test" });
+ * // → [priceAttribute, statusAttribute] if price and status are required but missing
+ * ```
+ */
+declare function getMissingRequiredAttributes(objectDef: ObjectDefinition, data: Record<string, unknown>): Attribute[];
+/**
+ * Check if a record is complete (all required attributes have valid values).
+ *
+ * @returns `true` if all required values are present and valid, `false` otherwise
+ */
+declare function isRecordComplete(objectDef: ObjectDefinition, data: Record<string, unknown>): boolean;
+/**
+ * Compute the completion status of a record based on its data.
+ *
+ * - `"complete"`: All required values are present and valid
+ * - `"draft"`: One or more required values are missing or invalid
+ *
+ * This function is used to dynamically determine the status when
+ * creating or updating records.
+ *
+ * @example
+ * ```typescript
+ * const status = computeRecordStatus(PRODUCT, {
+ *   name: "Nike Air Max",
+ *   price: 129.99,
+ *   status: "active"
+ * });
+ * // → "complete"
+ *
+ * const status2 = computeRecordStatus(PRODUCT, { name: "Draft Product" });
+ * // → "draft" (missing required fields)
+ * ```
+ */
+declare function computeRecordStatus(objectDef: ObjectDefinition, data: Record<string, unknown>): CompletionStatus;
+
+/**
+ * Object as stored in database (metadata)
+ */
+interface DBObject extends Timestamps {
+    id: Uuid;
+    tenantId: TenantId;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    system: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface CreateDBObject {
+    tenantId: TenantId;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateDBObject {
+    label?: string;
+    description?: string;
+    icon?: IconName;
+    metadata?: Record<string, unknown>;
+}
+interface UpsertDBObject extends CreateDBObject {
+    system: boolean;
+}
+/**
+ * Attribute as stored in database (metadata)
+ */
+interface DBAttribute extends Timestamps {
+    id: Uuid;
+    objectId: Uuid;
+    name: string;
+    label: string;
+    type: AttributeType;
+    description?: string;
+    icon?: IconName;
+    system: boolean;
+    required: boolean;
+    unique: boolean;
+    order: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    defaultValue?: unknown;
+    config: Record<string, unknown>;
+}
+interface CreateDBAttribute {
+    objectId: Uuid;
+    name: string;
+    label: string;
+    type: AttributeType;
+    description?: string;
+    icon?: IconName;
+    system?: boolean;
+    required?: boolean;
+    unique?: boolean;
+    order?: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    defaultValue?: unknown;
+    config?: Record<string, unknown>;
+}
+interface UpdateDBAttribute {
+    label?: string;
+    description?: string;
+    icon?: IconName;
+    required?: boolean;
+    order?: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    defaultValue?: unknown;
+    config?: Record<string, unknown>;
+}
+interface UpsertDBAttribute extends CreateDBAttribute {
+    objectId: Uuid;
+    name: string;
+}
+
+/**
+ * Object record creation data
+ */
+interface CreateObjectRecord {
+    tenantId: TenantId;
+    objectId: Uuid;
+    data: Record<string, unknown>;
+    /**
+     * Completion status of the record.
+     * - `draft`: Record is incomplete (missing required values)
+     * - `complete`: All required values are present and valid
+     */
+    completionStatus: "draft" | "complete";
+}
+/**
+ * Generic list options for pagination and sorting
+ */
+interface ListOptions {
+    limit?: number;
+    offset?: number;
+    orderBy?: string;
+    orderDirection?: "asc" | "desc";
+}
+/**
+ * Search options for full-text search
+ */
+interface SearchOptions extends ListOptions {
+    filters?: Record<string, unknown>;
+    highlight?: boolean;
+}
+/**
+ * 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;
+    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>;
+}
+
+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;
+    description?: string;
+    icon?: IconName;
+    attributes?: (Attribute | {
+        build: () => Attribute;
+    })[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Input for adding an attribute to an object
+ */
+interface AddAttributeInput {
+    name: string;
+    label: string;
+    type: AttributeType;
+    required?: boolean;
+    unique?: boolean;
+    description?: string;
+    placeholder?: string;
+    icon?: IconName;
+    defaultValue?: unknown;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Service for managing object schemas
+ * Handles fusion of native objects (from registry) and custom objects (from database)
+ */
+declare class ObjectSchemaService {
+    private adapter;
+    private nativeRegistry;
+    constructor(adapter: DatabaseAdapter, nativeRegistry: typeof registry);
+    /**
+     * Create a new custom object
+     * Validates name format and ensures system=false
+     *
+     * @param definition - Object definition (attributes can be raw definitions or builders)
+     * @param tenantId - Tenant ID owning the object
+     * @returns Created ObjectDefinition
+     */
+    createCustomObject(definition: CreateCustomObjectInput, tenantId: string): Promise<ObjectDefinition>;
+    /**
+     * Add a custom attribute to an existing object
+     * Can be used on both custom and native objects
+     * Attributes added via API are always custom (system=false)
+     *
+     * @param objectId - Object UUID from database
+     * @param attribute - Attribute definition
+     * @returns Created Attribute
+     */
+    addAttributeToObject(objectId: string, attribute: AddAttributeInput): Promise<Attribute>;
+    /**
+     * Update an attribute
+     * Can only update custom attributes (system=false)
+     *
+     * @param attributeId - Attribute UUID
+     * @param updates - Partial attribute updates
+     * @returns Updated Attribute
+     */
+    updateAttribute(attributeId: string, updates: Partial<AddAttributeInput>): Promise<Attribute>;
+    /**
+     * Delete an attribute
+     * Can only delete custom attributes (system=false)
+     *
+     * @param attributeId - Attribute UUID
+     */
+    deleteAttribute(attributeId: string): Promise<void>;
+    /**
+     * List attributes for an object
+     *
+     * @param objectId - Object UUID
+     * @param options - Filter options
+     * @returns List of attributes
+     */
+    listAttributes(objectId: string, options?: {
+        systemOnly?: boolean;
+        customOnly?: boolean;
+    }): Promise<Attribute[]>;
+    /**
+     * Validate attribute name format (variable identifier)
+     * @internal
+     */
+    private validateAttributeName;
+    /**
+     * Get complete object schema (system + custom attributes)
+     * If object is native, merges registry definition with DB custom attributes
+     * If object is custom, returns DB definition only
+     *
+     * @param objectId - Object UUID from database
+     * @returns Complete ObjectDefinition with all attributes
+     *
+     * @example
+     * ```typescript
+     * const service = new ObjectSchemaService(adapter, registry);
+     * const productSchema = await service.getObjectSchema("obj-123");
+     *
+     * console.log(productSchema.attributes); // System + custom attributes
+     * ```
+     */
+    getObjectSchema(objectId: string): Promise<ObjectDefinition>;
+    /**
+     * Get object schema by name (for system/native objects)
+     * @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;
+    /**
+     * Convert DB attribute to Attribute type
+     * @internal
+     */
+    private convertDBAttributeToAttribute;
+}
+
+/**
+ * Service for managing object records (CRUD operations)
+ * Handles validation, dispatch to correct table, and data consistency
+ */
+declare class RecordService {
+    private adapter;
+    private tenantId;
+    private schemaService;
+    private relationService;
+    constructor(adapter: DatabaseAdapter, tenantId: string);
+    /**
+     * Create a new record with validation
+     *
+     * @param objectId - Object UUID
+     * @param data - Record data (attribute values)
+     * @param options - Creation options
+     * @returns Created record with computed completionStatus
+     *
+     * @example
+     * ```typescript
+     * const service = new RecordService(adapter, "tenant-123");
+     *
+     * // Create a complete record (strict validation)
+     * const product = await service.createRecord("obj-product", {
+     *   name: "Nike Air Max",
+     *   price: 129.99,
+     *   status: "active"
+     * });
+     * // → product.completionStatus = "complete"
+     *
+     * // Create a draft record (allows missing required fields)
+     * const draft = await service.createRecord("obj-product", {
+     *   name: "Draft Product"
+     * }, { allowDraft: true });
+     * // → draft.completionStatus = "draft"
+     * ```
+     */
+    createRecord(objectId: string, data: Record<string, unknown>, options?: {
+        /**
+         * Allow creating records with missing required fields.
+         * Format validation still applies to provided values.
+         * @default false
+         */
+        allowDraft?: boolean;
+        /**
+         * Skip all validation (format + relations).
+         * @default true
+         */
+        validate?: boolean;
+        /**
+         * Skip relation validation only.
+         * Useful for bulk imports where relations are validated separately.
+         * @default false
+         */
+        skipRelationValidation?: boolean;
+        skipSystemCheck?: boolean;
+    }): Promise<ObjectRecord>;
+    /**
+     * Get a record by ID
+     *
+     * @param recordId - Record UUID
+     * @param options - Query options
+     * @returns Record or null if not found
+     */
+    getRecord(recordId: string, options?: {
+        includeSchema?: boolean;
+    }): Promise<ObjectRecord | null>;
+    /**
+     * Get a record by ID or throw if not found
+     */
+    getRecordOrThrow(recordId: string): Promise<ObjectRecord>;
+    /**
+     * Update a record with validation
+     *
+     * The completion status is automatically recalculated after each update.
+     * A draft record becomes complete when all required fields are filled.
+     *
+     * @param recordId - Record UUID
+     * @param data - Partial data to update
+     * @param options - Update options
+     * @returns Updated record with recalculated completionStatus
+     *
+     * @example
+     * ```typescript
+     * // Update a draft record to make it complete
+     * const updated = await service.updateRecord(draftId, {
+     *   price: 99.99,
+     *   status: "active"
+     * });
+     * // → updated.completionStatus = "complete" if all required fields now present
+     * ```
+     */
+    updateRecord(recordId: string, data: Partial<Record<string, unknown>>, options?: {
+        /**
+         * Skip validation entirely (format + relations).
+         * @default true
+         */
+        validate?: boolean;
+        /**
+         * Allow partial updates without strict validation.
+         * Format validation still applies to provided values.
+         * @default false
+         */
+        partial?: boolean;
+        /**
+         * Skip relation validation only.
+         * @default false
+         */
+        skipRelationValidation?: boolean;
+    }): Promise<ObjectRecord>;
+    /**
+     * Delete a record
+     *
+     * @param recordId - Record UUID
+     * @param options - Delete options
+     */
+    deleteRecord(recordId: string, options?: {
+        checkSystem?: boolean;
+    }): Promise<void>;
+    /**
+     * List records for an object with pagination
+     *
+     * @param objectId - Object UUID
+     * @param options - List options
+     * @returns Records and total count
+     */
+    listRecords(objectId: string, options?: {
+        limit?: number;
+        offset?: number;
+        orderBy?: string;
+        orderDirection?: "asc" | "desc";
+    }): Promise<{
+        records: ObjectRecord[];
+        total: number;
+    }>;
+    /**
+     * Search records using full-text search
+     *
+     * @param objectId - Object UUID
+     * @param query - Search query
+     * @param options - Search options
+     * @returns Matching records and total count
+     */
+    searchRecords(objectId: string, query: string, options?: {
+        limit?: number;
+        offset?: number;
+        filters?: Record<string, unknown>;
+    }): Promise<{
+        records: ObjectRecord[];
+        total: number;
+    }>;
+    /**
+     * Validate data against object schema without saving
+     *
+     * @param objectId - Object UUID
+     * @param data - Data to validate
+     * @returns Validation result
+     */
+    validateData(objectId: string, data: Record<string, unknown>): Promise<ValidationResult>;
+    /**
+     * Compute the completion status for given data without saving.
+     * Useful for UI to show draft/complete status before submitting.
+     *
+     * @param objectId - Object UUID
+     * @param data - Data to check
+     * @returns Computed completion status
+     */
+    computeStatus(objectId: string, data: Record<string, unknown>): Promise<CompletionStatus>;
+    /**
+     * Refresh the completion status of an existing record.
+     * Useful when schema changes and you need to recompute statuses.
+     *
+     * @param recordId - Record UUID
+     * @returns Updated completion status
+     */
+    refreshRecordStatus(recordId: string): Promise<CompletionStatus>;
+}
+
+/**
+ * Result of relation validation
+ */
+interface RelationValidationResult {
+    valid: boolean;
+    errors: RelationValidationError[];
+}
+/**
+ * Individual relation validation error
+ */
+interface RelationValidationError {
+    /** Attribute name */
+    attribute: string;
+    /** Error message */
+    message: string;
+    /** Invalid record IDs */
+    invalidIds?: string[];
+}
+/**
+ * Resolved relation option
+ */
+interface RelationOption {
+    /** Record ID */
+    id: string;
+    /** Object ID */
+    objectId: string;
+    /** Object name (technical name) */
+    objectName: string;
+    /** Object label (display name) */
+    objectLabel: string;
+    /** Object icon */
+    objectIcon?: string;
+    /** Display label (resolved from titleAttribute) */
+    label: string;
+    /** Additional record data */
+    data?: Record<string, unknown>;
+}
+/**
+ * Response for relation options
+ */
+interface RelationOptionsResponse {
+    options: RelationOption[];
+    hasMore: boolean;
+    total: number;
+}
+/**
+ * Parameters for fetching relation options
+ */
+interface GetRelationOptionsParams {
+    /** Search query */
+    query?: string;
+    /** Page number (1-based) */
+    page?: number;
+    /** Page size */
+    pageSize?: number;
+    /** Filter by specific target object */
+    targetObject?: string;
+}
+/**
+ * Service for validating relation attributes
+ * Ensures referenced records exist and belong to valid target objects
+ */
+declare class RelationService {
+    private adapter;
+    private schemaService;
+    constructor(adapter: DatabaseAdapter, nativeRegistry: typeof registry);
+    /**
+     * Validate all relation attributes in the data
+     *
+     * @param schema - Object schema containing attribute definitions
+     * @param data - Record data to validate
+     * @returns Validation result with errors if any
+     *
+     * @example
+     * ```typescript
+     * const result = await relationService.validateRelations(schema, {
+     *   company: "rec-123",
+     *   contacts: ["rec-456", "rec-789"]
+     * });
+     *
+     * if (!result.valid) {
+     *   console.log(result.errors);
+     *   // [{ attribute: "company", message: "Record not found", invalidIds: ["rec-123"] }]
+     * }
+     * ```
+     */
+    validateRelations(schema: ObjectDefinition, data: Record<string, unknown>): Promise<RelationValidationResult>;
+    /**
+     * Validate a single relation attribute value
+     */
+    private validateRelationAttribute;
+    /**
+     * Extract IDs from relation value based on cardinality
+     */
+    private extractIds;
+    /**
+     * Get valid object IDs from relation targets
+     */
+    private getValidObjectIds;
+    /**
+     * Validate relations and throw if invalid
+     */
+    validateRelationsOrThrow(schema: ObjectDefinition, data: Record<string, unknown>): Promise<void>;
+    /**
+     * Get available options for a relation attribute
+     * Searches across all target objects defined in the relation
+     *
+     * @param attribute - Relation attribute definition
+     * @param tenantId - Tenant ID for multi-tenant isolation
+     * @param params - Query parameters
+     *
+     * @example
+     * ```typescript
+     * const options = await relationService.getOptions(attribute, "tenant-1", {
+     *   query: "nike",
+     *   page: 1,
+     *   pageSize: 20
+     * });
+     * ```
+     */
+    getOptions(attribute: RelationAttribute, tenantId: string, params?: GetRelationOptionsParams): Promise<RelationOptionsResponse>;
+    /**
+     * Resolve record IDs to their display labels
+     * Useful for displaying current values in the UI
+     *
+     * @param ids - Record IDs to resolve
+     * @param tenantId - Tenant ID for multi-tenant isolation
+     *
+     * @example
+     * ```typescript
+     * const resolved = await relationService.resolveIds(["rec-1", "rec-2"], "tenant-1");
+     * // [{ id: "rec-1", label: "Nike Air Max", objectName: "products", ... }]
+     * ```
+     */
+    resolveIds(ids: string[], tenantId: string): Promise<RelationOption[]>;
+    /**
+     * Find a relation attribute by ID
+     */
+    findAttributeById(attributeId: string): Promise<RelationAttribute | null>;
+    /**
+     * Resolve display label from record values
+     * Uses displayTemplate if provided, otherwise falls back to titleAttribute
+     */
+    private resolveLabel;
+}
+
+/**
+ * Service for managing user profiles
+ * Handles user profile CRUD, auth provider sync, and role management
+ */
+declare class UserProfileService {
+    private adapter;
+    private tenantId;
+    constructor(adapter: DatabaseAdapter, tenantId: string);
+    /**
+     * Create a new user profile (typically after first auth)
+     *
+     * @param data - User profile creation data
+     * @returns Created user profile
+     *
+     * @example
+     * ```typescript
+     * const service = new UserProfileService(adapter, "tenant-123");
+     *
+     * // After Supabase auth
+     * const profile = await service.createProfile({
+     *   tenantId: "tenant-123",
+     *   authId: authUser.id,
+     *   email: authUser.email,
+     *   firstName: authUser.user_metadata.first_name,
+     *   lastName: authUser.user_metadata.last_name,
+     *   role: "member",
+     *   status: "active"
+     * });
+     * ```
+     */
+    createProfile(data: CreateUserProfile): Promise<UserProfile>;
+    /**
+     * Get user profile by ID
+     */
+    getProfile(profileId: string): Promise<UserProfile | null>;
+    /**
+     * Get user profile by ID or throw
+     */
+    getProfileOrThrow(profileId: string): Promise<UserProfile>;
+    /**
+     * Get user profile by auth provider ID
+     *
+     * @param authId - Auth provider user ID (Supabase, Clerk, etc.)
+     * @returns User profile or null
+     */
+    getProfileByAuthId(authId: string): Promise<UserProfile | null>;
+    /**
+     * Get or create user profile (idempotent operation)
+     * Useful for auth callbacks - ensures profile exists
+     *
+     * @param authId - Auth provider user ID
+     * @param data - Profile data to create if doesn't exist
+     * @returns Existing or newly created profile
+     *
+     * @example
+     * ```typescript
+     * // In Supabase auth callback
+     * const profile = await service.getOrCreateProfile(
+     *   authUser.id,
+     *   {
+     *     tenantId: "tenant-123",
+     *     authId: authUser.id,
+     *     email: authUser.email,
+     *     role: "member",
+     *     status: "active"
+     *   }
+     * );
+     * ```
+     */
+    getOrCreateProfile(authId: string, data: CreateUserProfile): Promise<UserProfile>;
+    /**
+     * Update user profile
+     */
+    updateProfile(profileId: string, data: UpdateUserProfile): Promise<UserProfile>;
+    /**
+     * Delete user profile
+     *
+     * @param profileId - Profile UUID
+     * @param options - Delete options
+     */
+    deleteProfile(profileId: string, options?: {
+        checkAdmin?: boolean;
+    }): Promise<void>;
+    /**
+     * List all user profiles for the tenant
+     */
+    listProfiles(options?: ListOptions): Promise<UserProfile[]>;
+    /**
+     * Update last login timestamp
+     *
+     * @param profileId - Profile UUID
+     *
+     * @example
+     * ```typescript
+     * // After successful auth
+     * await service.updateLastLogin(profile.id);
+     * ```
+     */
+    updateLastLogin(profileId: string): Promise<void>;
+    /**
+     * Change user role
+     *
+     * @param profileId - Profile UUID
+     * @param newRole - New role
+     */
+    changeRole(profileId: string, newRole: string): Promise<UserProfile>;
+    /**
+     * Change user status
+     *
+     * @param profileId - Profile UUID
+     * @param newStatus - New status
+     */
+    changeStatus(profileId: string, newStatus: "active" | "pending" | "inactive" | "suspended"): Promise<UserProfile>;
+    /**
+     * Get user by email
+     */
+    getProfileByEmail(email: string): Promise<UserProfile | null>;
+    /**
+     * Check if user has role
+     */
+    hasRole(profileId: string, role: string): Promise<boolean>;
+    /**
+     * Check if user is admin
+     */
+    isAdmin(profileId: string): Promise<boolean>;
+}
+
+/**
+ * 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>;
+
+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, ObjectSchemaService 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 TabType as a8, type FormTab as a9, createRelationValidator as aA, createRatingValidator as aB, createAttributeValidator as aC, createObjectValidator as aD, type ValidationResult as aE, validateAttribute as aF, validateObject as aG, validateObjectOrThrow as aH, createDraftValidator as aI, validateDraft as aJ, validateDraftOrThrow as aK, getMissingRequiredAttributes as aL, isRecordComplete as aM, computeRecordStatus as aN, type DatabaseAdapter as aO, createMockAdapter as aP, type ObjectsRepository as aQ, type AttributesRepository as aR, type UserProfilesRepository as aS, type FilesRepository as aT, type ObjectRecordsRepository as aU, type ViewsRepository as aV, FileService as aW, GeocodingService as aX, GlobalSearchService as aY, type CreateCustomObjectInput as aZ, type AddAttributeInput as a_, type TableTab as aa, type CustomTab as ab, isFormTab as ac, isTableTab as ad, isCustomTab as ae, type Uuid as af, type TenantId as ag, generateId as ah, generatePrefixedId as ai, registry as aj, viewRegistry as ak, createTextValidator as al, createNumberValidator as am, createCheckboxValidator as an, createDateValidator as ao, createPhoneValidator as ap, createCurrencyValidator as aq, createStatusValidator as ar, createSelectValidator as as, createMultiselectValidator as at, createLocationValidator as au, createTimestampValidator as av, createFileValidator as aw, createUserValidator as ax, createSingleRelationValidator as ay, createMultiRelationValidator as az, type TextAreaAttribute as b, RecordService as b0, type RelationValidationResult as b1, type RelationValidationError as b2, type RelationOption as b3, type RelationOptionsResponse as b4, type GetRelationOptionsParams as b5, RelationService as b6, UserProfileService as b7, type CreateViewInput as b8, type UpdateViewInput as b9, type UpsertDBView as bA, type OperationResult as bB, type ViewSyncResult as bC, type ViewSyncOptions as bD, syncNativeViews as bE, verifyNativeViewsSync as bF, getViewSyncPreview as bG, ViewService as ba, type SyncResult as bb, type SyncOptions as bc, syncNativeObjects as bd, verifyNativeObjectsSync as be, getSyncPreview as bf, type FullSyncResult as bg, type FullSyncOptions as bh, syncAll as bi, type DBObject as bj, type CreateDBObject as bk, type UpdateDBObject as bl, type UpsertDBObject as bm, type DBAttribute as bn, type CreateDBAttribute as bo, type UpdateDBAttribute as bp, type UpsertDBAttribute as bq, type CreateObjectRecord as br, type ListOptions as bs, type SearchOptions as bt, type GlobalSearchOptions as bu, type GlobalSearchResultItem as bv, type FileListOptions as bw, type DBView as bx, type CreateDBView as by, type UpdateDBView as bz, type CheckboxAttribute as c, type PhoneAttribute as d, type CurrencyAttribute as e, type LocationAttribute as f, type TimestampAttribute as g, type SingleRelationAttribute as h, type MultiRelationAttribute as i, type RelationTarget as j, type RatingAttribute as k, type ObjectDefinition as l, type 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 };