import { Index } from "./index";
import { CollectionOptions } from "./collectionOptions";
import { IdentityGenerator } from "../config/configuration";
export declare namespace MappingModel {
    interface Mapping {
        flags: MappingFlags;
        hasFlags(flags: MappingFlags): boolean;
    }
    interface EnumMembers {
        [name: string]: number;
    }
    interface Property {
        name: string;
        flags: PropertyFlags;
        nullable?: boolean;
        field: string;
        inverseOf: string;
        mapping: Mapping;
        setFlags(flags: PropertyFlags): void;
    }
    const enum MappingFlags {
        Array = 1,
        Boolean = 2,
        Class = 4,
        Date = 8,
        Enum = 16,
        Number = 32,
        Object = 64,
        RegExp = 128,
        String = 256,
        Tuple = 512,
        Entity = 1024,
        Embeddable = 2048,
        InheritanceRoot = 4096,
        Converter = 8192,
        Buffer = 16384,
        Iterable = 32768,
        Virtual = 65536,
        Immutable = 131072,
        ImmutableEmbeddable = 133120,
    }
    const enum PropertyFlags {
        None = 0,
        Ignored = 1,
        CascadeSave = 2,
        CascadeRemove = 4,
        CascadeDetach = 8,
        CascadeRefresh = 16,
        CascadeMerge = 32,
        CascadeAll = 62,
        InverseSide = 64,
        OrphanRemoval = 256,
        WriteOnly = 512,
        FetchEager = 1024,
        FetchLazy = 2048,
        Parent = 4096,
        All = 8063,
        WalkEntities = 8192,
        Dereference = 16384,
    }
    interface ObjectMapping extends Mapping {
        addProperty(property: Property): void;
        getProperty(name: string): Property;
        validateProperty(property: Property): string;
    }
    interface ClassMapping extends ObjectMapping {
        name: string;
        discriminatorField: string;
        discriminatorValue: string;
        classConstructor: Function;
        hasSubClasses: boolean;
        hasBaseClass: boolean;
        setDiscriminatorValue(value: string): void;
    }
    interface EntityMapping extends ClassMapping {
        collectionName: string;
        databaseName: string;
        flushPriority: FlushPriority;
        indexes: Index[];
        collectionOptions: CollectionOptions;
        identity: IdentityGenerator;
        changeTracking: ChangeTrackingType;
        versioned: boolean;
        versionField: string;
        addIndex(index: Index): void;
    }
    function createProperty(name: string, mapping: Mapping): Property;
    function createArrayMapping(elementMapping: Mapping): Mapping;
    function createBooleanMapping(): Mapping;
    function createClassMapping(baseClass?: ClassMapping): ClassMapping;
    function createDateMapping(): Mapping;
    function createEntityMapping(baseClass?: EntityMapping): EntityMapping;
    function createEnumMapping(members: EnumMembers, ignoreCase?: boolean): Mapping;
    function createNumberMapping(): Mapping;
    function createObjectMapping(): ObjectMapping;
    function createRegExpMapping(): Mapping;
    function createStringMapping(): Mapping;
    function createConverterMapping(converter: PropertyConverter): Mapping;
    function createBufferMapping(): Mapping;
    function createTupleMapping(elementMappings: Mapping[]): Mapping;
}
export interface PropertyConverter {
    convertToDocumentField(property: any): any;
    convertToObjectProperty(field: any): any;
    areEqual(field1: any, field2: any): boolean;
}
export declare const enum ChangeTrackingType {
    None = 0,
    DeferredImplicit = 1,
    DeferredExplicit = 2,
}
export declare const enum FlushPriority {
    High = 100,
    MediumHigh = 75,
    Medium = 50,
    MediumLow = 25,
    Low = 0,
}
export declare const enum CascadeFlags {
    None = 0,
    Save = 2,
    Remove = 4,
    Detach = 8,
    Refresh = 16,
    Merge = 32,
    All = 62,
}
export declare const enum FetchType {
    Eager = 1024,
    Lazy = 2048,
}