/// <reference types="node" />
import { BossObject, BossPrimitive } from "uparsecjs";
interface MapSerializationHandler<T> {
    serialize: (instance: T) => Promise<BossObject>;
    deserialize: (map: BossObject) => Promise<T>;
}
/**
 * The simple object that has sort of "copy constructor" that assigns all properties from an argument.
 * Useful to implement interfaces.
 */
export declare class CaseObject {
    constructor(props: any);
}
export interface MapSerializable {
    toMap(): Promise<BossObject>;
}
interface MapDeserializable<T> extends Function {
    fromMap(params: BossObject): Promise<T>;
}
export declare class MapSerializer {
    static Exception: {
        new (message?: string | undefined): {
            name: string;
            message: string;
            stack?: string | undefined;
        };
        captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
        stackTraceLimit: number;
    };
    static NotFound: {
        new (message?: string | undefined): {
            name: string;
            message: string;
            stack?: string | undefined;
        };
        captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
        stackTraceLimit: number;
    };
    static registerClass<T extends MapSerializable>(cls: MapDeserializable<T>, overrideName?: string): void;
    static registerCaseObject<T extends {
        new (props: any): CaseObject;
    }>(cls: T, overrideName?: string): void;
    static register<T>(name: string, handler: MapSerializationHandler<T>): void;
    static deserialize<T>(serialized: BossObject): Promise<T>;
    static serializeAny(source: any): Promise<BossPrimitive>;
    static deserializeAny(source: BossPrimitive): Promise<any>;
    /**
     *
     * @param source
     */
    static serialize(source: any): Promise<BossObject | BossPrimitive>;
    static toBoss(source: any): Promise<Uint8Array>;
    /**
     * Unpack boss binary and deserialize its root object or object at some path.
     * @param allowNotTyped use [[deserializeAny]] instead of [[deserialize]], to restore structures without `$` type tag
     * @param packed binary boss-packed data
     * @param path if present, specify the path inside unpacked data to the object to unpack.
     * @return promise to the unpacked object.
     * @throws NotFound if path does not existing in the unpacked object
     * @throws Exception if deserialization failed
     */
    static deserializeBoss<T>(allowNotTyped: boolean | undefined, packed: Uint8Array, ...path: string[]): Promise<T>;
    static fromBoss<T>(packed: Uint8Array, ...path: string[]): Promise<T>;
    static anyFromBoss<T>(packed: Uint8Array, ...path: string[]): Promise<T>;
}
/**
 * Decorator to register a class as MapSerializable providing it meets interface requirements. Works only
 * if the class constructor name is the same as a type tag. If not, use direct registration with
 * [[MapSerializer.registerClass]] for example.
 * @param cls class to register
 */
export declare function Serializable(cls: MapDeserializable<MapSerializable>): void;
export declare function fromBoss<T>(packed: Uint8Array, ...path: string[]): Promise<T>;
export declare function toBoss(source: Function | MapSerializable): Promise<Uint8Array>;
export declare type SerializedSet<T> = {
    $: 'Set';
    data: T[];
};
export {};