@stndrds/schema 0.1.0-alpha.14 → 0.1.0-alpha.16

package/dist/runtime-B7N-oycb.d.ts

@@ -0,0 +1,4854 @@
+import { ColorId, IconName, CountryIso3, CurrencyCode, MimeType } from '@stndrds/constants';
+import { z } from 'zod';
+
+/**
+ * UUID string type for all identifiers
+ */
+type Uuid = string;
+/**
+ * Tenant identifier for multi-tenant isolation
+ * Phase 1: Type defined but not yet used in interfaces
+ * Phase 2+: Will be added to ObjectRecord and services for SaaS mode
+ */
+type TenantId = string;
+/**
+ * Generate a unique UUID v4
+ * Uses crypto.randomUUID() when available (Node.js 19+, modern browsers)
+ * Falls back to a manual implementation for older environments
+ *
+ * @returns A UUID v4 string
+ *
+ * @example
+ * ```typescript
+ * const id = generateId();
+ * // "a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"
+ * ```
+ */
+declare function generateId(): Uuid;
+/**
+ * Generate a prefixed ID for better debugging and readability
+ *
+ * @param prefix - Prefix for the ID (e.g., "obj", "attr", "rec")
+ * @returns A prefixed UUID string
+ *
+ * @example
+ * ```typescript
+ * const objectId = generatePrefixedId("obj");
+ * // "obj_a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"
+ *
+ * const attrId = generatePrefixedId("attr");
+ * // "attr_a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"
+ * ```
+ */
+declare function generatePrefixedId(prefix: string): Uuid;
+
+type AttributeType = "text" | "textarea" | "number" | "checkbox" | "date" | "phone" | "currency" | "status" | "location" | "timestamp" | "select" | "multiselect" | "file" | "user" | "relation" | "rating";
+/**
+ * Status group categorization
+ */
+type StatusGroup = "idle" | "in_progress" | "finished";
+/**
+ * Unified option type for select-like fields
+ */
+interface Option {
+    id: string;
+    label: string;
+    value: string;
+    color?: ColorId;
+    icon?: IconName;
+    description?: string;
+    group?: StatusGroup;
+}
+/**
+ * Attribute grouping for UI organization
+ */
+interface AttributeGroup {
+    id: string;
+    label: string;
+    description?: string;
+    attributeIds: string[];
+    collapsible?: boolean;
+    collapsed?: boolean;
+    order?: number;
+}
+interface BaseAttribute<DefaultValueType = unknown> {
+    id: Uuid;
+    name: string;
+    label: string;
+    type: AttributeType;
+    required: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    description?: string;
+    defaultValue?: DefaultValueType;
+    icon?: IconName;
+    order?: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface TextAttribute extends BaseAttribute<string> {
+    type: "text";
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+}
+type NumberUnit = "integer" | "decimal" | "percentage";
+interface NumberAttribute extends BaseAttribute<number> {
+    type: "number";
+    min?: number;
+    max?: number;
+    unit?: NumberUnit;
+    decimals?: number;
+}
+interface CheckboxAttribute extends BaseAttribute<boolean> {
+    type: "checkbox";
+}
+type DateFormat = "short" | "long" | "full" | "relative";
+type DateValue = string | "today";
+interface DateAttribute extends BaseAttribute<string> {
+    type: "date";
+    dateFormat?: DateFormat;
+    minDate?: DateValue;
+    maxDate?: DateValue;
+}
+interface Phone {
+    countryCode: CountryIso3;
+    phoneNumber: string;
+}
+interface PhoneAttribute extends BaseAttribute<Phone> {
+    type: "phone";
+    defaultCountryCode?: CountryIso3;
+}
+interface Currency {
+    code: CurrencyCode;
+    value: number;
+}
+interface CurrencyAttribute extends BaseAttribute<Currency> {
+    type: "currency";
+    defaultCurrency?: CurrencyCode;
+    allowedCurrencies?: CurrencyCode[];
+}
+/**
+ * StatusAttribute - For workflow states with semantic grouping (idle/in_progress/finished)
+ * Use this for: Task status, Order status, Project phases, Process states
+ * Use SelectAttribute for: Categories, Types, simple choices without workflow
+ */
+interface StatusAttribute extends BaseAttribute<string> {
+    type: "status";
+    options: Option[];
+}
+interface Location {
+    address?: string;
+    address2?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: CountryIso3;
+    latitude?: number;
+    longitude?: number;
+}
+type LocationGranularity = "full" | "address" | "city" | "state" | "country" | "coordinates";
+interface LocationAttribute extends BaseAttribute<Location> {
+    type: "location";
+    granularity: LocationGranularity;
+    enableAutocomplete?: boolean;
+    enableMap?: boolean;
+    defaultCountry?: CountryIso3;
+    allowedCountries?: CountryIso3[];
+    displayFormat?: "single_line" | "multi_line" | "compact";
+}
+interface TimestampAttribute extends BaseAttribute<number> {
+    type: "timestamp";
+    autoUpdate?: boolean;
+}
+/**
+ * SelectAttribute - For simple single-choice selection
+ * Use this for: Categories, Document types, Departments, Priorities
+ * Options can be grouped (e.g., countries by continent) but no workflow logic
+ */
+interface SelectAttribute extends BaseAttribute<string> {
+    type: "select";
+    options: Option[];
+}
+interface MultiselectAttribute extends BaseAttribute<string[]> {
+    type: "multiselect";
+    options: Option[];
+}
+type DocumentType = "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+type DocumentFace = "front" | "back" | "single";
+interface DocumentTypeConfig {
+    type: DocumentType;
+    label: string;
+    faces: DocumentFace[];
+    attributeMapping?: {
+        attributeId: string;
+        extractedKey: string;
+        face?: DocumentFace;
+        required?: boolean;
+    }[];
+}
+interface FileVerificationConfig {
+    enabled: boolean;
+    documentTypes: DocumentTypeConfig[];
+    autoExtract?: boolean;
+    autoValidate?: boolean;
+}
+interface FileAttribute extends BaseAttribute<string> {
+    type: "file";
+    maxFiles?: number;
+    maxSize?: number;
+    allowedTypes?: MimeType[] | readonly MimeType[];
+    verification?: FileVerificationConfig;
+}
+interface UserAttribute extends BaseAttribute<string> {
+    type: "user";
+    allowedRoles?: string[];
+}
+/**
+ * Target object for a relation - defines which objects can be linked
+ */
+interface RelationTarget {
+    /** Object name (e.g., "companies", "contacts") */
+    object: string;
+    /**
+     * Display template for the label using mustache-like syntax
+     * @example "{name}" or "{firstName} {lastName} — {email}"
+     */
+    displayTemplate?: string;
+    /**
+     * Optional filter to restrict available records
+     * @example { status: "active" }
+     */
+    filter?: Record<string, unknown>;
+}
+/**
+ * Strategy when a target record is deleted
+ * - "restrict": Prevent deletion if relations exist (default)
+ * - "cascade": Delete this record too
+ * - "set_null": Set the relation value to null
+ */
+type RelationOnDelete = "restrict" | "cascade" | "set_null";
+/**
+ * Base properties shared by both single and multi relation attributes
+ */
+interface RelationAttributeBase extends Omit<BaseAttribute<unknown>, "defaultValue"> {
+    type: "relation";
+    /** Target objects that can be linked */
+    targets: RelationTarget[];
+    /** Deletion strategy when target record is deleted */
+    onDelete?: RelationOnDelete;
+}
+/**
+ * Single relation attribute (one-to-one or many-to-one)
+ * Stores a single record ID or null
+ */
+interface SingleRelationAttribute extends RelationAttributeBase {
+    cardinality: "one";
+    defaultValue?: string | null;
+}
+/**
+ * Multi relation attribute (one-to-many or many-to-many)
+ * Stores an array of record IDs
+ */
+interface MultiRelationAttribute extends RelationAttributeBase {
+    cardinality: "many";
+    defaultValue?: string[];
+    /** Minimum number of relations required */
+    minItems?: number;
+    /** Maximum number of relations allowed */
+    maxItems?: number;
+}
+/**
+ * RelationAttribute links to other objects/records
+ * Discriminated union by cardinality for type-safe value handling
+ *
+ * @example Single relation (many-to-one)
+ * ```typescript
+ * relation({ name: "company", label: "Company" })
+ *   .to("companies")
+ *   .required()
+ * // → Value: "rec-uuid-123" | null
+ * ```
+ *
+ * @example Multi relation (many-to-many)
+ * ```typescript
+ * relation({ name: "contacts", label: "Contacts" })
+ *   .to("contacts", { displayTemplate: "{firstName} {lastName}" })
+ *   .many()
+ *   .maxItems(5)
+ * // → Value: ["rec-1", "rec-2", ...]
+ * ```
+ *
+ * @example Polymorphic relation (multiple target objects)
+ * ```typescript
+ * relation({ name: "linked", label: "Linked Items" })
+ *   .to("companies")
+ *   .to("contacts")
+ *   .to("deals")
+ *   .many()
+ * // → Can link to records from any of these objects
+ * ```
+ */
+type RelationAttribute = SingleRelationAttribute | MultiRelationAttribute;
+interface TextAreaAttribute extends BaseAttribute<string> {
+    type: "textarea";
+}
+interface RatingAttribute extends BaseAttribute<number> {
+    type: "rating";
+    max?: number;
+    iconType?: "star" | "heart" | "thumbs" | "number";
+}
+type Attribute = TextAttribute | TextAreaAttribute | NumberAttribute | CheckboxAttribute | DateAttribute | PhoneAttribute | CurrencyAttribute | StatusAttribute | LocationAttribute | TimestampAttribute | SelectAttribute | MultiselectAttribute | FileAttribute | UserAttribute | RelationAttribute | RatingAttribute;
+
+/**
+ * Timestamps for tracking creation and updates
+ */
+interface Timestamps {
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Object definition - Represents a database table/entity
+ */
+interface ObjectDefinition {
+    id?: Uuid;
+    name: string;
+    label: string;
+    pluralLabel?: string;
+    description?: string;
+    icon?: IconName;
+    /**
+     * Template expression used to compute the object's display label.
+     * Supports variable interpolation and pipes for formatting.
+     *
+     * @example
+     * ```typescript
+     * // Simple attribute reference
+     * labelExpression: "{{ name }}"
+     *
+     * // Multiple attributes
+     * labelExpression: "{{ firstName }} {{ lastName }}"
+     *
+     * // With pipes for formatting
+     * labelExpression: "{{ code | UPPER }} - {{ name | capitalize }}"
+     * ```
+     *
+     * Available pipes: UPPER, LOWER, capitalize, trim
+     */
+    labelExpression: string;
+    attributes: Attribute[];
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Links an attribute to an object
+ */
+interface ObjectAttribute {
+    objectId: Uuid;
+    attributeId: Uuid;
+    order?: number;
+    required?: boolean;
+}
+/**
+ * Completion status of a record based on data completeness.
+ *
+ * - `draft`: Record is missing one or more required attribute values.
+ *   Can be saved but is considered incomplete.
+ * - `complete`: All required attribute values are present and valid.
+ *   Record is ready for use.
+ *
+ * This is different from workflow status (e.g., "pending", "approved").
+ * Completion status is computed dynamically based on the object schema.
+ */
+type CompletionStatus = "draft" | "complete";
+/**
+ * Record - Instance of an Object (a row in the database)
+ */
+interface ObjectRecord extends Timestamps {
+    id: Uuid;
+    objectId: Uuid;
+    /**
+     * Display label computed from the object's labelExpression.
+     * Computed dynamically based on record values.
+     *
+     * @example "John Doe" (from "{{ firstName }} {{ lastName }}")
+     */
+    label: string;
+    /**
+     * Completion status of the record.
+     * - `draft`: Missing required values, record is incomplete
+     * - `complete`: All required values present and valid
+     *
+     * Computed dynamically based on the object's schema.
+     */
+    completionStatus: CompletionStatus;
+    values: Record<string, unknown>;
+}
+
+/**
+ * Storage provider type
+ */
+type StorageProvider = "s3" | "gcs" | "azure" | "local" | "cloudflare-r2" | string;
+/**
+ * File visibility level
+ */
+type FileVisibility = "public" | "private" | "restricted";
+/**
+ * File - Represents uploaded file metadata and storage info
+ *
+ * ARCHITECTURE:
+ * - Fixed table (no custom attributes)
+ * - Manages file storage, permissions, and metadata
+ * - uploadedBy links to user_profiles table
+ * - Supports soft delete via deletedAt
+ *
+ * @example
+ * ```typescript
+ * const file: File = {
+ *   id: "file-123",
+ *   tenantId: "tenant-456",
+ *   name: "contract-2025.pdf",
+ *   originalName: "Contract Acme Corp 2025.pdf",
+ *   mimeType: "application/pdf",
+ *   size: 2458624,
+ *   storageProvider: "s3",
+ *   storagePath: "tenants/456/files/2025/11/contract-2025.pdf",
+ *   storageBucket: "my-app-files",
+ *   url: "https://cdn.example.com/files/file-123",
+ *   uploadedBy: "profile-789",
+ *   folderPath: "/contracts/2025",
+ *   tags: ["contract", "legal"],
+ *   visibility: "restricted",
+ *   allowedUsers: ["profile-789", "profile-456"],
+ *   createdAt: new Date(),
+ *   updatedAt: new Date(),
+ * };
+ * ```
+ */
+interface File extends Timestamps {
+    id: Uuid;
+    tenantId: Uuid;
+    /**
+     * File name (sanitized for storage)
+     */
+    name: string;
+    /**
+     * Original file name (as uploaded by user)
+     */
+    originalName: string;
+    /**
+     * MIME type (e.g., "application/pdf", "image/jpeg")
+     */
+    mimeType: MimeType | string;
+    /**
+     * File size in bytes
+     */
+    size: number;
+    /**
+     * Storage provider (s3, gcs, azure, local, etc.)
+     */
+    storageProvider: StorageProvider;
+    /**
+     * Path in the storage bucket
+     */
+    storagePath: string;
+    /**
+     * Storage bucket name (if applicable)
+     */
+    storageBucket?: string;
+    /**
+     * Public or signed URL to access the file
+     */
+    url: string;
+    /**
+     * User who uploaded the file (FK to user_profiles)
+     */
+    uploadedBy: Uuid;
+    /**
+     * Folder path for organization (e.g., "/contracts/2025")
+     */
+    folderPath?: string;
+    /**
+     * Tags for search and categorization
+     */
+    tags?: string[];
+    /**
+     * File visibility level
+     * - public: Anyone with the URL can access
+     * - private: Only uploadedBy can access
+     * - restricted: Only specific users (allowedUsers) can access
+     */
+    visibility: FileVisibility;
+    /**
+     * List of user IDs authorized to access this file (if visibility = "restricted")
+     */
+    allowedUsers?: Uuid[];
+    /**
+     * Soft delete timestamp (null = not deleted)
+     */
+    deletedAt?: Date;
+}
+/**
+ * Data required to create a new file record
+ */
+interface CreateFile {
+    tenantId: Uuid;
+    name: string;
+    originalName: string;
+    mimeType: MimeType | string;
+    size: number;
+    storageProvider: StorageProvider;
+    storagePath: string;
+    storageBucket?: string;
+    url: string;
+    uploadedBy: Uuid;
+    folderPath?: string;
+    tags?: string[];
+    visibility?: FileVisibility;
+    allowedUsers?: Uuid[];
+}
+/**
+ * Data for updating an existing file record
+ */
+interface UpdateFile {
+    name?: string;
+    folderPath?: string;
+    tags?: string[];
+    visibility?: FileVisibility;
+    allowedUsers?: Uuid[];
+}
+
+/** Operators for text-based attributes */
+type TextFilterOperator = "is" | "is_not" | "contains" | "not_contains" | "starts_with" | "ends_with" | "is_empty" | "is_not_empty";
+/** Operators for number-based attributes */
+type NumberFilterOperator = "eq" | "neq" | "lt" | "gt" | "lte" | "gte" | "is_empty" | "is_not_empty";
+/** Operators for checkbox */
+type CheckboxFilterOperator = "is_checked" | "is_not_checked";
+/** Operators for date-based attributes */
+type DateFilterOperator = "is" | "is_not" | "before" | "after" | "on_or_before" | "on_or_after" | "is_within" | "is_empty" | "is_not_empty";
+/** Operators for select-based attributes (supports single or multi-value filtering) */
+type SelectFilterOperator = "is" | "is_not" | "any_of" | "none_of" | "is_empty" | "is_not_empty";
+/** Operators for multiselect-based attributes */
+type MultiselectFilterOperator = "contains" | "not_contains" | "is_empty" | "is_not_empty";
+/** Operators for relation-based attributes (supports single or multi-value filtering) */
+type RelationFilterOperator = "any_of" | "none_of" | "contains" | "not_contains" | "is_empty" | "is_not_empty";
+/** All possible filter operators */
+type FilterOperator = TextFilterOperator | NumberFilterOperator | CheckboxFilterOperator | DateFilterOperator | SelectFilterOperator | MultiselectFilterOperator | RelationFilterOperator;
+/** Relative date value for "is_within" operator */
+interface RelativeDateValue {
+    amount: number;
+    unit: "days" | "weeks" | "months" | "years";
+    direction: "past" | "future";
+}
+/** Currency filter value with amount and optional currency codes
+ * - code: undefined or [] = any currency
+ * - code: string[] = filter by specific currencies
+ */
+interface CurrencyFilterValue {
+    value: number | null;
+    code?: string[];
+}
+/** Phone filter value with number and optional country code */
+interface PhoneFilterValue {
+    phoneNumber: string | null;
+    countryCode?: string;
+}
+/** Filter value can be various types depending on the attribute */
+type FilterValue = string | number | boolean | string[] | RelativeDateValue | CurrencyFilterValue | PhoneFilterValue | null;
+/** A single filter rule */
+interface FilterRule {
+    /** Attribute name to filter on */
+    attribute: string;
+    /** Filter operator */
+    operator: FilterOperator;
+    /** Filter value (null for operators like is_empty) */
+    value: FilterValue;
+}
+/** Combinator for filter rules */
+type FilterCombinator = "and" | "or";
+/** Complete filter state (simple mode) */
+interface FilterState {
+    /** How to combine rules */
+    combinator: FilterCombinator;
+    /** List of filter rules */
+    rules: FilterRule[];
+}
+/**
+ * A filter group containing rules (used in advanced mode)
+ * Groups can be nested up to 2 levels deep
+ */
+interface FilterGroup {
+    /** Unique identifier for this group */
+    id: string;
+    /** How to combine rules within this group */
+    combinator: FilterCombinator;
+    /** List of filter rules in this group */
+    rules: FilterRule[];
+}
+/**
+ * Advanced filter state with nested groups
+ * Structure: AdvancedFilterState -> FilterGroup[] -> FilterRule[]
+ * Maximum 2 levels of nesting
+ */
+interface AdvancedFilterState {
+    /** How to combine groups at the top level */
+    combinator: FilterCombinator;
+    /** List of filter groups */
+    groups: FilterGroup[];
+}
+/**
+ * Type guard to check if a filter state is advanced
+ */
+declare function isAdvancedFilterState(state: FilterState | AdvancedFilterState): state is AdvancedFilterState;
+/**
+ * Convert simple filter state to advanced filter state
+ */
+declare function toAdvancedFilterState(state: FilterState): AdvancedFilterState;
+/**
+ * Convert advanced filter state to simple filter state (flattens groups)
+ * Note: This loses group structure - use with caution
+ */
+declare function toSimpleFilterState(state: AdvancedFilterState): FilterState;
+/** Sort direction */
+type SortDirection = "asc" | "desc";
+/** A single sort rule */
+interface SortRule {
+    /** Attribute name to sort by */
+    attribute: string;
+    /** Sort direction */
+    direction: SortDirection;
+}
+/** Complete query state with search, filters, sorts, and pagination */
+interface QueryState {
+    /** Full-text search query */
+    search?: string;
+    /** Filter configuration (simple mode) */
+    filters?: FilterState;
+    /** Advanced filter configuration (grouped mode) */
+    advancedFilters?: AdvancedFilterState;
+    /** Sort configuration (multiple sorts supported) */
+    sorts?: SortRule[];
+    /** Pagination */
+    limit?: number;
+    offset?: number;
+}
+/** Mapping of attribute types to their valid operators */
+declare const OPERATORS_BY_TYPE: Record<AttributeType, readonly FilterOperator[]>;
+/** Check if an operator requires a value */
+type NoValueOperator = "is_empty" | "is_not_empty" | "is_checked" | "is_not_checked";
+/** Operators that don't require a value */
+declare const NO_VALUE_OPERATORS: readonly NoValueOperator[];
+/**
+ * Check if an operator requires a value
+ */
+declare function isNoValueOperator(operator: FilterOperator): operator is NoValueOperator;
+
+/**
+ * Autocomplete suggestion from geocoding service
+ */
+interface GeocodingSuggestion {
+    /** Unique identifier from the provider */
+    id: string;
+    /** Human-readable label for display */
+    label: string;
+    /** Structured location data */
+    location: Location;
+    /** Optional match score/confidence (0-1) */
+    score?: number;
+    /** Optional additional metadata from the provider */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Parameters for autocomplete search
+ */
+interface GeocodingAutocompleteParams {
+    /** Search query */
+    query: string;
+    /** Restrict results to specific countries */
+    countries?: CountryIso3[];
+    /** Preferred language for results (ISO 639-1) */
+    language?: string;
+    /** Maximum number of results */
+    limit?: number;
+    /** Bias results toward a specific location */
+    biasLocation?: {
+        latitude: number;
+        longitude: number;
+    };
+    /** Session token for billing optimization (some providers) */
+    sessionToken?: string;
+    /**
+     * Level of address detail expected
+     * Adapters can use this to filter/optimize results
+     * - "full": Full address with street, city, postal code, etc.
+     * - "address": Street address without postal code
+     * - "city": City level only
+     * - "state": State/region level only
+     * - "country": Country level only
+     * - "coordinates": Only coordinates (lat/lng)
+     */
+    granularity?: LocationGranularity;
+}
+/**
+ * Parameters for reverse geocoding
+ */
+interface ReverseGeocodingParams {
+    /** Latitude */
+    latitude: number;
+    /** Longitude */
+    longitude: number;
+    /** Preferred language for results */
+    language?: string;
+}
+/**
+ * Parameters for geocoding a structured address
+ */
+interface GeocodingParams {
+    /** Structured address components */
+    address: Partial<Location>;
+    /** Preferred language for results */
+    language?: string;
+}
+/**
+ * Abstract geocoding adapter interface
+ * Implement this interface for different geocoding providers
+ *
+ * @example Google Maps implementation
+ * ```typescript
+ * class GoogleMapsGeocodingAdapter implements GeocodingAdapter {
+ *   async autocomplete(params) {
+ *     const response = await fetch(
+ *       `https://maps.googleapis.com/maps/api/place/autocomplete/json?input=${params.query}&key=${this.apiKey}`
+ *     );
+ *     // Transform response to GeocodingSuggestion[]
+ *   }
+ * }
+ * ```
+ *
+ * @example Mapbox implementation
+ * ```typescript
+ * class MapboxGeocodingAdapter implements GeocodingAdapter {
+ *   async autocomplete(params) {
+ *     const response = await fetch(
+ *       `https://api.mapbox.com/geocoding/v5/mapbox.places/${params.query}.json?access_token=${this.token}`
+ *     );
+ *     // Transform response to GeocodingSuggestion[]
+ *   }
+ * }
+ * ```
+ */
+interface GeocodingAdapter {
+    /**
+     * Autocomplete address search
+     * Returns suggestions as the user types
+     */
+    autocomplete(params: GeocodingAutocompleteParams): Promise<GeocodingSuggestion[]>;
+    /**
+     * Reverse geocode coordinates to an address
+     * Optional - some providers may not support this
+     */
+    reverse?(params: ReverseGeocodingParams): Promise<GeocodingSuggestion | null>;
+    /**
+     * Geocode a structured address to coordinates
+     * Optional - some providers may not support this
+     */
+    geocode?(params: GeocodingParams): Promise<GeocodingSuggestion | null>;
+}
+/**
+ * No-op geocoding adapter
+ * Returns empty results when no geocoding provider is configured
+ */
+declare class NoopGeocodingAdapter implements GeocodingAdapter {
+    autocomplete(): Promise<GeocodingSuggestion[]>;
+    reverse(): Promise<null>;
+    geocode(): Promise<null>;
+}
+
+/**
+ * Scope of a permission rule.
+ * - `object`: Controls access to an entire object type (business data)
+ * - `system`: Controls access to platform resources (users, schema, roles)
+ * - `attribute`: Controls access to specific fields (Phase 2)
+ * - `record`: Controls access to specific records via filters (Phase 3)
+ */
+type PermissionScope = "object" | "system" | "attribute" | "record";
+/**
+ * Actions that can be performed on an object.
+ */
+type ObjectAction = "read" | "create" | "update" | "delete";
+/**
+ * System resources that can be managed.
+ * - `users`: User profiles and invitations
+ * - `schema`: Object definitions and attributes
+ * - `roles`: Roles and permissions
+ * - `settings`: Tenant settings and configuration
+ */
+type SystemResource = "users" | "schema" | "roles" | "settings";
+/**
+ * Actions that can be performed on system resources.
+ * Same as ObjectAction for consistency.
+ */
+type SystemAction = "read" | "create" | "update" | "delete";
+/**
+ * Role definition - Groups permissions together.
+ *
+ * Roles are tenant-scoped and can be system-defined (immutable) or custom.
+ *
+ * @example
+ * ```typescript
+ * const adminRole: Role = {
+ *   id: "role-123",
+ *   tenantId: "tenant-456",
+ *   name: "admin",
+ *   label: "Administrator",
+ *   description: "Full access to all objects",
+ *   system: true,
+ *   createdAt: new Date(),
+ *   updatedAt: new Date(),
+ * };
+ * ```
+ */
+interface Role extends Timestamps {
+    id: Uuid;
+    tenantId: Uuid;
+    /**
+     * Technical name (unique per tenant, used in code).
+     * Examples: "admin", "member", "sales_manager"
+     */
+    name: string;
+    /**
+     * Display name shown in UI.
+     */
+    label: string;
+    /**
+     * Optional description of the role's purpose.
+     */
+    description?: string;
+    /**
+     * If true, this role cannot be modified or deleted.
+     * Used for built-in roles like "admin".
+     * Follows the same naming convention as ObjectDefinition.system.
+     */
+    system: boolean;
+}
+/**
+ * Permission definition - Grants specific actions on a target.
+ *
+ * A permission belongs to a role and defines what actions are allowed
+ * on a specific target (object, attribute, or record filter).
+ *
+ * @example
+ * ```typescript
+ * // Allow read and update on companies object
+ * const permission: Permission = {
+ *   id: "perm-123",
+ *   roleId: "role-456",
+ *   scope: "object",
+ *   target: "companies",
+ *   actions: ["read", "update"],
+ *   createdAt: new Date(),
+ * };
+ *
+ * // Wildcard permission for all objects
+ * const wildcardPerm: Permission = {
+ *   id: "perm-789",
+ *   roleId: "role-456",
+ *   scope: "object",
+ *   target: "*",
+ *   actions: ["read", "create", "update", "delete"],
+ *   createdAt: new Date(),
+ * };
+ * ```
+ */
+interface Permission {
+    id: Uuid;
+    roleId: Uuid;
+    /**
+     * Scope of this permission.
+     */
+    scope: PermissionScope;
+    /**
+     * Target of the permission.
+     * - For `object` scope: object name (e.g., "companies") or "*" for all
+     * - For `system` scope: system resource (e.g., "users", "schema") or "*" for all
+     * - For `attribute` scope: "objectName.attributeName"
+     * - For `record` scope: object name (filter is in `filter` field)
+     */
+    target: string;
+    /**
+     * Actions allowed on the target.
+     * For object/system scopes: "read", "create", "update", "delete"
+     */
+    actions: ObjectAction[] | SystemAction[];
+    /**
+     * JSON filter for record-level permissions (Phase 3).
+     * Supports template variables like `{{ currentUser.id }}`.
+     */
+    filter?: Record<string, unknown>;
+    createdAt: Date;
+}
+/**
+ * Links a user profile to a role within a tenant.
+ *
+ * A user can have multiple roles, and their permissions are additive (union).
+ *
+ * Note: `userProfileId` references UserProfile.id from the user_profiles table,
+ * NOT the auth provider ID (authId). This keeps permissions tied to the
+ * application's user management, not the authentication layer.
+ */
+interface UserRoleAssignment {
+    id: Uuid;
+    /**
+     * User profile ID (UserProfile.id from user_profiles table).
+     * This links to the application's user management system,
+     * not the auth provider's user ID.
+     */
+    userProfileId: Uuid;
+    roleId: Uuid;
+    tenantId: Uuid;
+    /**
+     * When the role was assigned.
+     */
+    assignedAt: Date;
+    /**
+     * User profile ID of who assigned this role (for audit trail).
+     */
+    assignedBy?: Uuid;
+}
+/**
+ * Computed permissions for a user.
+ *
+ * This is the merged result of all roles assigned to a user.
+ * Returned by the API for permission checks.
+ */
+interface EffectivePermissions {
+    /**
+     * If true, the user has full admin access and bypasses all permission checks.
+     */
+    isAdmin: boolean;
+    /**
+     * Object-level permissions.
+     * Key is the object name, value is array of allowed actions.
+     * Special key "*" means permission applies to all objects.
+     */
+    objectPermissions: Record<string, ObjectAction[]>;
+    /**
+     * System-level permissions.
+     * Key is the system resource (users, schema, roles, settings), value is array of allowed actions.
+     * Special key "*" means permission applies to all system resources.
+     */
+    systemPermissions: Record<string, SystemAction[]>;
+}
+/**
+ * Permissions for a specific object.
+ * Convenience type for frontend use.
+ */
+interface ObjectPermissions {
+    canRead: boolean;
+    canCreate: boolean;
+    canUpdate: boolean;
+    canDelete: boolean;
+}
+/**
+ * Permissions for a specific system resource.
+ * Convenience type for frontend use.
+ */
+interface SystemPermissions {
+    canRead: boolean;
+    canCreate: boolean;
+    canUpdate: boolean;
+    canDelete: boolean;
+}
+/**
+ * Input for creating a new role.
+ */
+interface CreateRoleInput {
+    tenantId: Uuid;
+    name: string;
+    label: string;
+    description?: string;
+}
+/**
+ * Input for updating an existing role.
+ */
+interface UpdateRoleInput {
+    label?: string;
+    description?: string;
+}
+/**
+ * Input for creating a permission.
+ */
+interface CreatePermissionInput {
+    scope: PermissionScope;
+    target: string;
+    /**
+     * Actions allowed on the target.
+     * For object/system scopes: "read", "create", "update", "delete"
+     */
+    actions: ObjectAction[] | SystemAction[];
+    filter?: Record<string, unknown>;
+}
+/**
+ * Input for assigning a role to a user.
+ */
+interface AssignRoleInput {
+    /**
+     * User profile ID (UserProfile.id).
+     */
+    userProfileId: Uuid;
+    roleId: Uuid;
+    tenantId: Uuid;
+    assignedBy?: Uuid;
+}
+
+/**
+ * Simple user role for basic authorization.
+ *
+ * COEXISTENCE WITH RBAC:
+ * This simple role system coexists with the granular RBAC system (see `permissions.ts`).
+ *
+ * - **UserProfile.role**: Simple string-based role for quick access checks.
+ *   Used for high-level authorization (e.g., "is this user an admin?").
+ *   Values: "admin" | "member" | "guest" | custom strings.
+ *
+ * - **RBAC System (Role, Permission, UserRoleAssignment)**: Fine-grained permissions
+ *   for object-level access control (read/create/update/delete per object type).
+ *   Used for detailed authorization (e.g., "can this user update companies?").
+ *
+ * MIGRATION STRATEGY:
+ * 1. For simple apps: Use only `UserProfile.role` - sufficient for basic admin/member checks.
+ * 2. For complex apps: Use RBAC for granular permissions, `UserProfile.role` becomes informational.
+ * 3. The `PermissionService.getEffectivePermissions()` automatically grants admin bypass
+ *    when a user has a role named "admin" in the RBAC system.
+ *
+ * @see permissions.ts for the full RBAC implementation
+ */
+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)
+ *
+ * RELATIONSHIP WITH RBAC:
+ * - `UserProfile.id` is used as `userProfileId` in `UserRoleAssignment`
+ * - The RBAC system assigns multiple roles to a UserProfile
+ * - For simple use cases, `UserProfile.role` is sufficient
+ * - For granular permissions, use the RBAC system via `PermissionService`
+ *
+ * @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;
+    /**
+     * Simple role for basic authorization checks.
+     *
+     * Common values: "admin", "member", "guest"
+     *
+     * NOTE: For granular object-level permissions, use the RBAC system
+     * (Role, Permission, UserRoleAssignment) via PermissionService.
+     * This field is kept for backward compatibility and simple use cases.
+     *
+     * @see UserRoleAssignment for the RBAC relationship
+     */
+    role: UserRole;
+    /**
+     * Account status
+     * - active: Normal user, full access
+     * - pending: Awaiting activation/approval
+     * - inactive: Deactivated account
+     * - suspended: Temporarily blocked
+     */
+    status: UserStatus;
+    /**
+     * Last login timestamp (updated on each successful auth)
+     */
+    lastLoginAt?: Date;
+}
+/**
+ * Data required to create a new user profile
+ */
+interface CreateUserProfile {
+    tenantId: Uuid;
+    authId: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    avatarUrl?: string;
+    role?: UserRole;
+    status?: UserStatus;
+}
+/**
+ * Data for updating an existing user profile
+ */
+interface UpdateUserProfile {
+    firstName?: string;
+    lastName?: string;
+    avatarUrl?: string;
+    role?: UserRole;
+    status?: UserStatus;
+    lastLoginAt?: Date;
+}
+
+/**
+ * Inline attribute group configuration
+ * Groups multiple attributes into a single composite field with dropdown editing
+ */
+interface AttributeGroupField {
+    /** Unique identifier for the group */
+    id: string;
+    /** Display label for the composite field */
+    label: string;
+    /** Description shown in the dropdown */
+    description?: string;
+    /** Attribute names to include in this group */
+    attributes: string[];
+    /**
+     * Template for the display value
+     * Uses {attributeName} syntax for interpolation
+     * @example "{billing_street}, {billing_city} {billing_postal_code}"
+     */
+    displayTemplate?: string;
+}
+/**
+ * Field definition within a form group
+ * Can be either a single attribute or an inline attribute group
+ */
+interface Field {
+    /** Attribute name to display (for single attribute fields) */
+    attribute?: string;
+    /** Inline attribute group (groups multiple attributes into one composite field) */
+    attributeGroup?: AttributeGroupField;
+    /** Grid span (1-12 columns) */
+    span?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+    /** Override label for this view (only for single attribute fields) */
+    label?: string;
+    /** Force read-only display */
+    readOnly?: boolean;
+}
+/**
+ * Group of fields for organizing forms
+ */
+interface Group {
+    id: string;
+    label: string;
+    description?: string;
+    fields: Field[];
+    collapsible?: boolean;
+    collapsed?: boolean;
+    order?: number;
+}
+type TabType = "form" | "table" | "custom";
+/**
+ * Base properties shared by all tab types
+ */
+interface BaseTab {
+    id: string;
+    name: string;
+    label: string;
+    icon?: IconName;
+    order?: number;
+    /** If true, tab is defined by developer (protected) */
+    system?: boolean;
+}
+/**
+ * Form tab - displays attributes organized in groups
+ */
+interface FormTab extends BaseTab {
+    type: "form";
+    groups: Group[];
+}
+/**
+ * Table tab - displays records from a relation attribute
+ */
+interface TableTab extends BaseTab {
+    type: "table";
+    /** Name of the relation attribute */
+    relation: string;
+    /** Columns to display (attribute names from target object) */
+    columns: string[];
+    /** Allow creating new records */
+    allowCreate?: boolean;
+    /** Allow inline editing */
+    allowEdit?: boolean;
+    /** Allow deleting records */
+    allowDelete?: boolean;
+    /** Default filters */
+    filters?: Record<string, unknown>;
+    /** Default sort */
+    sort?: {
+        field: string;
+        order: "asc" | "desc";
+    };
+}
+/**
+ * Custom tab - renders a developer-defined component
+ */
+interface CustomTab extends BaseTab {
+    type: "custom";
+    /** Component identifier to render */
+    component: string;
+    /** Props to pass to the component */
+    props?: Record<string, unknown>;
+}
+/**
+ * Union of all tab types
+ */
+type Tab = FormTab | TableTab | CustomTab;
+/**
+ * View definition - organizes object attributes into tabs/pages
+ *
+ * @example
+ * ```typescript
+ * const companyView: ViewDefinition = {
+ *   name: "detail",
+ *   label: "Company Detail",
+ *   object: "companies",
+ *   tabs: [
+ *     { type: "form", name: "general", label: "Info", groups: [...] },
+ *     { type: "table", name: "contacts", label: "Contacts", relation: "contacts", columns: [...] }
+ *   ],
+ *   default: true,
+ *   system: true
+ * };
+ * ```
+ */
+interface ViewDefinition {
+    id?: Uuid;
+    /** Technical name (kebab-case) */
+    name: string;
+    /** Display label */
+    label: string;
+    /** Description */
+    description?: string;
+    /** Icon */
+    icon?: IconName;
+    /** Object this view belongs to (object name) */
+    object: string;
+    /** Tabs in this view */
+    tabs: Tab[];
+    /** Default view for this object */
+    default?: boolean;
+    /** System view (defined by developer, protected) */
+    system?: boolean;
+    /** Extensible metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Check if a tab is a form tab
+ */
+declare function isFormTab(tab: Tab): tab is FormTab;
+/**
+ * Check if a tab is a table tab
+ */
+declare function isTableTab(tab: Tab): tab is TableTab;
+/**
+ * Check if a tab is a custom tab
+ */
+declare function isCustomTab(tab: Tab): tab is CustomTab;
+
+/**
+ * Registry for native objects defined in code
+ * Native objects are system objects that cannot be deleted/modified by clients
+ * They are defined by developers and synced to the database at startup
+ */
+declare class NativeObjectRegistryClass {
+    private objects;
+    /**
+     * Register one or more native objects
+     * Auto-builds if ObjectBuilder is passed instead of ObjectDefinition
+     * @param objects - Single object/builder or array of objects/builders to register
+     * @returns this (for chaining)
+     * @throws Error if object is invalid or already registered
+     *
+     * @example
+     * ```typescript
+     * // No .build() needed - registry auto-builds!
+     * const PRODUCT = object({ id: "obj-product", name: "products", label: "Product" })
+     *   .system()
+     *   .attribute(text({ id: "attr-name", name: "name", label: "Name" }));
+     *
+     * registry.register(PRODUCT);  // ← Auto-builds here
+     *
+     * // Can still explicitly .build() if you want
+     * registry.register(PRODUCT.build());
+     *
+     * // Register multiple
+     * registry.register([PRODUCT, ORDER, CUSTOMER]);
+     * ```
+     */
+    register(objects: ObjectDefinition | ObjectDefinition[] | {
+        build: () => ObjectDefinition;
+    } | Array<{
+        build: () => ObjectDefinition;
+    }>): this;
+    /**
+     * Validate and register a single object
+     * @internal
+     */
+    private validateAndRegister;
+    /**
+     * Get a native object by its name
+     * @param name - The object name
+     * @returns The object definition or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const product = registry.getByName("products");
+     * if (product) {
+     *   console.log(product.label); // "Product"
+     * }
+     * ```
+     */
+    getByName(name: string): ObjectDefinition | undefined;
+    /**
+     * Get a native object or throw if not found
+     * @param name - The object name
+     * @returns The object definition
+     * @throws Error if not found
+     */
+    getByNameOrThrow(name: string): ObjectDefinition;
+    /**
+     * Get all registered native objects
+     * @returns Array of all registered object definitions
+     */
+    getAll(): ObjectDefinition[];
+    /**
+     * Get all registered native object names
+     * @returns Array of object names
+     */
+    listNames(): string[];
+    /**
+     * Check if a native object is registered
+     * @param name - The object name
+     * @returns true if registered, false otherwise
+     */
+    has(name: string): boolean;
+    /**
+     * Get the number of registered objects
+     */
+    get size(): number;
+    /**
+     * Clear all registered objects (useful for testing)
+     * @internal
+     */
+    clear(): void;
+    /**
+     * Get registry summary for debugging
+     */
+    summary(): string;
+    /**
+     * Log registry summary to console
+     */
+    debug(): void;
+}
+/**
+ * Singleton instance of the registry
+ * Use this to register and retrieve native objects
+ *
+ * @example
+ * ```typescript
+ * import { registry } from "@stndrds/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 "@stndrds/schema";
+ *
+ * const COMPANY_DETAIL = view("detail", "Detail")
+ *   .for("companies")
+ *   .system()
+ *   .tab("general", "Info")
+ *     .form(group("main", "Main").fields("name", "status"))
+ *   .build();
+ *
+ * viewRegistry.register(COMPANY_DETAIL);
+ * ```
+ */
+declare class ViewRegistry {
+    private views;
+    private byObject;
+    /**
+     * Register a native view
+     * @param viewOrViews - Single view or array of views
+     * @throws Error if view is not marked as system
+     * @throws Error if view with same name already exists for the object
+     */
+    register(viewOrViews: ViewDefinition | ViewDefinition[]): this;
+    private registerSingle;
+    /**
+     * Get all views for an object
+     */
+    getByObjectName(objectName: string): ViewDefinition[];
+    /**
+     * Get a specific view by object and view name
+     */
+    get(objectName: string, viewName: string): ViewDefinition | undefined;
+    /**
+     * Get a view or throw if not found
+     */
+    getOrThrow(objectName: string, viewName: string): ViewDefinition;
+    /**
+     * Get all registered views
+     */
+    getAll(): ViewDefinition[];
+    /**
+     * Check if a view exists
+     */
+    has(objectName: string, viewName: string): boolean;
+    /**
+     * Check if any views exist for an object
+     */
+    hasObject(objectName: string): boolean;
+    /**
+     * Get number of registered views
+     */
+    get size(): number;
+    /**
+     * List all object names that have views
+     */
+    listObjectNames(): string[];
+    /**
+     * Get default view for an object (if any)
+     */
+    getDefault(objectName: string): ViewDefinition | undefined;
+    /**
+     * Clear all registered views (for testing)
+     */
+    clear(): void;
+    /**
+     * Generate summary string for debugging
+     */
+    summary(): string;
+    /**
+     * Log summary to console
+     */
+    debug(): void;
+    private makeKey;
+}
+/**
+ * Global registry for native views
+ */
+declare const viewRegistry: ViewRegistry;
+
+/**
+ * Text attribute config schema
+ */
+declare const textConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    pattern: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    pattern?: string | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    pattern?: string | undefined;
+}>;
+/**
+ * Textarea attribute config schema
+ */
+declare const textareaConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Number attribute config schema
+ */
+declare const numberConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodOptional<z.ZodEnum<["integer", "decimal", "percentage"]>>;
+    decimals: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    unit?: "percentage" | "integer" | "decimal" | undefined;
+    decimals?: number | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    unit?: "percentage" | "integer" | "decimal" | undefined;
+    decimals?: number | undefined;
+}>;
+/**
+ * Checkbox attribute config schema
+ */
+declare const checkboxConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Date attribute config schema
+ */
+declare const dateConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    dateFormat: z.ZodOptional<z.ZodEnum<["short", "long", "full", "relative"]>>;
+    minDate: z.ZodOptional<z.ZodString>;
+    maxDate: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    dateFormat?: "short" | "long" | "full" | "relative" | undefined;
+    minDate?: string | undefined;
+    maxDate?: string | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    dateFormat?: "short" | "long" | "full" | "relative" | undefined;
+    minDate?: string | undefined;
+    maxDate?: string | undefined;
+}>;
+/**
+ * Phone attribute config schema
+ */
+declare const phoneConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    defaultCountryCode: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    defaultCountryCode?: string | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    defaultCountryCode?: string | undefined;
+}>;
+/**
+ * Currency attribute config schema
+ */
+declare const currencyConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    defaultCurrency: z.ZodOptional<z.ZodString>;
+    allowedCurrencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    defaultCurrency?: string | undefined;
+    allowedCurrencies?: string[] | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    defaultCurrency?: string | undefined;
+    allowedCurrencies?: string[] | undefined;
+}>;
+/**
+ * Status attribute config schema
+ */
+declare const statusConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodEnum<["idle", "in_progress", "finished"]>>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }, {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    options: {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Location attribute config schema
+ */
+declare const locationConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    granularity: z.ZodEnum<["full", "address", "city", "state", "country", "coordinates"]>;
+    enableAutocomplete: z.ZodOptional<z.ZodBoolean>;
+    enableMap: z.ZodOptional<z.ZodBoolean>;
+    defaultCountry: z.ZodOptional<z.ZodString>;
+    allowedCountries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    displayFormat: z.ZodOptional<z.ZodEnum<["single_line", "multi_line", "compact"]>>;
+}, "strip", z.ZodTypeAny, {
+    granularity: "full" | "address" | "city" | "state" | "country" | "coordinates";
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    enableAutocomplete?: boolean | undefined;
+    enableMap?: boolean | undefined;
+    defaultCountry?: string | undefined;
+    allowedCountries?: string[] | undefined;
+    displayFormat?: "single_line" | "multi_line" | "compact" | undefined;
+}, {
+    granularity: "full" | "address" | "city" | "state" | "country" | "coordinates";
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    enableAutocomplete?: boolean | undefined;
+    enableMap?: boolean | undefined;
+    defaultCountry?: string | undefined;
+    allowedCountries?: string[] | undefined;
+    displayFormat?: "single_line" | "multi_line" | "compact" | undefined;
+}>;
+/**
+ * Timestamp attribute config schema
+ */
+declare const timestampConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    autoUpdate: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    autoUpdate?: boolean | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    autoUpdate?: boolean | undefined;
+}>;
+/**
+ * Select attribute config schema
+ */
+declare const selectConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodEnum<["idle", "in_progress", "finished"]>>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }, {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    options: {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Multiselect attribute config schema
+ */
+declare const multiselectConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodEnum<["idle", "in_progress", "finished"]>>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }, {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    options: {
+        label: string;
+        id: string;
+        value: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        group?: "idle" | "in_progress" | "finished" | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+/**
+ * File attribute config schema
+ */
+declare const fileConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    maxFiles: z.ZodOptional<z.ZodNumber>;
+    maxSize: z.ZodOptional<z.ZodNumber>;
+    allowedTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    verification: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        documentTypes: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["id_card", "passport", "incorporation_certificate", "driver_license", "birth_certificate", "residence_permit", "bank_statement", "proof_of_address", "custom"]>;
+            label: z.ZodString;
+            faces: z.ZodArray<z.ZodEnum<["front", "back", "single"]>, "many">;
+            attributeMapping: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                attributeId: z.ZodString;
+                extractedKey: z.ZodString;
+                face: z.ZodOptional<z.ZodEnum<["front", "back", "single"]>>;
+                required: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }, {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            type: "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+            faces: ("front" | "back" | "single")[];
+            attributeMapping?: {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }[] | undefined;
+        }, {
+            label: string;
+            type: "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+            faces: ("front" | "back" | "single")[];
+            attributeMapping?: {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }[] | undefined;
+        }>, "many">;
+        autoExtract: z.ZodOptional<z.ZodBoolean>;
+        autoValidate: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        documentTypes: {
+            label: string;
+            type: "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+            faces: ("front" | "back" | "single")[];
+            attributeMapping?: {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }[] | undefined;
+        }[];
+        autoExtract?: boolean | undefined;
+        autoValidate?: boolean | undefined;
+    }, {
+        enabled: boolean;
+        documentTypes: {
+            label: string;
+            type: "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+            faces: ("front" | "back" | "single")[];
+            attributeMapping?: {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }[] | undefined;
+        }[];
+        autoExtract?: boolean | undefined;
+        autoValidate?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    maxFiles?: number | undefined;
+    maxSize?: number | undefined;
+    allowedTypes?: string[] | undefined;
+    verification?: {
+        enabled: boolean;
+        documentTypes: {
+            label: string;
+            type: "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+            faces: ("front" | "back" | "single")[];
+            attributeMapping?: {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }[] | undefined;
+        }[];
+        autoExtract?: boolean | undefined;
+        autoValidate?: boolean | undefined;
+    } | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    maxFiles?: number | undefined;
+    maxSize?: number | undefined;
+    allowedTypes?: string[] | undefined;
+    verification?: {
+        enabled: boolean;
+        documentTypes: {
+            label: string;
+            type: "id_card" | "passport" | "incorporation_certificate" | "driver_license" | "birth_certificate" | "residence_permit" | "bank_statement" | "proof_of_address" | "custom";
+            faces: ("front" | "back" | "single")[];
+            attributeMapping?: {
+                attributeId: string;
+                extractedKey: string;
+                required?: boolean | undefined;
+                face?: "front" | "back" | "single" | undefined;
+            }[] | undefined;
+        }[];
+        autoExtract?: boolean | undefined;
+        autoValidate?: boolean | undefined;
+    } | undefined;
+}>;
+/**
+ * User attribute config schema
+ */
+declare const userConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    allowedRoles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    allowedRoles?: string[] | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    allowedRoles?: string[] | undefined;
+}>;
+/**
+ * Relation attribute config schema
+ */
+declare const relationConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    targets: z.ZodArray<z.ZodObject<{
+        object: z.ZodString;
+        displayTemplate: z.ZodOptional<z.ZodString>;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        filter?: Record<string, unknown> | undefined;
+        displayTemplate?: string | undefined;
+    }, {
+        object: string;
+        filter?: Record<string, unknown> | undefined;
+        displayTemplate?: string | undefined;
+    }>, "many">;
+    onDelete: z.ZodOptional<z.ZodEnum<["restrict", "cascade", "set_null"]>>;
+    cardinality: z.ZodEnum<["one", "many"]>;
+    minItems: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    cardinality: "one" | "many";
+    targets: {
+        object: string;
+        filter?: Record<string, unknown> | undefined;
+        displayTemplate?: string | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    onDelete?: "restrict" | "cascade" | "set_null" | undefined;
+    minItems?: number | undefined;
+    maxItems?: number | undefined;
+}, {
+    cardinality: "one" | "many";
+    targets: {
+        object: string;
+        filter?: Record<string, unknown> | undefined;
+        displayTemplate?: string | undefined;
+    }[];
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    onDelete?: "restrict" | "cascade" | "set_null" | undefined;
+    minItems?: number | undefined;
+    maxItems?: number | undefined;
+}>;
+/**
+ * Rating attribute config schema
+ */
+declare const ratingConfigSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    max: z.ZodOptional<z.ZodNumber>;
+    iconType: z.ZodOptional<z.ZodEnum<["star", "heart", "thumbs", "number"]>>;
+}, "strip", z.ZodTypeAny, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    max?: number | undefined;
+    iconType?: "number" | "heart" | "star" | "thumbs" | undefined;
+}, {
+    defaultValue?: unknown;
+    disabled?: boolean | undefined;
+    placeholder?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+    hidden?: boolean | undefined;
+    archived?: boolean | undefined;
+    deprecated?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    max?: number | undefined;
+    iconType?: "number" | "heart" | "star" | "thumbs" | undefined;
+}>;
+/**
+ * Map of attribute type to config schema
+ */
+declare const attributeConfigSchemas: Record<AttributeType, z.ZodObject<z.ZodRawShape>>;
+/**
+ * Get the config schema for a specific attribute type
+ */
+declare function getAttributeConfigSchema(type: AttributeType): z.ZodObject<z.ZodRawShape>;
+/**
+ * Validate attribute config for a specific type
+ * Returns the validated config with only allowed properties
+ */
+declare function validateAttributeConfig(type: AttributeType, config: Record<string, unknown>): {
+    success: true;
+    data: Record<string, unknown>;
+} | {
+    success: false;
+    errors: string[];
+};
+/**
+ * Validate and strip unknown properties from attribute config
+ * This ensures only allowed properties are stored in the database
+ */
+declare function parseAttributeConfig(type: AttributeType, config: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Safely parse attribute config, returning undefined for invalid configs
+ */
+declare function safeParseAttributeConfig(type: AttributeType, config: Record<string, unknown>): Record<string, unknown> | undefined;
+/**
+ * Create a Zod schema for a text attribute
+ */
+declare function createTextValidator(attr: TextAttribute): z.ZodString;
+/**
+ * Create a Zod schema for a number attribute
+ */
+declare function createNumberValidator(attr: NumberAttribute): z.ZodNumber;
+/**
+ * Create a Zod schema for a checkbox attribute
+ */
+declare function createCheckboxValidator(_attr: CheckboxAttribute): z.ZodBoolean;
+/**
+ * Create a Zod schema for a date attribute
+ */
+declare function createDateValidator(attr: DateAttribute): z.ZodString;
+/**
+ * Create a Zod schema for a phone attribute
+ */
+declare function createPhoneValidator(_attr: PhoneAttribute): z.ZodType<{
+    countryCode: string;
+    phoneNumber: string;
+}>;
+/**
+ * Create a Zod schema for a currency attribute
+ */
+declare function createCurrencyValidator(_attr: CurrencyAttribute): z.ZodType<{
+    code: string;
+    value: number;
+}>;
+/**
+ * Create a Zod schema for a status attribute
+ */
+declare function createStatusValidator(attr: StatusAttribute): z.ZodEnum<[string, ...string[]]>;
+/**
+ * Create a Zod schema for a select attribute
+ */
+declare function createSelectValidator(attr: SelectAttribute): z.ZodEnum<[string, ...string[]]>;
+/**
+ * Create a Zod schema for a multiselect attribute
+ */
+declare function createMultiselectValidator(attr: MultiselectAttribute): z.ZodArray<z.ZodEnum<[string, ...string[]]>>;
+/**
+ * Create a Zod schema for a location attribute
+ */
+type LocationShape = {
+    address?: string;
+    address2?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    latitude?: number;
+    longitude?: number;
+};
+declare function createLocationValidator(_attr: LocationAttribute): z.ZodType<LocationShape>;
+/**
+ * Create a Zod schema for a timestamp attribute
+ */
+declare function createTimestampValidator(_attr: TimestampAttribute): z.ZodNumber;
+/**
+ * Create a Zod schema for a file attribute
+ */
+declare function createFileValidator(_attr: FileAttribute): z.ZodString;
+/**
+ * Create a Zod schema for a user attribute
+ */
+declare function createUserValidator(_attr: UserAttribute): z.ZodString;
+/**
+ * Create a Zod schema for a single relation attribute (cardinality: "one")
+ */
+declare function createSingleRelationValidator(attr: SingleRelationAttribute): z.ZodUnion<[z.ZodString, z.ZodNull]>;
+/**
+ * Create a Zod schema for a multi relation attribute (cardinality: "many")
+ */
+declare function createMultiRelationValidator(attr: MultiRelationAttribute): z.ZodArray<z.ZodString>;
+/**
+ * Create a Zod schema for a relation attribute
+ * Dispatches to single or multi validator based on cardinality
+ */
+declare function createRelationValidator(attr: RelationAttribute): z.ZodUnion<[z.ZodString, z.ZodNull]> | z.ZodArray<z.ZodString>;
+/**
+ * Create a Zod schema for a rating attribute
+ */
+declare function createRatingValidator(attr: RatingAttribute): z.ZodNumber;
+/**
+ * Create a Zod schema for any attribute type
+ */
+declare function createAttributeValidator(attr: Attribute): z.ZodTypeAny;
+/**
+ * Create a Zod schema for an entire object
+ */
+declare function createObjectValidator(objectDef: ObjectDefinition): z.ZodType<Record<string, unknown>>;
+/**
+ * Validation result
+ */
+interface ValidationResult {
+    success: boolean;
+    data?: Record<string, unknown>;
+    errors?: Array<{
+        path: string[];
+        message: string;
+    }>;
+}
+/**
+ * Validate data against an attribute schema
+ */
+declare function validateAttribute(attr: Attribute, value: unknown): ValidationResult;
+/**
+ * Validate data against an object schema
+ */
+declare function validateObject(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
+/**
+ * Validate and throw if invalid
+ */
+declare function validateObjectOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Create a Zod schema for draft validation.
+ * All attributes become optional, but provided values are still validated.
+ */
+declare function createDraftValidator(objectDef: ObjectDefinition): z.ZodType<Record<string, unknown>>;
+/**
+ * Validate data in draft mode.
+ * - All attributes are treated as optional (no required validation)
+ * - Provided values are still validated for format/type correctness
+ *
+ * Use this when creating records that may be incomplete (drafts).
+ *
+ * @example
+ * ```typescript
+ * const result = validateDraft(PRODUCT, { name: "Draft" });
+ * // → success even if "price" is required but missing
+ *
+ * const result2 = validateDraft(PRODUCT, { price: -10 });
+ * // → fails because price must be >= 0 (format validation still applies)
+ * ```
+ */
+declare function validateDraft(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
+/**
+ * Validate draft data and throw if format validation fails.
+ */
+declare function validateDraftOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Get the list of required attributes that are missing values.
+ *
+ * @example
+ * ```typescript
+ * const missing = getMissingRequiredAttributes(PRODUCT, { name: "Test" });
+ * // → [priceAttribute, statusAttribute] if price and status are required but missing
+ * ```
+ */
+declare function getMissingRequiredAttributes(objectDef: ObjectDefinition, data: Record<string, unknown>): Attribute[];
+/**
+ * Check if a record is complete (all required attributes have valid values).
+ *
+ * @returns `true` if all required values are present and valid, `false` otherwise
+ */
+declare function isRecordComplete(objectDef: ObjectDefinition, data: Record<string, unknown>): boolean;
+/**
+ * Compute the completion status of a record based on its data.
+ *
+ * - `"complete"`: All required values are present and valid
+ * - `"draft"`: One or more required values are missing or invalid
+ *
+ * This function is used to dynamically determine the status when
+ * creating or updating records.
+ *
+ * @example
+ * ```typescript
+ * const status = computeRecordStatus(PRODUCT, {
+ *   name: "Nike Air Max",
+ *   price: 129.99,
+ *   status: "active"
+ * });
+ * // → "complete"
+ *
+ * const status2 = computeRecordStatus(PRODUCT, { name: "Draft Product" });
+ * // → "draft" (missing required fields)
+ * ```
+ */
+declare function computeRecordStatus(objectDef: ObjectDefinition, data: Record<string, unknown>): CompletionStatus;
+
+/**
+ * Object as stored in database (metadata)
+ */
+interface DBObject extends Timestamps {
+    id: Uuid;
+    tenantId: TenantId;
+    name: string;
+    label: string;
+    pluralLabel?: string;
+    description?: string;
+    icon?: IconName;
+    labelExpression: string;
+    system: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface CreateDBObject {
+    tenantId: TenantId;
+    name: string;
+    label: string;
+    pluralLabel?: string;
+    description?: string;
+    icon?: IconName;
+    labelExpression: string;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateDBObject {
+    label?: string;
+    pluralLabel?: string;
+    description?: string;
+    icon?: IconName;
+    labelExpression?: string;
+    metadata?: Record<string, unknown>;
+}
+interface UpsertDBObject extends CreateDBObject {
+    system: boolean;
+}
+/**
+ * Attribute as stored in database (metadata)
+ */
+interface DBAttribute extends Timestamps {
+    id: Uuid;
+    objectId: Uuid;
+    name: string;
+    label: string;
+    type: AttributeType;
+    description?: string;
+    icon?: IconName;
+    system: boolean;
+    required: boolean;
+    unique: boolean;
+    order: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    defaultValue?: unknown;
+    config: Record<string, unknown>;
+}
+interface CreateDBAttribute {
+    objectId: Uuid;
+    name: string;
+    label: string;
+    type: AttributeType;
+    description?: string;
+    icon?: IconName;
+    system?: boolean;
+    required?: boolean;
+    unique?: boolean;
+    order?: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    defaultValue?: unknown;
+    config?: Record<string, unknown>;
+}
+interface UpdateDBAttribute {
+    label?: string;
+    type?: AttributeType;
+    description?: string;
+    icon?: IconName;
+    required?: boolean;
+    order?: number;
+    hidden?: boolean;
+    archived?: boolean;
+    deprecated?: boolean;
+    defaultValue?: unknown;
+    config?: Record<string, unknown>;
+}
+interface UpsertDBAttribute extends CreateDBAttribute {
+    objectId: Uuid;
+    name: string;
+}
+
+/**
+ * Object record creation data
+ */
+interface CreateObjectRecord {
+    tenantId: TenantId;
+    objectId: Uuid;
+    data: Record<string, unknown>;
+    /**
+     * Computed display label from labelExpression.
+     * Stored for performance - avoids recomputation on every read.
+     */
+    label: string;
+    /**
+     * Completion status of the record.
+     * - `draft`: Record is incomplete (missing required values)
+     * - `complete`: All required values are present and valid
+     */
+    completionStatus: "draft" | "complete";
+}
+/**
+ * Generic list options for pagination and sorting
+ */
+interface ListOptions {
+    limit?: number;
+    offset?: number;
+    /** @deprecated Use sorts instead */
+    orderBy?: string;
+    /** @deprecated Use sorts instead */
+    orderDirection?: "asc" | "desc";
+    /** Multiple sort rules */
+    sorts?: SortRule[];
+    /** Filter state */
+    filters?: FilterState;
+}
+/**
+ * Search options for full-text search
+ */
+interface SearchOptions extends ListOptions {
+    highlight?: boolean;
+}
+/**
+ * Global search options
+ */
+interface GlobalSearchOptions extends ListOptions {
+    /**
+     * Limit results to specific object names
+     */
+    objectNames?: string[];
+    /**
+     * Whether to include object metadata in results
+     */
+    includeObjectInfo?: boolean;
+}
+/**
+ * Global search result item
+ */
+interface GlobalSearchResultItem {
+    objectId: string;
+    objectName: string;
+    objectLabel: string;
+    /** Computed label from labelExpression */
+    label: string;
+    recordId: string;
+    values: Record<string, unknown>;
+    completionStatus: "draft" | "complete";
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * File-specific list options
+ */
+interface FileListOptions extends ListOptions {
+    folderPath?: string;
+    mimeType?: string;
+    uploadedBy?: Uuid;
+    includeDeleted?: boolean;
+}
+/**
+ * View as stored in database
+ */
+interface DBView extends Timestamps {
+    id: Uuid;
+    tenantId: TenantId;
+    objectId?: Uuid;
+    objectName: string;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    tabs: Tab[];
+    default: boolean;
+    system: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface CreateDBView {
+    tenantId: TenantId;
+    objectId?: Uuid;
+    objectName: string;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    tabs: Tab[];
+    default?: boolean;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateDBView {
+    label?: string;
+    description?: string;
+    icon?: IconName;
+    tabs?: Tab[];
+    default?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface UpsertDBView {
+    tenantId: TenantId;
+    objectName: string;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    tabs: Tab[];
+    default?: boolean;
+    system?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Result of an operation
+ */
+interface OperationResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+
+/**
+ * Repository for objects table (metadata)
+ */
+interface ObjectsRepository {
+    /**
+     * Find object by ID
+     */
+    findById(id: Uuid): Promise<DBObject | null>;
+    /**
+     * Find object by name and tenant
+     */
+    findByName(tenantId: TenantId, name: string): Promise<DBObject | null>;
+    /**
+     * Find system/native object by name (system=true, for sync)
+     */
+    findSystemByName(name: string): Promise<DBObject | null>;
+    /**
+     * Create object
+     */
+    create(data: CreateDBObject): Promise<DBObject>;
+    /**
+     * Update object
+     */
+    update(id: Uuid, data: Partial<UpdateDBObject>): Promise<DBObject>;
+    /**
+     * Delete object
+     */
+    delete(id: Uuid): Promise<void>;
+    /**
+     * List all objects for a tenant
+     */
+    list(tenantId: TenantId): Promise<DBObject[]>;
+    /**
+     * Upsert object (create or update based on nativeObjectId)
+     */
+    upsert(data: UpsertDBObject): Promise<DBObject>;
+}
+/**
+ * Repository for attributes table (metadata)
+ */
+interface AttributesRepository {
+    /**
+     * Find attribute by ID
+     */
+    findById(id: Uuid): Promise<DBAttribute | null>;
+    /**
+     * Find attributes by object ID
+     */
+    findByObjectId(objectId: Uuid): Promise<DBAttribute[]>;
+    /**
+     * Create attribute
+     */
+    create(data: CreateDBAttribute): Promise<DBAttribute>;
+    /**
+     * Update attribute
+     */
+    update(id: Uuid, data: Partial<UpdateDBAttribute>): Promise<DBAttribute>;
+    /**
+     * Delete attribute
+     */
+    delete(id: Uuid): Promise<void>;
+    /**
+     * Delete multiple attributes by names (for sync cleanup)
+     */
+    deleteByNames(objectId: Uuid, excludeNames: string[]): Promise<number>;
+    /**
+     * Upsert attribute (create or update based on objectId + name)
+     */
+    upsert(data: UpsertDBAttribute): Promise<DBAttribute>;
+}
+/**
+ * Repository for user_profiles table
+ */
+interface UserProfilesRepository {
+    /**
+     * Find user profile by ID
+     */
+    findById(id: Uuid): Promise<UserProfile | null>;
+    /**
+     * Find user profile by auth ID (external auth provider)
+     */
+    findByAuthId(authId: string): Promise<UserProfile | null>;
+    /**
+     * Find user profile by email
+     */
+    findByEmail(tenantId: TenantId, email: string): Promise<UserProfile | null>;
+    /**
+     * Create user profile
+     */
+    create(data: CreateUserProfile): Promise<UserProfile>;
+    /**
+     * Update user profile
+     */
+    update(id: Uuid, data: UpdateUserProfile): Promise<UserProfile>;
+    /**
+     * Delete user profile
+     */
+    delete(id: Uuid): Promise<void>;
+    /**
+     * List all user profiles for a tenant
+     */
+    list(tenantId: TenantId, options?: ListOptions): Promise<UserProfile[]>;
+    /**
+     * Count user profiles by role within a tenant.
+     * Useful for checking if last admin before deletion.
+     */
+    countByRole(tenantId: TenantId, role: string): Promise<number>;
+    /**
+     * 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>;
+    /**
+     * Find multiple records by IDs (batch fetch)
+     * Returns records in no particular order. Missing IDs are simply not included.
+     */
+    findByIds(ids: Uuid[]): Promise<ObjectRecord[]>;
+    /**
+     * 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>;
+}
+/**
+ * Repository for roles, permissions, and user role assignments.
+ *
+ * This repository is optional - if not provided in the DatabaseAdapter,
+ * permission checks are disabled (backward compatible behavior).
+ */
+interface PermissionsRepository {
+    /**
+     * Get all roles for a tenant
+     */
+    getRolesByTenant(tenantId: TenantId): Promise<Role[]>;
+    /**
+     * Get a role by ID
+     */
+    getRoleById(roleId: Uuid): Promise<Role | null>;
+    /**
+     * Get a role by name for a tenant
+     */
+    getRoleByName(tenantId: TenantId, name: string): Promise<Role | null>;
+    /**
+     * Create a new role
+     */
+    createRole(input: CreateRoleInput): Promise<Role>;
+    /**
+     * Update an existing role
+     */
+    updateRole(roleId: Uuid, updates: UpdateRoleInput): Promise<Role>;
+    /**
+     * Delete a role (fails if role is system role)
+     */
+    deleteRole(roleId: Uuid): Promise<void>;
+    /**
+     * Get all permissions for a role
+     */
+    getPermissionsByRole(roleId: Uuid): Promise<Permission[]>;
+    /**
+     * Set permissions for a role (replaces existing permissions)
+     */
+    setPermissions(roleId: Uuid, permissions: CreatePermissionInput[]): Promise<void>;
+    /**
+     * Get all roles assigned to a user profile within a tenant
+     */
+    getUserRoles(userProfileId: Uuid, tenantId: TenantId): Promise<Role[]>;
+    /**
+     * Assign a role to a user profile
+     */
+    assignRole(input: AssignRoleInput): Promise<UserRoleAssignment>;
+    /**
+     * Revoke a role from a user profile
+     */
+    revokeRole(userProfileId: Uuid, roleId: Uuid, tenantId: TenantId): Promise<void>;
+    /**
+     * Get effective permissions for a user profile (merged from all assigned roles)
+     *
+     * This method should:
+     * 1. Get all roles assigned to the user profile
+     * 2. Get all permissions for those roles
+     * 3. Merge permissions (union of actions per object)
+     * 4. Determine if user has admin privileges
+     */
+    getEffectivePermissions(userProfileId: Uuid, tenantId: TenantId): Promise<EffectivePermissions>;
+}
+
+/**
+ * Generic database adapter interface
+ * Any ORM (Drizzle, Prisma, Kysely, TypeORM) can implement this interface
+ * to work with @stndrds/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;
+    permissions?: PermissionsRepository;
+    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>;
+    roles: Map<Uuid, Role>;
+    permissions: Map<Uuid, Permission>;
+    userRoles: Map<Uuid, UserRoleAssignment>;
+}
+/**
+ * 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 "@stndrds/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 "@stndrds/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;
+    /**
+     * Plural form of the label (e.g., "Products" for "Product")
+     * Used in UI when displaying collections
+     */
+    pluralLabel?: 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;
+}
+/**
+ * Input for updating an object
+ * Only custom objects (system=false) can be updated
+ * Note: `name` cannot be changed after creation
+ */
+interface UpdateObjectInput {
+    label?: string;
+    pluralLabel?: string;
+    description?: string;
+    icon?: IconName;
+    labelExpression?: string;
+    metadata?: Record<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[]>;
+    /**
+     * Update a custom object
+     * Can only update custom objects (system=false)
+     *
+     * @param objectId - Object UUID
+     * @param updates - Partial object updates
+     * @returns Updated ObjectDefinition
+     *
+     * @example
+     * ```typescript
+     * const updated = await service.updateObject("obj-123", {
+     *   label: "Updated Label",
+     *   description: "New description",
+     * });
+     * ```
+     */
+    updateObject(objectId: string, updates: UpdateObjectInput): Promise<ObjectDefinition>;
+    /**
+     * Delete a custom object
+     * Can only delete custom objects (system=false)
+     * This will also delete all associated attributes and records
+     *
+     * @param objectId - Object UUID
+     *
+     * @example
+     * ```typescript
+     * await service.deleteObject("obj-123");
+     * ```
+     */
+    deleteObject(objectId: string): Promise<void>;
+    /**
+     * 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 PermissionService constructor
+ */
+interface PermissionServiceOptions {
+    /**
+     * Cache TTL in milliseconds.
+     * @default 60000 (1 minute)
+     */
+    cacheTtlMs?: number;
+    /**
+     * Maximum number of entries in the cache.
+     * Oldest entries are evicted when limit is reached (LRU-like).
+     * @default 10000
+     */
+    maxCacheSize?: number;
+}
+/**
+ * Service for checking and managing permissions.
+ *
+ * Features:
+ * - In-memory cache with TTL and size limit for effective permissions
+ * - Admin bypass for full access
+ * - Wildcard permission support (target: "*")
+ * - Object-level permission checks
+ *
+ * @example
+ * ```typescript
+ * const permissionService = new PermissionService(adapter, "tenant-123");
+ *
+ * // Check if user can read companies
+ * const canRead = await permissionService.canAccessObject(userId, "companies", "read");
+ *
+ * // Throw if user cannot update
+ * await permissionService.checkObjectAccess(userId, "companies", "update");
+ * ```
+ */
+declare class PermissionService {
+    private readonly adapter;
+    private readonly tenantId;
+    private cache;
+    private readonly cacheTtlMs;
+    private readonly maxCacheSize;
+    private readonly permissionsRepo;
+    constructor(adapter: DatabaseAdapter, tenantId: string, options?: PermissionServiceOptions);
+    /**
+     * Check if user can perform an action on an object.
+     *
+     * @param userProfileId - User profile ID to check
+     * @param objectName - Object name to check access for
+     * @param action - Action to check (read, create, update, delete)
+     * @returns true if user has permission, false otherwise
+     */
+    canAccessObject(userProfileId: string, objectName: string, action: ObjectAction): Promise<boolean>;
+    /**
+     * Check if user can access an object, throw ForbiddenError if not.
+     *
+     * @param userProfileId - User profile ID to check
+     * @param objectName - Object name to check access for
+     * @param action - Action to check
+     * @throws ForbiddenError if user lacks permission
+     */
+    checkObjectAccess(userProfileId: string, objectName: string, action: ObjectAction): Promise<void>;
+    /**
+     * Get permissions for a specific object as boolean flags.
+     * Optimized to fetch permissions once and compute all flags.
+     *
+     * @param userProfileId - User profile ID to check
+     * @param objectName - Object name to check
+     * @returns Object with canRead, canCreate, canUpdate, canDelete flags
+     */
+    getObjectPermissions(userProfileId: string, objectName: string): Promise<ObjectPermissions>;
+    /**
+     * Check if user can perform an action on a system resource.
+     *
+     * @param userProfileId - User profile ID to check
+     * @param resource - System resource (users, schema, roles, settings)
+     * @param action - Action to check (read, create, update, delete)
+     * @returns true if user has permission, false otherwise
+     */
+    canAccessSystem(userProfileId: string, resource: SystemResource, action: SystemAction): Promise<boolean>;
+    /**
+     * Check if user can access a system resource, throw ForbiddenError if not.
+     *
+     * @param userProfileId - User profile ID to check
+     * @param resource - System resource to check access for
+     * @param action - Action to check
+     * @throws ForbiddenError if user lacks permission
+     */
+    checkSystemAccess(userProfileId: string, resource: SystemResource, action: SystemAction): Promise<void>;
+    /**
+     * Get permissions for a specific system resource as boolean flags.
+     * Optimized to fetch permissions once and compute all flags.
+     *
+     * @param userProfileId - User profile ID to check
+     * @param resource - System resource to check
+     * @returns Object with canRead, canCreate, canUpdate, canDelete flags
+     */
+    getSystemPermissions(userProfileId: string, resource: SystemResource): Promise<SystemPermissions>;
+    /**
+     * Get effective permissions for a user.
+     * Results are cached with TTL and size limit.
+     *
+     * @param userProfileId - User profile ID
+     * @returns Merged permissions from all user's roles
+     */
+    getEffectivePermissions(userProfileId: string): Promise<EffectivePermissions>;
+    /**
+     * Invalidate cached permissions for a specific user.
+     * Call this after role/permission changes.
+     */
+    invalidateCache(userProfileId: string): void;
+    /**
+     * Invalidate all cached permissions.
+     * Call this after bulk role/permission changes.
+     */
+    invalidateAllCache(): void;
+    /**
+     * Get current cache size (for monitoring).
+     */
+    getCacheSize(): number;
+    private getCacheKey;
+    /**
+     * Get all roles for the current tenant.
+     */
+    getRoles(): Promise<Role[]>;
+    /**
+     * Get a role by ID.
+     */
+    getRoleById(roleId: string): Promise<Role | null>;
+    /**
+     * Create a new role.
+     */
+    createRole(input: Omit<CreateRoleInput, "tenantId">): Promise<Role>;
+    /**
+     * Update a role.
+     */
+    updateRole(roleId: string, updates: UpdateRoleInput): Promise<Role>;
+    /**
+     * Delete a role.
+     */
+    deleteRole(roleId: string): Promise<void>;
+    /**
+     * Get all permissions for a role.
+     */
+    getPermissionsByRole(roleId: string): Promise<Permission[]>;
+    /**
+     * Set permissions for a role (replaces existing).
+     */
+    setPermissions(roleId: string, permissions: CreatePermissionInput[]): Promise<void>;
+    /**
+     * Get all roles assigned to a user.
+     */
+    getUserRoles(userProfileId: string): Promise<Role[]>;
+    /**
+     * Assign a role to a user.
+     */
+    assignRole(userProfileId: string, roleId: string, assignedBy?: string): Promise<UserRoleAssignment>;
+    /**
+     * Revoke a role from a user.
+     */
+    revokeRole(userProfileId: string, roleId: string): Promise<void>;
+}
+
+/**
+ * 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;
+    /**
+     * Permission service for access control.
+     * If provided along with userId, permission checks are enforced.
+     * If not provided, no permission checks are performed (backward compatible).
+     */
+    permissionService?: PermissionService;
+    /**
+     * Current user ID for permission checks.
+     * Required when permissionService is provided.
+     */
+    userId?: string;
+}
+/**
+ * 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.
+ * Supports optional permission checks when permissionService and userId are provided.
+ */
+declare class RecordService {
+    private adapter;
+    private tenantId;
+    private schemaService;
+    private relationService;
+    private hookRegistry;
+    private permissionService?;
+    private userId?;
+    constructor(adapter: DatabaseAdapter, tenantId: string, options?: RecordServiceOptions);
+    /**
+     * Check permission for an action on an object.
+     * Only checks if permissionService and userId are configured.
+     * @internal
+     */
+    private checkPermission;
+    /**
+     * Compute display label from schema expression
+     * Automatically resolves relation attribute values to their labels
+     * @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?: ListOptions): 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?: SearchOptions): 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
+ *
+ * SECURITY: This type intentionally excludes raw record data.
+ * Only the computed label is exposed to prevent unauthorized data access
+ * through relation lookups. Users must have explicit read permissions
+ * on an object to access its record data.
+ */
+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;
+}
+/**
+ * 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
+     *
+     * Uses batch fetching for performance - fetches all records in one query,
+     * then groups by objectId to minimize schema lookups.
+     *
+     * @param ids - Record IDs to resolve
+     * @param _tenantId - Tenant ID for multi-tenant isolation (unused but kept for API compatibility)
+     * @param attributeId - Relation attribute ID to use its displayTemplate for label rendering
+     *
+     * @example
+     * ```typescript
+     * const resolved = await relationService.resolveIds(["rec-1", "rec-2"], "tenant-1", "attr-123");
+     * // [{ id: "rec-1", label: "Nike Air Max", objectName: "products", ... }]
+     * ```
+     */
+    resolveIds(ids: string[], _tenantId: string, attributeId: 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 "@stndrds/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 "@stndrds/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 "@stndrds/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 CheckboxFilterOperator as $, type Attribute as A, type BaseAttribute as B, type Currency as C, type DateAttribute as D, type DocumentFace as E, type FileAttribute as F, type Group as G, type DocumentTypeConfig as H, type FileVerificationConfig as I, type RelationAttribute as J, type StorageProvider as K, type Location as L, type MultiselectAttribute as M, type NumberAttribute as N, type ObjectAction as O, type Phone as P, type FileVisibility as Q, type RelationOnDelete as R, type StatusAttribute as S, type TextAttribute as T, type UserAttribute as U, type ViewDefinition as V, type File as W, type CreateFile as X, type UpdateFile as Y, type TextFilterOperator as Z, type NumberFilterOperator as _, type SelectAttribute as a, textConfigSchema as a$, type DateFilterOperator as a0, type SelectFilterOperator as a1, type MultiselectFilterOperator as a2, type RelationFilterOperator as a3, type FilterOperator as a4, type RelativeDateValue as a5, type CurrencyFilterValue as a6, type PhoneFilterValue as a7, type FilterValue as a8, type FilterRule as a9, type Permission as aA, type UserRoleAssignment as aB, type EffectivePermissions as aC, type ObjectPermissions as aD, type SystemPermissions as aE, type CreateRoleInput as aF, type UpdateRoleInput as aG, type CreatePermissionInput as aH, type AssignRoleInput as aI, type UserRole as aJ, type UserStatus as aK, type UserProfile as aL, type CreateUserProfile as aM, type UpdateUserProfile as aN, type TabType as aO, type FormTab as aP, type TableTab as aQ, type CustomTab as aR, isFormTab as aS, isTableTab as aT, isCustomTab as aU, type Uuid as aV, type TenantId as aW, generateId as aX, generatePrefixedId as aY, registry as aZ, viewRegistry as a_, type FilterCombinator as aa, type FilterState as ab, type FilterGroup as ac, type AdvancedFilterState as ad, isAdvancedFilterState as ae, toAdvancedFilterState as af, toSimpleFilterState as ag, type SortDirection as ah, type SortRule as ai, type QueryState as aj, OPERATORS_BY_TYPE as ak, type NoValueOperator as al, NO_VALUE_OPERATORS as am, isNoValueOperator as an, type GeocodingSuggestion as ao, type GeocodingAutocompleteParams as ap, type ReverseGeocodingParams as aq, type GeocodingParams as ar, type GeocodingAdapter as as, NoopGeocodingAdapter as at, type Timestamps as au, type ObjectAttribute as av, type CompletionStatus as aw, type ObjectRecord as ax, type PermissionScope as ay, type Role as az, type SystemResource as b, type ViewsRepository as b$, textareaConfigSchema as b0, numberConfigSchema as b1, checkboxConfigSchema as b2, dateConfigSchema as b3, phoneConfigSchema as b4, currencyConfigSchema as b5, statusConfigSchema as b6, locationConfigSchema as b7, timestampConfigSchema as b8, selectConfigSchema as b9, createRatingValidator as bA, createAttributeValidator as bB, createObjectValidator as bC, type ValidationResult as bD, validateAttribute as bE, validateObject as bF, validateObjectOrThrow as bG, createDraftValidator as bH, validateDraft as bI, validateDraftOrThrow as bJ, getMissingRequiredAttributes as bK, isRecordComplete as bL, computeRecordStatus as bM, type DatabaseAdapter as bN, type AttributeChange as bO, type HookContext as bP, type HookDefinition as bQ, type HookHandler as bR, type HookType as bS, NoopHookRegistry as bT, type HookRegistry as bU, createMockAdapter as bV, type ObjectsRepository as bW, type AttributesRepository as bX, type UserProfilesRepository as bY, type FilesRepository as bZ, type ObjectRecordsRepository as b_, multiselectConfigSchema as ba, fileConfigSchema as bb, userConfigSchema as bc, relationConfigSchema as bd, ratingConfigSchema as be, attributeConfigSchemas as bf, getAttributeConfigSchema as bg, validateAttributeConfig as bh, parseAttributeConfig as bi, safeParseAttributeConfig as bj, createTextValidator as bk, createNumberValidator as bl, createCheckboxValidator as bm, createDateValidator as bn, createPhoneValidator as bo, createCurrencyValidator as bp, createStatusValidator as bq, createSelectValidator as br, createMultiselectValidator as bs, createLocationValidator as bt, createTimestampValidator as bu, createFileValidator as bv, createUserValidator as bw, createSingleRelationValidator as bx, createMultiRelationValidator as by, createRelationValidator as bz, type SystemAction as c, type PermissionsRepository as c0, FileService as c1, GeocodingService as c2, GlobalSearchService as c3, type CreateCustomObjectInput as c4, type AddAttributeInput as c5, type UpdateObjectInput as c6, ObjectSchemaService as c7, type PermissionServiceOptions as c8, PermissionService as c9, type UpdateDBObject as cA, type UpsertDBObject as cB, type DBAttribute as cC, type CreateDBAttribute as cD, type UpdateDBAttribute as cE, type UpsertDBAttribute as cF, type CreateObjectRecord as cG, type ListOptions as cH, type SearchOptions as cI, type GlobalSearchOptions as cJ, type GlobalSearchResultItem as cK, type FileListOptions as cL, type DBView as cM, type CreateDBView as cN, type UpdateDBView as cO, type UpsertDBView as cP, type OperationResult as cQ, type ViewSyncResult as cR, type ViewSyncOptions as cS, syncNativeViews as cT, verifyNativeViewsSync as cU, getViewSyncPreview as cV, type RecordServiceOptions as ca, RecordService as cb, type RelationValidationResult as cc, type RelationValidationError as cd, type RelationOption as ce, type RelationOptionsResponse as cf, type GetRelationOptionsParams as cg, RelationService as ch, UserProfileService as ci, type CreateViewInput as cj, type UpdateViewInput as ck, ViewService as cl, type SyncResult as cm, type SyncOptions as cn, syncNativeObjects as co, verifyNativeObjectsSync as cp, getSyncPreview as cq, type FullSyncResult as cr, type FullSyncOptions as cs, syncAll as ct, DEFAULT_LABEL_FALLBACK as cu, renderLabelExpression as cv, isLabelExpression as cw, extractAttributeNames as cx, type DBObject as cy, type CreateDBObject as cz, type TextAreaAttribute as d, type CheckboxAttribute as e, type PhoneAttribute as f, type CurrencyAttribute as g, type Option as h, type LocationAttribute as i, type TimestampAttribute as j, type SingleRelationAttribute as k, type MultiRelationAttribute as l, type RelationTarget as m, type RatingAttribute as n, type ObjectDefinition as o, type Field as p, type AttributeGroupField as q, type Tab as r, type AttributeType as s, type StatusGroup as t, type AttributeGroup as u, type NumberUnit as v, type DateFormat as w, type DateValue as x, type LocationGranularity as y, type DocumentType as z };