export declare namespace Protocol {
    type TTypes = Message.UnsubscribeAll.Request | Message.Unsubscribe.Response | Message.Registration.Response | Disconnect | Message.Event.Options | Message | Message.Reconnection | Message.Reconnection.Request | Message.Reconnection.Response | Message.Event | Message.Event.Request | Message.Event.Response | Message.Subscribe | Message.Subscribe.Request | Message.Subscribe.Response | Message.Unsubscribe | Message.Unsubscribe.Request | Message.UnsubscribeAll | Message.UnsubscribeAll.Response | Message.Registration | Message.Registration.Request | Message.Demand | Message.Demand.FromExpectant | Message.Demand.FromExpectant.Request | Message.Demand.FromExpectant.Response | Message.Demand.FromRespondent | Message.Demand.FromRespondent.Request | Message.Demand.FromRespondent.Response | Message.Demand.Options | Message.Respondent | Message.Respondent.Bind | Message.Respondent.Bind.Request | Message.Respondent.Bind.Response | Message.Respondent.Unbind | Message.Respondent.Unbind.Request | Message.Respondent.Unbind.Response | Message.ToConsumer | EventDefinition | DemandDefinition | Subscription | ConnectionError | KeyValue;
    const KeysMapLeft: {
        [key: string]: any;
    };
    const KeysMapRight: {
        [key: string]: any;
    };
    const TypedEntitiesMap: {
        [key: string]: any;
    };
    const AdvancedTypes: {
        [key: string]: any;
    };
    interface IPrimitiveType<T> {
        tsType: string[];
        tsTypeDefault: string;
        binaryType: string;
        init: string;
        parse: (value: string | number | T) => T;
        serialize: (value: T) => string | number | boolean | T;
        validate: (value: string | number | T) => boolean;
        implementation?: () => {};
    }
    const PrimitiveTypes: {
        [key: string]: IPrimitiveType<any>;
    };
    namespace Packager {
        function join(...items: any[]): string | Uint8Array | Error;
        function split(source: string | Uint8Array): string[] | Uint8Array[] | Error;
        function isPackage(source: any): boolean;
    }
    namespace Json {
        namespace Impls {
            class Boolean {
                static toUint8(value: any): Uint8Array;
                static fromUint8(bytes: Uint8Array): boolean;
                static validate(value: number): Error | undefined;
            }
            class Float32 {
                static toUint8(int: any): Uint8Array;
                static fromUint8(bytes: Uint8Array): number;
                static validate(value: number): Error | undefined;
            }
            class Float64 {
                static toUint8(int: any): Uint8Array;
                static fromUint8(bytes: Uint8Array): number;
                static validate(value: number): Error | undefined;
            }
            class Int8 {
                static toUint8(int: any): Uint8Array;
                static fromUint8(bytes: Uint8Array): number;
                static validate(value: number): Error | undefined;
            }
            class Int16 {
                static toUint8(int: any): Uint8Array;
                static fromUint8(bytes: Uint8Array): number;
                static validate(value: number): Error | undefined;
            }
            class Int32 {
                static toUint8(int: any): Uint8Array;
                static fromUint8(bytes: Uint8Array): number;
                static validate(value: number): Error | undefined;
            }
            class Int64 {
                static toUint8(int: any): Uint8Array;
                static fromUint8(bytes: Uint8Array): number;
                static validate(value: number): Error | undefined;
            }
            class Uint8 {
                static fromAsciiStr(str: string): Uint8Array;
                static toAsciiStr(data: Uint8Array): string;
                static fromUtf8Str(str: string): Uint8Array;
                static toUtf8Str(bytes: Uint8Array): string;
                static toUint8(int: any): Uint8Array;
                static fromUint8(bytes: Uint8Array): number;
                static validate(value: number): Error | undefined;
            }
            class Uint16 {
                static toUint8(int: any): Uint8Array;
                static fromUint8(bytes: Uint8Array): number;
                static validate(value: number): Error | undefined;
            }
            class Uint32 {
                static toUint8(int: any): Uint8Array;
                static fromUint8(bytes: Uint8Array): number;
                static validate(value: number): Error | undefined;
            }
            class Uint64 {
                static toUint8(int: any): Uint8Array;
                static fromUint8(bytes: Uint8Array): number;
                static validate(value: number): Error | undefined;
            }
        }
        namespace Scheme {
            const Types: {
                int8: number;
                int16: number;
                int32: number;
                int64: number;
                uint8: number;
                uint16: number;
                uint32: number;
                uint64: number;
                float32: number;
                float64: number;
                boolean: number;
                asciiString: number;
                utf8String: number;
                object: number;
                array: number;
            };
            const TypesNames: {
                [x: number]: string;
            };
            const TypesSizes: {
                [x: number]: number;
            };
            const TypesProviders: {
                [x: number]: typeof Impls.Uint32 | typeof Impls.Boolean;
            };
            const LengthConvertor: {
                [x: number]: typeof Impls.Uint32.toUint8;
                object: typeof Impls.Uint32.toUint8;
            };
            const SizeDeclaration: {
                [x: number]: boolean;
            };
        }
        class Convertor {
            static encode(target: any, scheme: any, validation?: boolean): Uint8Array;
            static decode(target: Uint8Array, maxInteractionsCount?: number): any;
            private static _encodePrimitive;
            private static _isPrimitive;
            private static _getPrimitiveType;
        }
    }
    type TIncomeData = string | object | ArrayBuffer | number[] | Uint8Array;
    type TStringifyOutput = string | Uint8Array;
    class ProtocolState {
        private _debug;
        debug(value: boolean): void;
        isDebugged(): boolean;
    }
    const state: ProtocolState;
    enum EEntityType {
        root = "root",
        class = "class",
        namespace = "namespace",
        complex = "complex",
        primitive = "primitive",
        repeated = "repeated",
        reference = "reference",
        enum = "enum"
    }
    interface IProperty {
        name: string;
        type: EEntityType;
        optional: boolean;
        value: any;
    }
    const StandardTypes: string[];
    function _getPropNameAlias(propName: string, signature: string): string | Error;
    function _getPropName(alias: string, signature: string): string | Error;
    function _parse(source: TIncomeData, target?: any): TTypes | Error[];
    function _stringify(target: any, classRef: any): {
        [key: string]: any;
    } | Error[];
    function _JSONToBinary(target: any, signature: string): Uint8Array | Error;
    function _JSONFromBinary(data: Uint8Array): {} | Error;
    function getTypes(): {
        [key: string]: any;
    };
    function getJSONFromStr(str: string): {} | Error;
    function getJSONFromIncomeData(income: TIncomeData): {} | Error;
    function stringify(target: any, classRef: any): TStringifyOutput | Error;
    function parse(source: TIncomeData, target?: any): TTypes | Error;
    function parseFrom(source: TIncomeData, protocols: any | any[]): any;
    function typeOf(smth: any): string;
    function validateParams(params: any, classRef: any): Error[];
    function convertTypesToStandard(target: {
        [key: string]: any;
    }): {
        [key: string]: any;
    };
    function isInstanceOf(signature: string, target: any): boolean;
    class Root {
    }
    let ConvertedTypedEntitiesMap: {
        [key: string]: any;
    };
    let ReferencesMap: {
        [key: string]: any;
    };
    function init(): void;
    function getSignature(): string;
}
export declare class Message extends Protocol.Root {
    static getDescription(): {
        [key: string]: Protocol.IProperty;
    };
    static __signature: string;
    static getSignature(): string;
    static getProtocol(): any;
    __signature: string;
    getSignature(): string;
    getProtocol(): any;
    static parse(str: string | object): Protocol.TTypes | Error;
    stringify(): Protocol.TStringifyOutput | Error;
    static instanceOf(target: any): boolean;
    clientId: string;
    guid?: string;
    constructor(args: {
        clientId: string;
        guid?: string;
    });
}
export declare namespace Message {
    class Reconnection extends Message {
        static getDescription(): {
            [key: string]: Protocol.IProperty;
        };
        static __signature: string;
        static getSignature(): string;
        static getProtocol(): any;
        __signature: string;
        getSignature(): string;
        getProtocol(): any;
        static parse(str: string | object): Protocol.TTypes | Error;
        stringify(): Protocol.TStringifyOutput | Error;
        static instanceOf(target: any): boolean;
        constructor(args: {
            clientId: string;
            guid?: string;
        });
    }
    namespace Reconnection {
        class Request extends Reconnection {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            token: string;
            constructor(args: {
                clientId: string;
                guid?: string;
                token: string;
            });
        }
        class Response extends Reconnection {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            allowed: boolean;
            constructor(args: {
                clientId: string;
                guid?: string;
                allowed: boolean;
            });
        }
        enum Responses {
            ConnectionError = "ConnectionError"
        }
    }
    class Event extends Message {
        static getDescription(): {
            [key: string]: Protocol.IProperty;
        };
        static __signature: string;
        static getSignature(): string;
        static getProtocol(): any;
        __signature: string;
        getSignature(): string;
        getProtocol(): any;
        static parse(str: string | object): Protocol.TTypes | Error;
        stringify(): Protocol.TStringifyOutput | Error;
        static instanceOf(target: any): boolean;
        constructor(args: {
            clientId: string;
            guid?: string;
        });
    }
    namespace Event {
        class Request extends Event {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            event: EventDefinition;
            token: string;
            aliases?: Array<KeyValue>;
            options?: Message.Event.Options;
            constructor(args: {
                clientId: string;
                guid?: string;
                event: EventDefinition;
                token: string;
                aliases?: Array<KeyValue>;
                options?: Message.Event.Options;
            });
        }
        class Response extends Event {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            subscribers: number;
            constructor(args: {
                clientId: string;
                guid?: string;
                subscribers: number;
            });
        }
        enum Responses {
            ConnectionError = "ConnectionError"
        }
        class Options extends Protocol.Root {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            scope?: Message.Event.Options.Scope;
            constructor(args: {
                scope?: Message.Event.Options.Scope;
            });
        }
        namespace Options {
            enum Scope {
                local = "local",
                hosts = "hosts",
                clients = "clients",
                all = "all"
            }
        }
    }
    class Subscribe extends Message {
        static getDescription(): {
            [key: string]: Protocol.IProperty;
        };
        static __signature: string;
        static getSignature(): string;
        static getProtocol(): any;
        __signature: string;
        getSignature(): string;
        getProtocol(): any;
        static parse(str: string | object): Protocol.TTypes | Error;
        stringify(): Protocol.TStringifyOutput | Error;
        static instanceOf(target: any): boolean;
        constructor(args: {
            clientId: string;
            guid?: string;
        });
    }
    namespace Subscribe {
        class Request extends Subscribe {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            subscription: Subscription;
            token: string;
            constructor(args: {
                clientId: string;
                guid?: string;
                subscription: Subscription;
                token: string;
            });
        }
        class Response extends Subscribe {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            status: boolean;
            error?: string;
            constructor(args: {
                clientId: string;
                guid?: string;
                status: boolean;
                error?: string;
            });
        }
        enum Responses {
            ConnectionError = "ConnectionError"
        }
    }
    class Unsubscribe extends Message {
        static getDescription(): {
            [key: string]: Protocol.IProperty;
        };
        static __signature: string;
        static getSignature(): string;
        static getProtocol(): any;
        __signature: string;
        getSignature(): string;
        getProtocol(): any;
        static parse(str: string | object): Protocol.TTypes | Error;
        stringify(): Protocol.TStringifyOutput | Error;
        static instanceOf(target: any): boolean;
        constructor(args: {
            clientId: string;
            guid?: string;
        });
    }
    namespace Unsubscribe {
        class Request extends Unsubscribe {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            subscription: Subscription;
            token: string;
            constructor(args: {
                clientId: string;
                guid?: string;
                subscription: Subscription;
                token: string;
            });
        }
        class Response extends Unsubscribe {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            status: boolean;
            error?: string;
            constructor(args: {
                clientId: string;
                guid?: string;
                status: boolean;
                error?: string;
            });
        }
        enum Responses {
            ConnectionError = "ConnectionError"
        }
    }
    class UnsubscribeAll extends Message {
        static getDescription(): {
            [key: string]: Protocol.IProperty;
        };
        static __signature: string;
        static getSignature(): string;
        static getProtocol(): any;
        __signature: string;
        getSignature(): string;
        getProtocol(): any;
        static parse(str: string | object): Protocol.TTypes | Error;
        stringify(): Protocol.TStringifyOutput | Error;
        static instanceOf(target: any): boolean;
        constructor(args: {
            clientId: string;
            guid?: string;
        });
    }
    namespace UnsubscribeAll {
        class Request extends UnsubscribeAll {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            subscription: Subscription;
            token: string;
            constructor(args: {
                clientId: string;
                guid?: string;
                subscription: Subscription;
                token: string;
            });
        }
        class Response extends UnsubscribeAll {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            status: boolean;
            error?: string;
            constructor(args: {
                clientId: string;
                guid?: string;
                status: boolean;
                error?: string;
            });
        }
        enum Responses {
            ConnectionError = "ConnectionError"
        }
    }
    class Registration extends Message {
        static getDescription(): {
            [key: string]: Protocol.IProperty;
        };
        static __signature: string;
        static getSignature(): string;
        static getProtocol(): any;
        __signature: string;
        getSignature(): string;
        getProtocol(): any;
        static parse(str: string | object): Protocol.TTypes | Error;
        stringify(): Protocol.TStringifyOutput | Error;
        static instanceOf(target: any): boolean;
        constructor(args: {
            clientId: string;
            guid?: string;
        });
    }
    namespace Registration {
        class Request extends Registration {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            aliases: Array<KeyValue>;
            token: string;
            constructor(args: {
                clientId: string;
                guid?: string;
                aliases: Array<KeyValue>;
                token: string;
            });
        }
        class Response extends Registration {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            status: boolean;
            error?: string;
            constructor(args: {
                clientId: string;
                guid?: string;
                status: boolean;
                error?: string;
            });
        }
        enum Responses {
            ConnectionError = "ConnectionError"
        }
    }
    class Demand extends Message {
        static getDescription(): {
            [key: string]: Protocol.IProperty;
        };
        static __signature: string;
        static getSignature(): string;
        static getProtocol(): any;
        __signature: string;
        getSignature(): string;
        getProtocol(): any;
        static parse(str: string | object): Protocol.TTypes | Error;
        stringify(): Protocol.TStringifyOutput | Error;
        static instanceOf(target: any): boolean;
        constructor(args: {
            clientId: string;
            guid?: string;
        });
    }
    namespace Demand {
        class FromExpectant extends Demand {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            constructor(args: {
                clientId: string;
                guid?: string;
            });
        }
        namespace FromExpectant {
            class Request extends FromExpectant {
                static getDescription(): {
                    [key: string]: Protocol.IProperty;
                };
                static __signature: string;
                static getSignature(): string;
                static getProtocol(): any;
                __signature: string;
                getSignature(): string;
                getProtocol(): any;
                static parse(str: string | object): Protocol.TTypes | Error;
                stringify(): Protocol.TStringifyOutput | Error;
                static instanceOf(target: any): boolean;
                demand: DemandDefinition;
                token: string;
                query: Array<KeyValue>;
                options?: Message.Demand.Options;
                constructor(args: {
                    clientId: string;
                    guid?: string;
                    demand: DemandDefinition;
                    token: string;
                    query: Array<KeyValue>;
                    options?: Message.Demand.Options;
                });
            }
            class Response extends FromExpectant {
                static getDescription(): {
                    [key: string]: Protocol.IProperty;
                };
                static __signature: string;
                static getSignature(): string;
                static getProtocol(): any;
                __signature: string;
                getSignature(): string;
                getProtocol(): any;
                static parse(str: string | object): Protocol.TTypes | Error;
                stringify(): Protocol.TStringifyOutput | Error;
                static instanceOf(target: any): boolean;
                id: string;
                state: Message.Demand.State;
                error?: string;
                constructor(args: {
                    clientId: string;
                    guid?: string;
                    id: string;
                    state: Message.Demand.State;
                    error?: string;
                });
            }
            enum Responses {
                ConnectionError = "ConnectionError"
            }
        }
        class FromRespondent extends Demand {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            constructor(args: {
                clientId: string;
                guid?: string;
            });
        }
        namespace FromRespondent {
            class Request extends FromRespondent {
                static getDescription(): {
                    [key: string]: Protocol.IProperty;
                };
                static __signature: string;
                static getSignature(): string;
                static getProtocol(): any;
                __signature: string;
                getSignature(): string;
                getProtocol(): any;
                static parse(str: string | object): Protocol.TTypes | Error;
                stringify(): Protocol.TStringifyOutput | Error;
                static instanceOf(target: any): boolean;
                id: string;
                token: string;
                error?: string;
                demand?: DemandDefinition;
                constructor(args: {
                    clientId: string;
                    guid?: string;
                    id: string;
                    token: string;
                    error?: string;
                    demand?: DemandDefinition;
                });
            }
            class Response extends FromRespondent {
                static getDescription(): {
                    [key: string]: Protocol.IProperty;
                };
                static __signature: string;
                static getSignature(): string;
                static getProtocol(): any;
                __signature: string;
                getSignature(): string;
                getProtocol(): any;
                static parse(str: string | object): Protocol.TTypes | Error;
                stringify(): Protocol.TStringifyOutput | Error;
                static instanceOf(target: any): boolean;
                status: boolean;
                error?: string;
                constructor(args: {
                    clientId: string;
                    guid?: string;
                    status: boolean;
                    error?: string;
                });
            }
            enum Responses {
                ConnectionError = "ConnectionError"
            }
        }
        enum State {
            ERROR = "ERROR",
            NO_RESPONDENTS = "NO_RESPONDENTS",
            SUCCESS = "SUCCESS",
            DEMAND_SENT = "DEMAND_SENT",
            PENDING = "PENDING"
        }
        class Options extends Protocol.Root {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            scope?: Message.Demand.Options.Scope;
            constructor(args: {
                scope?: Message.Demand.Options.Scope;
            });
        }
        namespace Options {
            enum Scope {
                local = "local",
                hosts = "hosts",
                clients = "clients",
                all = "all"
            }
        }
    }
    class Respondent extends Message {
        static getDescription(): {
            [key: string]: Protocol.IProperty;
        };
        static __signature: string;
        static getSignature(): string;
        static getProtocol(): any;
        __signature: string;
        getSignature(): string;
        getProtocol(): any;
        static parse(str: string | object): Protocol.TTypes | Error;
        stringify(): Protocol.TStringifyOutput | Error;
        static instanceOf(target: any): boolean;
        constructor(args: {
            clientId: string;
            guid?: string;
        });
    }
    namespace Respondent {
        class Bind extends Respondent {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            constructor(args: {
                clientId: string;
                guid?: string;
            });
        }
        namespace Bind {
            class Request extends Bind {
                static getDescription(): {
                    [key: string]: Protocol.IProperty;
                };
                static __signature: string;
                static getSignature(): string;
                static getProtocol(): any;
                __signature: string;
                getSignature(): string;
                getProtocol(): any;
                static parse(str: string | object): Protocol.TTypes | Error;
                stringify(): Protocol.TStringifyOutput | Error;
                static instanceOf(target: any): boolean;
                demand: string;
                protocol: string;
                token: string;
                query: Array<KeyValue>;
                constructor(args: {
                    clientId: string;
                    guid?: string;
                    demand: string;
                    protocol: string;
                    token: string;
                    query: Array<KeyValue>;
                });
            }
            class Response extends Bind {
                static getDescription(): {
                    [key: string]: Protocol.IProperty;
                };
                static __signature: string;
                static getSignature(): string;
                static getProtocol(): any;
                __signature: string;
                getSignature(): string;
                getProtocol(): any;
                static parse(str: string | object): Protocol.TTypes | Error;
                stringify(): Protocol.TStringifyOutput | Error;
                static instanceOf(target: any): boolean;
                status: boolean;
                error?: string;
                constructor(args: {
                    clientId: string;
                    guid?: string;
                    status: boolean;
                    error?: string;
                });
            }
            enum Responses {
                ConnectionError = "ConnectionError"
            }
        }
        class Unbind extends Respondent {
            static getDescription(): {
                [key: string]: Protocol.IProperty;
            };
            static __signature: string;
            static getSignature(): string;
            static getProtocol(): any;
            __signature: string;
            getSignature(): string;
            getProtocol(): any;
            static parse(str: string | object): Protocol.TTypes | Error;
            stringify(): Protocol.TStringifyOutput | Error;
            static instanceOf(target: any): boolean;
            constructor(args: {
                clientId: string;
                guid?: string;
            });
        }
        namespace Unbind {
            class Request extends Unbind {
                static getDescription(): {
                    [key: string]: Protocol.IProperty;
                };
                static __signature: string;
                static getSignature(): string;
                static getProtocol(): any;
                __signature: string;
                getSignature(): string;
                getProtocol(): any;
                static parse(str: string | object): Protocol.TTypes | Error;
                stringify(): Protocol.TStringifyOutput | Error;
                static instanceOf(target: any): boolean;
                demand: string;
                protocol: string;
                token: string;
                constructor(args: {
                    clientId: string;
                    guid?: string;
                    demand: string;
                    protocol: string;
                    token: string;
                });
            }
            class Response extends Unbind {
                static getDescription(): {
                    [key: string]: Protocol.IProperty;
                };
                static __signature: string;
                static getSignature(): string;
                static getProtocol(): any;
                __signature: string;
                getSignature(): string;
                getProtocol(): any;
                static parse(str: string | object): Protocol.TTypes | Error;
                stringify(): Protocol.TStringifyOutput | Error;
                static instanceOf(target: any): boolean;
                status: boolean;
                constructor(args: {
                    clientId: string;
                    guid?: string;
                    status: boolean;
                });
            }
            enum Responses {
                ConnectionError = "ConnectionError"
            }
        }
    }
    class ToConsumer extends Message {
        static getDescription(): {
            [key: string]: Protocol.IProperty;
        };
        static __signature: string;
        static getSignature(): string;
        static getProtocol(): any;
        __signature: string;
        getSignature(): string;
        getProtocol(): any;
        static parse(str: string | object): Protocol.TTypes | Error;
        stringify(): Protocol.TStringifyOutput | Error;
        static instanceOf(target: any): boolean;
        event?: EventDefinition;
        demand?: DemandDefinition;
        return?: DemandDefinition;
        constructor(args: {
            clientId: string;
            guid?: string;
            event?: EventDefinition;
            demand?: DemandDefinition;
            return?: DemandDefinition;
        });
    }
}
export declare class EventDefinition extends Protocol.Root {
    static getDescription(): {
        [key: string]: Protocol.IProperty;
    };
    static __signature: string;
    static getSignature(): string;
    static getProtocol(): any;
    __signature: string;
    getSignature(): string;
    getProtocol(): any;
    static parse(str: string | object): Protocol.TTypes | Error;
    stringify(): Protocol.TStringifyOutput | Error;
    static instanceOf(target: any): boolean;
    protocol: string;
    event: string;
    bodyStr: string;
    bodyBinary: Array<number>;
    constructor(args: {
        protocol: string;
        event: string;
        bodyStr: string;
        bodyBinary: Array<number>;
    });
}
export declare class DemandDefinition extends Protocol.Root {
    static getDescription(): {
        [key: string]: Protocol.IProperty;
    };
    static __signature: string;
    static getSignature(): string;
    static getProtocol(): any;
    __signature: string;
    getSignature(): string;
    getProtocol(): any;
    static parse(str: string | object): Protocol.TTypes | Error;
    stringify(): Protocol.TStringifyOutput | Error;
    static instanceOf(target: any): boolean;
    id: string;
    protocol: string;
    demand: string;
    bodyStr: string;
    bodyBinary: Array<number>;
    expected: string;
    error?: string;
    pending?: boolean;
    constructor(args: {
        id: string;
        protocol: string;
        demand: string;
        bodyStr: string;
        bodyBinary: Array<number>;
        expected: string;
        error?: string;
        pending?: boolean;
    });
}
export declare class Subscription extends Protocol.Root {
    static getDescription(): {
        [key: string]: Protocol.IProperty;
    };
    static __signature: string;
    static getSignature(): string;
    static getProtocol(): any;
    __signature: string;
    getSignature(): string;
    getProtocol(): any;
    static parse(str: string | object): Protocol.TTypes | Error;
    stringify(): Protocol.TStringifyOutput | Error;
    static instanceOf(target: any): boolean;
    protocol: string;
    event?: string;
    constructor(args: {
        protocol: string;
        event?: string;
    });
}
export declare class ConnectionError extends Protocol.Root {
    static getDescription(): {
        [key: string]: Protocol.IProperty;
    };
    static __signature: string;
    static getSignature(): string;
    static getProtocol(): any;
    __signature: string;
    getSignature(): string;
    getProtocol(): any;
    static parse(str: string | object): Protocol.TTypes | Error;
    stringify(): Protocol.TStringifyOutput | Error;
    static instanceOf(target: any): boolean;
    guid?: string;
    reason: ConnectionError.Reasons;
    message: string;
    constructor(args: {
        guid?: string;
        reason: ConnectionError.Reasons;
        message: string;
    });
}
export declare namespace ConnectionError {
    enum Reasons {
        FAIL_AUTH = "FAIL_AUTH",
        NO_TOKEN_FOUND = "NO_TOKEN_FOUND",
        NO_CLIENT_ID_FOUND = "NO_CLIENT_ID_FOUND",
        NO_TOKEN_PROVIDED = "NO_TOKEN_PROVIDED",
        TOKEN_IS_WRONG = "TOKEN_IS_WRONG",
        UNEXPECTED_REQUEST = "UNEXPECTED_REQUEST",
        NO_DATA_PROVIDED = "NO_DATA_PROVIDED"
    }
}
export declare class Disconnect extends Protocol.Root {
    static getDescription(): {
        [key: string]: Protocol.IProperty;
    };
    static __signature: string;
    static getSignature(): string;
    static getProtocol(): any;
    __signature: string;
    getSignature(): string;
    getProtocol(): any;
    static parse(str: string | object): Protocol.TTypes | Error;
    stringify(): Protocol.TStringifyOutput | Error;
    static instanceOf(target: any): boolean;
    reason: Disconnect.Reasons;
    message?: string;
    constructor(args: {
        reason: Disconnect.Reasons;
        message?: string;
    });
}
export declare namespace Disconnect {
    enum Reasons {
        SHUTDOWN = "SHUTDOWN"
    }
}
export declare class KeyValue extends Protocol.Root {
    static getDescription(): {
        [key: string]: Protocol.IProperty;
    };
    static __signature: string;
    static getSignature(): string;
    static getProtocol(): any;
    __signature: string;
    getSignature(): string;
    getProtocol(): any;
    static parse(str: string | object): Protocol.TTypes | Error;
    stringify(): Protocol.TStringifyOutput | Error;
    static instanceOf(target: any): boolean;
    key: string;
    value: string;
    constructor(args: {
        key: string;
        value: string;
    });
}
export declare type TProtocolTypes = Protocol.TTypes;
export declare const parse: typeof Protocol.parse;
export declare const parseFrom: typeof Protocol.parseFrom;
export declare const stringify: typeof Protocol.stringify;
export declare const join: typeof Protocol.Packager.join;
export declare const split: typeof Protocol.Packager.split;
export declare const isPackage: typeof Protocol.Packager.isPackage;
export declare const getSignature: typeof Protocol.getSignature;
export interface IClass {
    getSignature: () => string;
    parse: (str: string | object) => any;
}
export interface IImplementation {
    getSignature: () => string;
    stringify: () => Protocol.TStringifyOutput | Error;
}