import { IModelType, IModelTypeItem, IModelTypeCompositeBuilder, IModelTypeEntry, IModelTypeComposite, IModelParseContext, IModelTypeConstraint, Predicate } from "./model.api";
import { ModelTypeConstrainable, ModelConstraints, ModelTypeConstraintOptional } from "./model.base";
export declare class ModelTypeAny extends ModelTypeConstrainable<any> implements IModelTypeItem<any> {
    private _constructFun;
    constructor(name: string, construct?: () => any, constraints?: ModelConstraints<any>);
    protected _clone(constraints: ModelConstraints<any>): this;
    protected _kind(): string;
    asItemType(): IModelTypeItem<any>;
    fromString(text: string): any;
    asString(obj: any): string;
    lowerBound(): IModelTypeConstraint<any>;
    upperBound(): IModelTypeConstraint<any>;
    possibleValues(): any[];
    create(): any;
    parse(ctx: IModelParseContext): any;
    validate(ctx: IModelParseContext): void;
    unparse(val: any): any;
}
export declare class ModelTypeObject<T> extends ModelTypeConstrainable<T> implements IModelTypeCompositeBuilder<T> {
    private _constructFun;
    private _entries;
    private _entriesByName;
    private _allowAdditional;
    constructor(name: string, construct?: () => T, constraints?: ModelConstraints<T>);
    asCompositeType(): IModelTypeComposite<T> | undefined;
    protected _clone(constraints: ModelConstraints<T>): this;
    addConstraint(c: IModelTypeConstraint<T>): IModelTypeCompositeBuilder<T>;
    addItem(key: string, type: IModelType<any>, required?: boolean): IModelTypeCompositeBuilder<T>;
    findItem(key: string): IModelTypeEntry;
    extend<X>(type: IModelTypeComposite<X>): IModelTypeCompositeBuilder<T>;
    asItemType(): IModelTypeItem<T>;
    itemType(name: string | number): IModelType<any>;
    keyPathType(keyPath: string | string[]): IModelType<any> | undefined;
    keyPathItem(keyPath: string | string[]): IModelTypeEntry | undefined;
    slice(names: string[] | number[]): IModelTypeComposite<T>;
    _slice(names: string[] | number[]): ModelTypeObject<T>;
    withReplacedItems(replaceItems: {
        [key: string]: IModelType<any> | undefined;
    }, options?: {
        name?: string;
    }): ModelTypeObject<any>;
    get items(): IModelTypeEntry[];
    parse(ctx: IModelParseContext): T;
    validate(ctx: IModelParseContext): void;
    unparse(value: T): any;
    _create(): T;
    create(): T;
    createEmpty(): T;
    possibleValuesForContextData(name: string | number, data: any): any[];
    protected _kind(): string;
}
export type ComparisonOp = "=" | "==" | "<" | "<=" | ">" | ">=" | "!=";
export type UnaryOp = "!" | "!!" | 'true' | 'false' | true | false;
export interface IComparePropertiesConstraintOptions {
    properties: string | string[];
    op: ComparisonOp;
}
export declare class ModelTypeConstraintCompareProperties extends ModelTypeConstraintOptional<any> {
    constructor(fieldsOrSelf: string[] | IComparePropertiesConstraintOptions | ModelTypeConstraintCompareProperties, op?: ComparisonOp);
    protected _id(): string;
    checkAndAdjustValue(val: any, ctx: IModelParseContext): any;
    usedItems(): string[];
    private _fields;
    private _op;
    private _comparator;
}
export interface IEqualPropertiesConstraintOptions {
    properties: string | string[];
}
export declare class ModelTypeConstraintEqualProperties extends ModelTypeConstraintOptional<any> {
    constructor(fieldsOrSelf: string[] | IEqualPropertiesConstraintOptions | ModelTypeConstraintEqualProperties);
    private _isConstraintEqualFields;
    protected _id(): string;
    checkAndAdjustValue(val: any, ctx: IModelParseContext): any;
    usedItems(): string[];
    private _fields;
}
export type IConditionOptions = IComparisonOptions | IUnaryOpOptions | boolean | 'true' | 'false';
export interface IComparisonOptions {
    property: string;
    value: string | string[] | number | number[];
    op?: ComparisonOp;
    invert?: boolean;
}
export interface IUnaryOpOptions {
    property: string;
    op: UnaryOp;
    invert?: boolean;
}
/**
 * Creates a predicate for a conjunction of conditions.
 */
export declare function createPredicateAnd(condition: IConditionOptions | IConditionOptions[]): Predicate<any>;
/**
 * Creates a predicate for a condition in disjunctive normal form.
 */
export declare function createPredicateOrOfAnd(condition: IConditionOptions | IConditionOptions[][]): Predicate<any>;
export declare function createSinglePredicate(condition: IConditionOptions): Predicate<any>;
export interface IConditionalValueConstraintOptions {
    condition: IConditionOptions | IConditionOptions[];
    properties: string | string[];
    possibleValue?: string | number | string[] | number[];
    clearOtherwise: boolean;
}
export interface IConditionalValueConstraintSettings {
    id: string;
    predicate: (x: any) => boolean;
    valueCheck: (x: any) => boolean;
    properties: string[];
    possibleValues: any[];
    clearOtherwise: boolean;
    condition: IConditionOptions | IConditionOptions[];
}
export declare class ModelTypeConstraintConditionalValue extends ModelTypeConstraintOptional<any> {
    constructor(optionsOrSelf: IConditionalValueConstraintOptions | ModelTypeConstraintConditionalValue);
    private _isConstraintConditionalValue;
    protected _id(): string;
    checkAndAdjustValue(val: any, ctx: IModelParseContext): Date;
    possibleValuesForContextData?(name: string | number, data: any): any[];
    usedItems(): string[];
    slice(fields: string[] | number[]): ModelTypeConstraintConditionalValue;
    private _settings;
}
/**
 * can be used for validation, only, not for value modification
 */
export declare class ModelTypePropertyConstraint extends ModelTypeConstraintOptional<any> {
    constructor(propertyOrThis: string | ModelTypePropertyConstraint, constraint: IModelTypeConstraint<any>);
    _id(): string;
    checkAndAdjustValue(val: any, ctx: IModelParseContext): any;
    usedItems(): string[];
    private _property;
    private _constraint;
}
export declare class ModelTypeConstraintOneOf<T> implements IModelTypeConstraint<T> {
    constructor(types: IModelType<T>[]);
    checkAndAdjustValue(v: T, c: IModelParseContext): T;
    get id(): string;
    private _types;
}