import * as $protobuf from "protobufjs";
/** Namespace base. */
export namespace base {

    /** Properties of a Filter. */
    interface IFilter {

        /** Filter and */
        and?: (base.Filter.IAnd|null);

        /** Filter or */
        or?: (base.Filter.IOr|null);

        /** Filter orderBy */
        orderBy?: (base.Filter.IOrderBy|null);
    }

    /** Represents a Filter. */
    class Filter implements IFilter {

        /**
         * Constructs a new Filter.
         * @param [properties] Properties to set
         */
        constructor(properties?: base.IFilter);

        /** Filter and. */
        public and?: (base.Filter.IAnd|null);

        /** Filter or. */
        public or?: (base.Filter.IOr|null);

        /** Filter orderBy. */
        public orderBy?: (base.Filter.IOrderBy|null);

        /** Filter filter. */
        public filter?: ("and"|"or"|"orderBy");

        /**
         * Encodes the specified Filter message. Does not implicitly {@link base.Filter.verify|verify} messages.
         * @param message Filter message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: base.IFilter, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a Filter message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns Filter
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): base.Filter;

        /**
         * Verifies a Filter message.
         * @param message Plain object to verify
         * @returns `null` if valid, otherwise the reason why it is not
         */
        public static verify(message: { [k: string]: any }): (string|null);

        /**
         * Creates a Filter message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns Filter
         */
        public static fromObject(object: { [k: string]: any }): base.Filter;

        /**
         * Creates a plain object from a Filter message. Also converts values to other types if specified.
         * @param message Filter
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: base.Filter, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this Filter to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace Filter {

        /** Cond enum. */
        enum Cond {
            None = 0,
            Eq = 1,
            Neq = 2,
            Gt = 3,
            Gte = 4,
            Lt = 5,
            Lte = 6,
            Like = 7,
            In = 8,
            NotIn = 9,
            IsNull = 10,
            NotNull = 11,
            Between = 12
        }

        /** Properties of an And. */
        interface IAnd {

            /** And cond */
            cond?: (string|null);

            /** And column */
            column?: (string|null);

            /** And args */
            args?: (string[]|null);
        }

        /** Represents an And. */
        class And implements IAnd {

            /**
             * Constructs a new And.
             * @param [properties] Properties to set
             */
            constructor(properties?: base.Filter.IAnd);

            /** And cond. */
            public cond: string;

            /** And column. */
            public column: string;

            /** And args. */
            public args: string[];

            /**
             * Encodes the specified And message. Does not implicitly {@link base.Filter.And.verify|verify} messages.
             * @param message And message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: base.Filter.IAnd, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an And message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns And
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): base.Filter.And;

            /**
             * Verifies an And message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);

            /**
             * Creates an And message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns And
             */
            public static fromObject(object: { [k: string]: any }): base.Filter.And;

            /**
             * Creates a plain object from an And message. Also converts values to other types if specified.
             * @param message And
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: base.Filter.And, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this And to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an Or. */
        interface IOr {

            /** Or cond */
            cond?: (string|null);

            /** Or column */
            column?: (string|null);

            /** Or args */
            args?: (string[]|null);
        }

        /** Represents an Or. */
        class Or implements IOr {

            /**
             * Constructs a new Or.
             * @param [properties] Properties to set
             */
            constructor(properties?: base.Filter.IOr);

            /** Or cond. */
            public cond: string;

            /** Or column. */
            public column: string;

            /** Or args. */
            public args: string[];

            /**
             * Encodes the specified Or message. Does not implicitly {@link base.Filter.Or.verify|verify} messages.
             * @param message Or message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: base.Filter.IOr, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an Or message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns Or
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): base.Filter.Or;

            /**
             * Verifies an Or message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);

            /**
             * Creates an Or message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns Or
             */
            public static fromObject(object: { [k: string]: any }): base.Filter.Or;

            /**
             * Creates a plain object from an Or message. Also converts values to other types if specified.
             * @param message Or
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: base.Filter.Or, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this Or to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an OrderBy. */
        interface IOrderBy {

            /** OrderBy orderByDirection */
            orderByDirection?: (base.Filter.OrderByDerection|null);

            /** OrderBy column */
            column?: (string|null);
        }

        /** Represents an OrderBy. */
        class OrderBy implements IOrderBy {

            /**
             * Constructs a new OrderBy.
             * @param [properties] Properties to set
             */
            constructor(properties?: base.Filter.IOrderBy);

            /** OrderBy orderByDirection. */
            public orderByDirection: base.Filter.OrderByDerection;

            /** OrderBy column. */
            public column: string;

            /**
             * Encodes the specified OrderBy message. Does not implicitly {@link base.Filter.OrderBy.verify|verify} messages.
             * @param message OrderBy message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: base.Filter.IOrderBy, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an OrderBy message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns OrderBy
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): base.Filter.OrderBy;

            /**
             * Verifies an OrderBy message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);

            /**
             * Creates an OrderBy message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns OrderBy
             */
            public static fromObject(object: { [k: string]: any }): base.Filter.OrderBy;

            /**
             * Creates a plain object from an OrderBy message. Also converts values to other types if specified.
             * @param message OrderBy
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: base.Filter.OrderBy, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this OrderBy to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** OrderByDerection enum. */
        enum OrderByDerection {
            Asc = 0,
            Desc = 1
        }
    }

    /** Properties of a Debug. */
    interface IDebug {

        /** Debug logLevel */
        logLevel?: (string|null);

        /** Debug showSql */
        showSql?: (boolean|null);
    }

    /** Represents a Debug. */
    class Debug implements IDebug {

        /**
         * Constructs a new Debug.
         * @param [properties] Properties to set
         */
        constructor(properties?: base.IDebug);

        /** Debug logLevel. */
        public logLevel: string;

        /** Debug showSql. */
        public showSql?: (boolean|null);

        /** Debug _showSql. */
        public _showSql?: "showSql";

        /**
         * Encodes the specified Debug message. Does not implicitly {@link base.Debug.verify|verify} messages.
         * @param message Debug message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: base.IDebug, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a Debug message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns Debug
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): base.Debug;

        /**
         * Verifies a Debug message.
         * @param message Plain object to verify
         * @returns `null` if valid, otherwise the reason why it is not
         */
        public static verify(message: { [k: string]: any }): (string|null);

        /**
         * Creates a Debug message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns Debug
         */
        public static fromObject(object: { [k: string]: any }): base.Debug;

        /**
         * Creates a plain object from a Debug message. Also converts values to other types if specified.
         * @param message Debug
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: base.Debug, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this Debug to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a DelByIdRequest. */
    interface IDelByIdRequest {

        /** DelByIdRequest id */
        id?: (number|null);
    }

    /** Represents a DelByIdRequest. */
    class DelByIdRequest implements IDelByIdRequest {

        /**
         * Constructs a new DelByIdRequest.
         * @param [properties] Properties to set
         */
        constructor(properties?: base.IDelByIdRequest);

        /** DelByIdRequest id. */
        public id: number;

        /**
         * Encodes the specified DelByIdRequest message. Does not implicitly {@link base.DelByIdRequest.verify|verify} messages.
         * @param message DelByIdRequest message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: base.IDelByIdRequest, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a DelByIdRequest message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns DelByIdRequest
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): base.DelByIdRequest;

        /**
         * Verifies a DelByIdRequest message.
         * @param message Plain object to verify
         * @returns `null` if valid, otherwise the reason why it is not
         */
        public static verify(message: { [k: string]: any }): (string|null);

        /**
         * Creates a DelByIdRequest message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns DelByIdRequest
         */
        public static fromObject(object: { [k: string]: any }): base.DelByIdRequest;

        /**
         * Creates a plain object from a DelByIdRequest message. Also converts values to other types if specified.
         * @param message DelByIdRequest
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: base.DelByIdRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this DelByIdRequest to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a DelByUuidRequest. */
    interface IDelByUuidRequest {

        /** DelByUuidRequest uuid */
        uuid?: (string|null);
    }

    /** Represents a DelByUuidRequest. */
    class DelByUuidRequest implements IDelByUuidRequest {

        /**
         * Constructs a new DelByUuidRequest.
         * @param [properties] Properties to set
         */
        constructor(properties?: base.IDelByUuidRequest);

        /** DelByUuidRequest uuid. */
        public uuid: string;

        /**
         * Encodes the specified DelByUuidRequest message. Does not implicitly {@link base.DelByUuidRequest.verify|verify} messages.
         * @param message DelByUuidRequest message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: base.IDelByUuidRequest, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a DelByUuidRequest message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns DelByUuidRequest
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): base.DelByUuidRequest;

        /**
         * Verifies a DelByUuidRequest message.
         * @param message Plain object to verify
         * @returns `null` if valid, otherwise the reason why it is not
         */
        public static verify(message: { [k: string]: any }): (string|null);

        /**
         * Creates a DelByUuidRequest message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns DelByUuidRequest
         */
        public static fromObject(object: { [k: string]: any }): base.DelByUuidRequest;

        /**
         * Creates a plain object from a DelByUuidRequest message. Also converts values to other types if specified.
         * @param message DelByUuidRequest
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: base.DelByUuidRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this DelByUuidRequest to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of an EmptyRequest. */
    interface IEmptyRequest {
    }

    /** Represents an EmptyRequest. */
    class EmptyRequest implements IEmptyRequest {

        /**
         * Constructs a new EmptyRequest.
         * @param [properties] Properties to set
         */
        constructor(properties?: base.IEmptyRequest);

        /**
         * Encodes the specified EmptyRequest message. Does not implicitly {@link base.EmptyRequest.verify|verify} messages.
         * @param message EmptyRequest message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: base.IEmptyRequest, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes an EmptyRequest message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns EmptyRequest
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): base.EmptyRequest;

        /**
         * Verifies an EmptyRequest message.
         * @param message Plain object to verify
         * @returns `null` if valid, otherwise the reason why it is not
         */
        public static verify(message: { [k: string]: any }): (string|null);

        /**
         * Creates an EmptyRequest message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns EmptyRequest
         */
        public static fromObject(object: { [k: string]: any }): base.EmptyRequest;

        /**
         * Creates a plain object from an EmptyRequest message. Also converts values to other types if specified.
         * @param message EmptyRequest
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: base.EmptyRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this EmptyRequest to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }
}

/** Namespace uas. */
export namespace uas {

    /** Represents an Uas */
    class Uas extends $protobuf.rpc.Service {

        /**
         * Constructs a new Uas service.
         * @param rpcImpl RPC implementation
         * @param [requestDelimited=false] Whether requests are length-delimited
         * @param [responseDelimited=false] Whether responses are length-delimited
         */
        constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean);

        /**
         * Calls Connect.
         * @param request Request message or plain object
         * @param callback Node-style callback called with the error, if any, and Response
         */
        public connect(request: uas.IRequest, callback: uas.Uas.ConnectCallback): void;

        /**
         * Calls Connect.
         * @param request Request message or plain object
         * @returns Promise
         */
        public connect(request: uas.IRequest): Promise<uas.Response>;

        /**
         * Calls Ping.
         * @param request Request message or plain object
         * @param callback Node-style callback called with the error, if any, and Response
         */
        public ping(request: uas.IRequest, callback: uas.Uas.PingCallback): void;

        /**
         * Calls Ping.
         * @param request Request message or plain object
         * @returns Promise
         */
        public ping(request: uas.IRequest): Promise<uas.Response>;

        /**
         * Calls Reauthenticate.
         * @param request Request message or plain object
         * @param callback Node-style callback called with the error, if any, and Response
         */
        public reauthenticate(request: uas.IRequest, callback: uas.Uas.ReauthenticateCallback): void;

        /**
         * Calls Reauthenticate.
         * @param request Request message or plain object
         * @returns Promise
         */
        public reauthenticate(request: uas.IRequest): Promise<uas.Response>;

        /**
         * Calls Subscribe.
         * @param request SubscribeRequest message or plain object
         * @param callback Node-style callback called with the error, if any, and SubscribeResponse
         */
        public subscribe(request: uas.ISubscribeRequest, callback: uas.Uas.SubscribeCallback): void;

        /**
         * Calls Subscribe.
         * @param request SubscribeRequest message or plain object
         * @returns Promise
         */
        public subscribe(request: uas.ISubscribeRequest): Promise<uas.SubscribeResponse>;

        /**
         * Calls Unsubscribe.
         * @param request SubscribeRequest message or plain object
         * @param callback Node-style callback called with the error, if any, and SubscribeResponse
         */
        public unsubscribe(request: uas.ISubscribeRequest, callback: uas.Uas.UnsubscribeCallback): void;

        /**
         * Calls Unsubscribe.
         * @param request SubscribeRequest message or plain object
         * @returns Promise
         */
        public unsubscribe(request: uas.ISubscribeRequest): Promise<uas.SubscribeResponse>;
    }

    namespace Uas {

        /**
         * Callback as used by {@link uas.Uas#connect}.
         * @param error Error, if any
         * @param [response] Response
         */
        type ConnectCallback = (error: (Error|null), response?: uas.Response) => void;

        /**
         * Callback as used by {@link uas.Uas#ping}.
         * @param error Error, if any
         * @param [response] Response
         */
        type PingCallback = (error: (Error|null), response?: uas.Response) => void;

        /**
         * Callback as used by {@link uas.Uas#reauthenticate}.
         * @param error Error, if any
         * @param [response] Response
         */
        type ReauthenticateCallback = (error: (Error|null), response?: uas.Response) => void;

        /**
         * Callback as used by {@link uas.Uas#subscribe}.
         * @param error Error, if any
         * @param [response] SubscribeResponse
         */
        type SubscribeCallback = (error: (Error|null), response?: uas.SubscribeResponse) => void;

        /**
         * Callback as used by {@link uas.Uas#unsubscribe}.
         * @param error Error, if any
         * @param [response] SubscribeResponse
         */
        type UnsubscribeCallback = (error: (Error|null), response?: uas.SubscribeResponse) => void;
    }

    /** Properties of a Request. */
    interface IRequest {

        /** Request token */
        token?: (string|null);

        /** Request sessionid */
        sessionid?: (string|null);
    }

    /** Represents a Request. */
    class Request implements IRequest {

        /**
         * Constructs a new Request.
         * @param [properties] Properties to set
         */
        constructor(properties?: uas.IRequest);

        /** Request token. */
        public token: string;

        /** Request sessionid. */
        public sessionid: string;

        /**
         * Encodes the specified Request message. Does not implicitly {@link uas.Request.verify|verify} messages.
         * @param message Request message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: uas.IRequest, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a Request message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns Request
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): uas.Request;

        /**
         * Verifies a Request message.
         * @param message Plain object to verify
         * @returns `null` if valid, otherwise the reason why it is not
         */
        public static verify(message: { [k: string]: any }): (string|null);

        /**
         * Creates a Request message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns Request
         */
        public static fromObject(object: { [k: string]: any }): uas.Request;

        /**
         * Creates a plain object from a Request message. Also converts values to other types if specified.
         * @param message Request
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: uas.Request, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this Request to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a Response. */
    interface IResponse {

        /** Response code */
        code?: (number|null);

        /** Response message */
        message?: (string|null);

        /** Response sessionid */
        sessionid?: (string|null);
    }

    /** Represents a Response. */
    class Response implements IResponse {

        /**
         * Constructs a new Response.
         * @param [properties] Properties to set
         */
        constructor(properties?: uas.IResponse);

        /** Response code. */
        public code: number;

        /** Response message. */
        public message: string;

        /** Response sessionid. */
        public sessionid: string;

        /**
         * Encodes the specified Response message. Does not implicitly {@link uas.Response.verify|verify} messages.
         * @param message Response message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: uas.IResponse, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a Response message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns Response
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): uas.Response;

        /**
         * Verifies a Response message.
         * @param message Plain object to verify
         * @returns `null` if valid, otherwise the reason why it is not
         */
        public static verify(message: { [k: string]: any }): (string|null);

        /**
         * Creates a Response message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns Response
         */
        public static fromObject(object: { [k: string]: any }): uas.Response;

        /**
         * Creates a plain object from a Response message. Also converts values to other types if specified.
         * @param message Response
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: uas.Response, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this Response to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SubscribeRequest. */
    interface ISubscribeRequest {

        /** SubscribeRequest sessionid */
        sessionid?: (string|null);

        /** SubscribeRequest topics */
        topics?: (string[]|null);
    }

    /** Represents a SubscribeRequest. */
    class SubscribeRequest implements ISubscribeRequest {

        /**
         * Constructs a new SubscribeRequest.
         * @param [properties] Properties to set
         */
        constructor(properties?: uas.ISubscribeRequest);

        /** SubscribeRequest sessionid. */
        public sessionid: string;

        /** SubscribeRequest topics. */
        public topics: string[];

        /**
         * Encodes the specified SubscribeRequest message. Does not implicitly {@link uas.SubscribeRequest.verify|verify} messages.
         * @param message SubscribeRequest message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: uas.ISubscribeRequest, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SubscribeRequest message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SubscribeRequest
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): uas.SubscribeRequest;

        /**
         * Verifies a SubscribeRequest message.
         * @param message Plain object to verify
         * @returns `null` if valid, otherwise the reason why it is not
         */
        public static verify(message: { [k: string]: any }): (string|null);

        /**
         * Creates a SubscribeRequest message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SubscribeRequest
         */
        public static fromObject(object: { [k: string]: any }): uas.SubscribeRequest;

        /**
         * Creates a plain object from a SubscribeRequest message. Also converts values to other types if specified.
         * @param message SubscribeRequest
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: uas.SubscribeRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SubscribeRequest to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SubscribeResponse. */
    interface ISubscribeResponse {

        /** SubscribeResponse code */
        code?: (number|null);

        /** SubscribeResponse message */
        message?: (string|null);

        /** SubscribeResponse subscribed */
        subscribed?: (string[]|null);

        /** SubscribeResponse alreadySubscribed */
        alreadySubscribed?: (string[]|null);

        /** SubscribeResponse unauthorized */
        unauthorized?: (string[]|null);

        /** SubscribeResponse unsubscribed */
        unsubscribed?: (string[]|null);

        /** SubscribeResponse notSubscribed */
        notSubscribed?: (string[]|null);
    }

    /** Represents a SubscribeResponse. */
    class SubscribeResponse implements ISubscribeResponse {

        /**
         * Constructs a new SubscribeResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: uas.ISubscribeResponse);

        /** SubscribeResponse code. */
        public code: number;

        /** SubscribeResponse message. */
        public message: string;

        /** SubscribeResponse subscribed. */
        public subscribed: string[];

        /** SubscribeResponse alreadySubscribed. */
        public alreadySubscribed: string[];

        /** SubscribeResponse unauthorized. */
        public unauthorized: string[];

        /** SubscribeResponse unsubscribed. */
        public unsubscribed: string[];

        /** SubscribeResponse notSubscribed. */
        public notSubscribed: string[];

        /**
         * Encodes the specified SubscribeResponse message. Does not implicitly {@link uas.SubscribeResponse.verify|verify} messages.
         * @param message SubscribeResponse message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: uas.ISubscribeResponse, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SubscribeResponse message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SubscribeResponse
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): uas.SubscribeResponse;

        /**
         * Verifies a SubscribeResponse message.
         * @param message Plain object to verify
         * @returns `null` if valid, otherwise the reason why it is not
         */
        public static verify(message: { [k: string]: any }): (string|null);

        /**
         * Creates a SubscribeResponse message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SubscribeResponse
         */
        public static fromObject(object: { [k: string]: any }): uas.SubscribeResponse;

        /**
         * Creates a plain object from a SubscribeResponse message. Also converts values to other types if specified.
         * @param message SubscribeResponse
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: uas.SubscribeResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SubscribeResponse to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of an Event. */
    interface IEvent {

        /** Event domain */
        domain?: (string|null);

        /** Event topic */
        topic?: (string|null);

        /** Event name */
        name?: (string|null);

        /** Event header */
        header?: ({ [k: string]: string }|null);

        /** Event body */
        body?: (Uint8Array|null);
    }

    /** Represents an Event. */
    class Event implements IEvent {

        /**
         * Constructs a new Event.
         * @param [properties] Properties to set
         */
        constructor(properties?: uas.IEvent);

        /** Event domain. */
        public domain: string;

        /** Event topic. */
        public topic: string;

        /** Event name. */
        public name: string;

        /** Event header. */
        public header: { [k: string]: string };

        /** Event body. */
        public body: Uint8Array;

        /**
         * Encodes the specified Event message. Does not implicitly {@link uas.Event.verify|verify} messages.
         * @param message Event message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: uas.IEvent, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes an Event message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns Event
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): uas.Event;

        /**
         * Verifies an Event message.
         * @param message Plain object to verify
         * @returns `null` if valid, otherwise the reason why it is not
         */
        public static verify(message: { [k: string]: any }): (string|null);

        /**
         * Creates an Event message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns Event
         */
        public static fromObject(object: { [k: string]: any }): uas.Event;

        /**
         * Creates a plain object from an Event message. Also converts values to other types if specified.
         * @param message Event
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: uas.Event, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this Event to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }
}
