import { ClassSchema, PropertyCompilerSchema, PropertySchema } from "./decorators";
import { ClassType } from "@marcj/estdlib";
export declare let moment: any;
/**
 * This is used withing JIT functions.
 * @hidden
 */
export declare function findParent<T>(parents: any[], parentType: ClassType<T>): T | undefined;
/**
 * This resolves the PropertyCompilerSchema for a property path.
 *
 * A property path can be a deep path, separated with dots. This function makes sure to return the
 * correct PropertyCompilerSchema so that a correct compiler can be built to convert this type.
 */
export declare function resolvePropertyCompilerSchema<T>(schema: ClassSchema<T>, propertyPath: string): PropertyCompilerSchema;
/**
 * A handy utility class that allows fast access to a JitPropertyConverter class.
 */
export declare class CacheJitPropertyConverter {
    readonly fromFormat: string;
    readonly toFormat: string;
    protected cache: Map<ClassType<any>, JitPropertyConverter>;
    constructor(fromFormat: string, toFormat: string);
    getJitPropertyConverter(classType: ClassType<any>): JitPropertyConverter;
}
/**
 * Creates a new JIT compiled function to convert given property schema for certain paths.
 * Paths can be deep paths making it possible to convert patch-like/mongo structure
 *
 * Note: If fromFormat -> toFormat has no compiler templates registered,
 * the generated function does virtually nothing.
 */
export declare class JitPropertyConverter {
    readonly fromFormat: string;
    readonly toFormat: string;
    protected schema: ClassSchema<any>;
    protected cacheJitPropertyMap: WeakMap<PropertyCompilerSchema, any>;
    constructor(fromFormat: string, toFormat: string, classType: ClassType<any>);
    convert(path: string, value: any, parents?: any[]): any;
    convertProperty(property: PropertyCompilerSchema, value: any, parents?: any[]): any;
}
/**
 *
 * Creates a new JIT compiled function to convert given property schema. Deep paths are not allowed.
 */
export declare function createJITConverterFromPropertySchema(fromFormat: string, toFormat: string, property: PropertySchema): (value: any, parents?: any[]) => any;
export declare class ToClassState {
    onFullLoadCallbacks: (() => void)[];
}
export declare function createClassToXFunction<T>(classType: ClassType<T>, toFormat: string | 'plain'): (instance: T) => any;
export declare function createXToClassFunction<T>(classType: ClassType<T>, fromTarget: string | 'plain'): (data: {
    [name: string]: any;
}, parents?: any[], state?: ToClassState) => T;
export declare function jitPlainToClass<T>(classType: ClassType<T>, data: any, parents?: any[]): T;
export declare function jitClassToPlain<T>(classType: ClassType<T>, instance: T): Partial<T>;
export declare function jitPartial<T, K extends keyof T>(fromFormat: string, toFormat: string, classType: ClassType<T>, partial: {
    [name: string]: any;
}, parents?: any[]): Partial<{
    [F in K]: any;
}>;
export declare function jitPartialClassToPlain<T, K extends keyof T>(classType: ClassType<T>, partial: {
    [name: string]: any;
}): Partial<{
    [F in K]: any;
}>;
export declare function jitPartialPlainToClass<T, K extends keyof T>(classType: ClassType<T>, partial: {
    [name: string]: any;
}, parents?: any[]): Partial<{
    [F in K]: any;
}>;