import { Injector, Type } from '../di';
import { Renderable } from '../dom';
import { Serializer, Serialized } from './Serializer';
import { ReversibleMap } from '../utils';
import { ConfiguredSerializer } from './ConfiguredSerializer';
import { RenderableConstructorArg } from '../common';
export interface Constructable<T> {
    constructor: Function;
}
export declare type BaseSerializer = Serializer<Renderable, Serialized>;
export declare type SerializerConstructor<T extends BaseSerializer> = new (...args: any[]) => T;
export declare type BaseSerializerArg<T extends BaseSerializer = any> = T | SerializerConstructor<T> | ConfiguredSerializer<SerializerConstructor<T>, any>;
export interface SerializerContainerConfig {
    /**
     * An injector to use as the parent injector.
     * @type {Injector}
     */
    injector?: Injector;
}
/**
 * A container for running and determining serializers.
 * @export
 * @class SerializerContainer
 * @example
 *
 * const container = new SerializerContainer();
 *
 * class MyClass {}
 *
 * const mySerializer = new GenericSerializer('MyClass', MyClass);
 *
 * container.registerSerializer(MyClass, mySerializer);
 * container.serialize(new MyClass()); // => { name: 'MyClass' }
 * container.deserialize({ name: 'MyClass' }); // => MyClass
 */
export declare class SerializerContainer {
    protected _injector: any;
    protected _serializers: Map<Type<any>, BaseSerializerArg<any>>;
    protected _classMap: ReversibleMap<Type<any>, string>;
    protected _instanceCache: WeakMap<any, Serializer<any, any>>;
    /**
     * Creates an instance of SerializerContainer.
     * @param {SerializerContainerConfig} [config={}]
     */
    constructor(config?: SerializerContainerConfig);
    /**
     * Registers a serializer with the container.
     * @param {Type<any>} _Class
     * @param {(BaseSerializer|Type<BaseSerializer>)} serializer
     * @param {{ skipRegister?: boolean }} [options={}]
     */
    registerSerializer<R extends Renderable, T extends Serializer<R, any>>(_Class: new (...args: any[]) => R, serializer: BaseSerializerArg<T>, options?: {
        skipRegister?: boolean;
    }): void;
    constructSerializer<T extends BaseSerializer>(serializer: BaseSerializerArg<T>): T;
    /**
     * Registers a class that can be identified by a string representation.
     * @param {string} name
     * @param {Type<any>} _Class
     */
    registerClass(name: string, _Class: Type<any>): void;
    /**
     * Registers multiple classes that can be identified by a string representation.
     * @param {{ [key:string]: Type<any> }} [classes={}]
     */
    registerClasses(classes?: {
        [key: string]: Type<any>;
    }): void;
    /**
     * Resolves a class to it's registered string representation.
     * @param {Type<any>} _Class
     * @returns {(string|null)}
     */
    resolveClassString(_Class: Type<any>): string | null;
    /**
     * Resolves a serializer from a serialized node.
     * @param {Serialized} node
     * @returns {(BaseSerializer|null)}
     */
    resolveFromSerialized(node: Serialized): Serializer<any, any> | null;
    /**
     * Resolves a serializer from a class.
     * @param {Type<any>} _Class
     * @returns {(BaseSerializer|null)}
     */
    resolveFromClass(_Class: Type<any>): Serializer<any, any> | null;
    /**
     * Resolves a serializer from an instance of a registered class.
     * @param {(Renderable & Constructable<any>)} instance
     * @returns {(BaseSerializer|null)}
     */
    resolveFromInstance(instance: Renderable & Constructable<any>): BaseSerializer | null;
    /**
     * Resolves a string to a registered class.
     * @param {string} name
     * @returns {(Type<any>|null)}
     */
    resolveClass<T>(name: string): Type<T> | null;
    /**
     * Serializes a class instance using the registered serializer for that class.
     * @template R The class type.
     * @template S The serialized type.
     * @param {R} instance
     * @returns {S} The serialized node.
     */
    serialize<R extends Renderable & Constructable<any>, S extends Serialized>(instance: R): S;
    /**
     * Deserializes a serialized node using the registered serializer for that node type.
     * @template R The class type.
     * @template S The serialized type.
     * @param {S} serialized
     * @returns {R} The renderable argument.
     */
    deserialize<R extends Renderable, S extends Serialized>(serialized: S): RenderableConstructorArg<R>;
    serializeList<R extends Renderable & Constructable<any>, S extends Serialized>(instances: R[]): S[];
    deserializeList<R extends Renderable, S extends Serialized>(serialized: S[]): RenderableConstructorArg<R>[];
    isExcluded<R extends Renderable & Constructable<any>>(instance: R): boolean;
    /**
     * Resolves a token with this containers injector.
     * @template T The return type.
     * @param {*} token
     * @returns {(T|null)}
     */
    resolve<T>(token: any, _throw?: boolean): T;
    private _deserialize;
    private _serialize;
}