import { IObjectWillChange, IObjectChange } from 'mobx';
import { ComplexType, IType, IComplexType } from '../Type';
import { TypeFlags } from '../type-flags';
import { ValueProperty } from '../property-types/ValueProperty';
import { IJsonPatch, IStateTreeNode } from '../../core/NodeUtils';
import { IContext, IValidationResult } from '../type-checker';
import { ObjectNode } from '../../core/ObjectNode';
import { INode } from '../../core/interface';
export declare type ModelTypeConfig = {
    name?: string;
    extra?: {
        [K: string]: any;
    };
    properties?: {
        [K: string]: IType<any, any>;
    };
    initializers?: ReadonlyArray<((instance: any) => any)>;
    preProcessor?: (snapshot: any) => any;
};
export declare class ObjectType<S = any, T = any> extends ComplexType<S, T> {
    readonly shouldAttachNode: boolean;
    readonly flags: TypeFlags;
    readonly initializers: ((instance: any) => any)[];
    properties: {
        [K: string]: IType<any, any>;
    };
    extra: {
        [K: string]: any;
    };
    modelConstructor: new () => any;
    private _props;
    private propsKeys;
    private preProcessor;
    private _identifierProp;
    constructor(opts: ModelTypeConfig);
    named(name: string): IModelType<S, T>;
    extras(extra: {
        [k: string]: any;
    }): IModelType<S, T>;
    props<SP, TP>(properties: {
        [K in keyof TP]: IType<any, TP[K]>;
    } & {
        [K in keyof SP]: IType<SP[K], any>;
    }): IModelType<S & SP, T & TP>;
    instantiate(parent: ObjectNode | null, subpath: string, environment: any, snapshot: any): INode;
    createNewInstance: () => Object;
    finalizeNewInstance: (node: ObjectNode, snapshot: any) => void;
    preProcessSnapshot(preProcessor: (snapshot: any) => S): IModelType<S, T>;
    willChange(change: IObjectWillChange): IObjectWillChange | null;
    didChange: (change: IObjectChange) => void;
    applySnapshot(node: ObjectNode, snapshot: any): void;
    applyPatchLocally(node: ObjectNode, subpath: string, patch: IJsonPatch): void;
    applySnapshotPreProcessor(snapshot: any): any;
    getValue(node: ObjectNode): any;
    getDefaultSnapshot(): any;
    getSnapshot(node: ObjectNode): any;
    hasNestedFields(): boolean;
    getChildren(node: ObjectNode): INode[];
    getChildField(node: ObjectNode, key: string): INode;
    getChildType(key: string): IType<any, any>;
    readonly identityProperty: ValueProperty;
    getValueProperties(): ValueProperty[];
    removeChild(node: ObjectNode, subpath: string): void;
    isValidSnapshot(value: any, context: IContext): IValidationResult;
    cloneAndEnhance(opts: ModelTypeConfig): ObjectType<any, any>;
    actions<A extends {
        [name: string]: Function;
    }>(fn: (self: T) => A): IModelType<S, T & A>;
    instantiateActions(self: T, actions: {
        [name: string]: Function;
    }): void;
    views<V extends Object>(fn: (self: T) => V): IModelType<S, T & V>;
    instantiateViews(self: T, views: Object): void;
    volatile<TP>(fn: (self: T) => TP): IModelType<S, T & TP>;
    instantiateVolatileState(self: T, state: Object): void;
    extend<A extends {
        [name: string]: Function;
    } = {}, V extends Object = {}, VS extends Object = {}>(fn: (self: T & IStateTreeNode) => {
        actions?: A;
        views?: V;
        state?: VS;
    }): IModelType<S, T & A & V & VS>;
    parseModelProps(): void;
    private forAllProps(fn);
    describe(): string;
}
export declare function model<T = {}>(name: string, properties?: IModelProperties<T>): IModelType<Snapshot<T>, IModelPros<T>>;
export declare function model<T = {}>(properties?: IModelProperties<T>): IModelType<Snapshot<T>, IModelPros<T>>;
export declare type IModelProperties<T> = {
    [K in keyof T]?: IType<any, T[K]> | T[K];
};
export declare type IModelVolatileState<T> = {
    [K in keyof T]?: ((self?: any) => T[K]) | T[K];
};
export declare type IModelPros<T> = {
    [K in keyof T]?: T[K];
};
export declare type Snapshot<T> = {
    [K in keyof T]?: Snapshot<T[K]> | T[K];
};
export interface IModelType<S, T> extends IComplexType<S, T & IStateTreeNode> {
    named(newName: string): IModelType<S, T>;
    extras(newExtra: {
        [k: string]: any;
    }): IModelType<S, T>;
    props<SP, TP>(props: {
        [K in keyof TP]?: IType<any, TP[K]> | TP[K];
    } & {
        [K in keyof SP]?: IType<SP[K], any> | SP[K];
    }): IModelType<S & Snapshot<SP>, T & TP>;
    views<V extends Object>(fn: (self: T & IStateTreeNode) => V): IModelType<S, T & IModelPros<V>>;
    actions<A extends {
        [name: string]: Function;
    }>(fn: (self: T & IStateTreeNode) => A): IModelType<S, T & IModelPros<A>>;
    volatile<TP>(fn: (self: T) => TP): IModelType<S, T & IModelPros<TP>>;
    extend<A extends {
        [name: string]: Function;
    } = {}, V extends Object = {}, VS extends Object = {}>(fn: (self: T & IStateTreeNode) => {
        actions?: A;
        views?: V;
        state?: VS;
    }): IModelType<S, T & IModelPros<A> & IModelPros<V> & IModelPros<VS>>;
    preProcessSnapshot(fn: (snapshot: any) => S): IModelType<S, T>;
}
export declare function compose<T1, S1, T2, S2, T3, S3>(t1: IModelType<T1, S1>, t2: IModelType<T2, S2>, t3?: IModelType<T3, S3>): IModelType<IStateTreeNode & T1 & T2 & T3, S1 & S2 & S3>;
export declare function compose<T1, S1, T2, S2, T3, S3>(name: string, t1: IModelType<T1, S1>, t2: IModelType<T2, S2>, t3?: IModelType<T3, S3>): IModelType<IStateTreeNode & T1 & T2 & T3, S1 & S2 & S3>;
export declare function compose<BASE_T, BASE_S, T, S>(name: string, baseType: IModelType<BASE_T, BASE_S>, properties: IModelProperties<T> & ThisType<IStateTreeNode & T & BASE_T>, volatileState: IModelVolatileState<S> & ThisType<IStateTreeNode & BASE_T & T & BASE_S & S>, operations: ThisType<BASE_T & T & BASE_S & S>): IModelType<IStateTreeNode & BASE_T & T, BASE_S & S>;
export declare function compose<BASE_T, BASE_S, T, S>(name: string, baseType: IModelType<BASE_T, BASE_S>, properties: IModelProperties<T> & ThisType<IStateTreeNode & T & BASE_T>, operations?: ThisType<BASE_T & T & BASE_S & S>): IModelType<IStateTreeNode & BASE_T & T, BASE_S & S>;
export declare function compose<BASE_T, BASE_S, T, S>(baseType: IModelType<BASE_T, BASE_S>, properties: IModelProperties<T> & ThisType<IStateTreeNode & T & BASE_T>, volatileState: IModelVolatileState<S> & ThisType<IStateTreeNode & BASE_T & T & BASE_S & S>, operations: ThisType<BASE_T & T & BASE_S & S>): IModelType<IStateTreeNode & BASE_T & T, BASE_S & S>;
export declare function compose<BASE_T, BASE_S, T, S>(baseType: IModelType<BASE_T, BASE_S>, properties: IModelProperties<T> & ThisType<IStateTreeNode & T & BASE_T>, operations?: ThisType<BASE_T & T & BASE_S & S>): IModelType<IStateTreeNode & BASE_T & T, BASE_S & S>;
export declare function getObjectType<S, T>(object: IStateTreeNode): ObjectType<S, T>;