import type { Datetime, GoogleMapObject, IMediaObject, IRichtext, JsonArray, JsonValue, Mandatory, RawDocument } from '@levo.libraries/types';
import type { LemaCollectionRelationship, LemaRelationOnDelete } from './relation';
/**
 * Lema Field Management System
 *
 * Provides comprehensive field type definitions and utilities for managing
 * Lema (Levo Extended Metadata Architecture) fields. Supports various
 * field types including primitives, arrays, relationships, and complex
 * nested structures.
 *
 * Key Features:
 * - Field type definitions with validation rules
 * - Relationship management between collections
 * - Interface generation from field definitions
 * - Type-safe field option handling
 * - Support for complex nested structures
 *
 * Field Types Supported:
 * - **Primitives**: string, number, boolean, date, identifier
 * - **Arrays**: array-string, array-number, array-date, etc.
 * - **Files**: file, array-file with media object support
 * - **Locations**: location, array-location with Google Maps integration
 * - **Rich Text**: richtext with HTML/text/JSON support
 * - **Relationships**: collection with m2o, o2m, m2m relationships
 * - **Complex**: record (nested), group (repeated nested)
 *
 * Dependencies:
 * - @levo.libraries/types - Core type definitions
 * - @levo.libraries/utilities - Utility functions for data transformation
 * - date-fns - Date formatting utilities
 *
 * Integration Points:
 * - Used by Lema ORM for schema generation
 * - Used by validation services for type checking
 * - Used by form builders for UI generation
 * - Used by export utilities for data transformation
 *
 * @example
 * ```typescript
 * // Define a user field with relationship
 * const userField: LemaField = {
 *   key: 'user',
 *   kind: 'collection',
 *   field_interface: 'CollectionWidget',
 *   options: {
 *     relationship: 'm2o',
 *     collection_key: 'users',
 *     on_delete: 'SET_NULL'
 *   },
 *   // ... other field properties
 * };
 * ```
 */
type field = {
    id: string;
    collection_id: string;
    section_id: string;
    key: string;
    kind: string;
    field_interface: string;
    options: JsonValue;
    fields: JsonValue;
    default_value: JsonValue | null;
    label: string;
    helper_text: string;
    hidden: boolean;
    secret: boolean;
    editable: boolean;
    readonly: boolean;
    allow_public_view: boolean;
    allow_public_submit: boolean;
    sort_order: number;
    required: boolean;
    unique: boolean;
    min: JsonValue | null;
    max: JsonValue | null;
    formats: JsonArray;
    values: JsonArray;
    created_at: Date;
    updated_at: Date;
};
export declare const field_relationship: {
    m2m: "m2m";
    m2o: "m2o";
    o2m: "o2m";
};
export interface LemaFieldOptions {
    /**
     * Collection Options
     */
    collection_key?: string;
    collection_id?: string;
    reference_field_key?: string;
    label_field_key?: string;
    current_have_many_connected?: boolean;
    connected_have_many_current?: boolean;
    relationship?: LemaCollectionRelationship | string;
    on_delete?: LemaRelationOnDelete;
    /**
     * Slug Options
     */
    slug?: string;
    /**
     * Dropdown Options
     */
    custom_input?: boolean;
    /**
     * Verification Options (EmailWidget/PhoneWidget)
     */
    verification_required?: boolean;
    /**
     * TTL (time-to-live) in seconds for date fields.
     * MongoDB will automatically delete documents when the date field value is reached.
     * Set to 0 to expire documents exactly at the field's datetime value.
     * Only applies to date fields.
     *
     * @example
     * expires_at: { kind: 'date', options: { ttl_seconds: 0 } }
     */
    ttl_seconds?: number;
    /**
     * Explicitly create a regular MongoDB index on this field.
     * Use for date/boolean fields that are actively queried and need an index.
     * Without this, date and boolean fields are NOT auto-indexed.
     *
     * @example
     * starts_at: { kind: 'date', options: { index: true } }
     */
    index?: true;
}
export declare const FieldInterfaceList: readonly ["CollectionWidget", "ArrayWidget", "RecordWidget", "IdentifierWidget", "TextWidget", "TextareaWidget", "MultiTextWidget", "EmailWidget", "URLWidget", "CurrencyWidget", "NumberWidget", "PhoneWidget", "SlugWidget", "JSONWidget", "RichTextWidget", "BlogWidget", "DateWidget", "TimeWidget", "DateTimeWidget", "RadioWidget", "CheckboxWidget", "ToggleCheckboxWidget", "SwitchWidget", "DropdownWidget", "MultiDropdownWidget", "ImageUploadWidget", "MultiImageUploadWidget", "MediaUploadWidget", "FileUploadWidget", "MultiFileUploadWidget", "VideoUploadWidget", "GeocoderWidget", "MultiGeocoderWidget"];
export type LemaFieldInterface = (typeof FieldInterfaceList)[number];
export declare const field_interface: {
    CollectionWidget: "CollectionWidget";
    ArrayWidget: "ArrayWidget";
    RecordWidget: "RecordWidget";
    IdentifierWidget: "IdentifierWidget";
    TextWidget: "TextWidget";
    TextareaWidget: "TextareaWidget";
    MultiTextWidget: "MultiTextWidget";
    EmailWidget: "EmailWidget";
    URLWidget: "URLWidget";
    CurrencyWidget: "CurrencyWidget";
    NumberWidget: "NumberWidget";
    PhoneWidget: "PhoneWidget";
    SlugWidget: "SlugWidget";
    JSONWidget: "JSONWidget";
    RichTextWidget: "RichTextWidget";
    BlogWidget: "BlogWidget";
    DateWidget: "DateWidget";
    TimeWidget: "TimeWidget";
    DateTimeWidget: "DateTimeWidget";
    RadioWidget: "RadioWidget";
    CheckboxWidget: "CheckboxWidget";
    ToggleCheckboxWidget: "ToggleCheckboxWidget";
    SwitchWidget: "SwitchWidget";
    DropdownWidget: "DropdownWidget";
    MultiDropdownWidget: "MultiDropdownWidget";
    ImageUploadWidget: "ImageUploadWidget";
    MultiImageUploadWidget: "MultiImageUploadWidget";
    MediaUploadWidget: "MediaUploadWidget";
    FileUploadWidget: "FileUploadWidget";
    MultiFileUploadWidget: "MultiFileUploadWidget";
    VideoUploadWidget: "VideoUploadWidget";
    GeocoderWidget: "GeocoderWidget";
    MultiGeocoderWidget: "MultiGeocoderWidget";
};
export declare const FieldKindList: readonly ["collection", "record", "group", "string", "number", "date", "boolean", "json", "file", "array-json", "array-string", "array-number", "array-date", "array-boolean", "array-location", "array-file", "location", "richtext", "identifier"];
export type LemaFieldKind = (typeof FieldKindList)[number];
export declare const kind_defaults: Record<LemaFieldKind, any>;
export declare const TRUE: true;
export declare const FALSE: false;
export declare const field_kind: {
    'array-boolean': "array-boolean";
    'array-date': "array-date";
    'array-file': "array-file";
    'array-json': "array-json";
    'array-location': "array-location";
    'array-number': "array-number";
    'array-string': "array-string";
    boolean: "boolean";
    collection: "collection";
    date: "date";
    file: "file";
    group: "group";
    identifier: "identifier";
    json: "json";
    location: "location";
    number: "number";
    record: "record";
    richtext: "richtext";
    string: "string";
};
type IFieldExpanded = Omit<field, 'fields'> & {
    fields: LemaField[];
};
export type LemaField = Mandatory<Omit<IFieldExpanded, 'kind' | 'options'>, 'key'> & {
    kind: LemaFieldKind;
    options?: LemaFieldOptions;
};
export type LemaRoot = Record<string, Omit<LemaField, 'key' | 'fields'> & {
    fields?: LemaRoot;
}>;
export type FieldValueType = {
    identifier: string;
    json: RawDocument;
    'array-json': RawDocument[];
    'array-location': GoogleMapObject.Root[];
    location: GoogleMapObject.Root;
    file: IMediaObject;
    'array-file': IMediaObject[];
};
export type NonNullableKeys<T> = {
    [K in keyof T]: Exclude<T[K], null>;
};
export type ExtractTypeKeys<RootType, ExtractType> = {
    [K in keyof RootType as RootType[K] extends ExtractType ? K : never]: RootType[K];
};
type Optional<T, RequiredFlag> = RequiredFlag extends true ? T : T | null;
type ScalarKindMap<RequiredFlag> = {
    identifier: string;
    string: string;
    number: Optional<number, RequiredFlag>;
    boolean: Optional<boolean, RequiredFlag>;
    date: Optional<Datetime, RequiredFlag>;
    json: Optional<RawDocument, RequiredFlag>;
    file: Optional<IMediaObject, RequiredFlag>;
    location: Optional<GoogleMapObject.Root, RequiredFlag>;
    richtext: IRichtext;
};
type ArrayKindMap = {
    'array-string': string[];
    'array-number': number[];
    'array-boolean': boolean[];
    'array-date': Datetime[];
    'array-json': RawDocument[];
    'array-file': IMediaObject[];
    'array-location': GoogleMapObject.Root[];
};
type RelationshipKindMap<Options, RequiredFlag> = Options['relationship'] extends 'm2o' ? Optional<string, RequiredFlag> : Options['relationship'] extends 'm2m' ? string[] : Options['relationship'] extends 'o2m' ? never : undefined;
type ComplexKindMap<T, RequiredFlag> = {
    record: Optional<LemaInterface<T['fields']>, RequiredFlag>;
    group: LemaInterface<T['fields']>[];
};
type FieldKindMap<T> = T extends {
    kind: keyof ScalarKindMap<any>;
} ? ScalarKindMap<T['required']>[T['kind']] : T extends {
    kind: keyof ArrayKindMap;
} ? ArrayKindMap[T['kind']] : T extends {
    kind: 'collection';
} ? RelationshipKindMap<T['options'], T['required']> : T extends {
    kind: keyof ComplexKindMap<T, any>;
} ? ComplexKindMap<T, T['required']>[T['kind']] : never;
export type LemaInterface<T> = {
    [K in keyof T as T[K]['options']['relationship'] extends 'o2m' ? never : K]: FieldKindMap<T[K]>;
};
export type LemaInterfaceUpdate<T> = Omit<Partial<LemaInterface<T>>, '_id'>;
export type LemaInterfaceCreate<T> = (keyof {
    [K in keyof T as T[K]['required'] extends true ? K : never]: LemaInterface<T>[K];
} extends never ? {} : {
    [K in keyof T as T[K]['required'] extends true ? K : never]: LemaInterface<T>[K];
}) & {
    [K in keyof T as T[K]['required'] extends true ? never : K]?: LemaInterface<T>[K];
};
export {};