/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-unused-vars */
import * as $protobuf from "protobufjs";
/** Namespace dtalk. */
export namespace dtalk {
  /** Namespace proto. */
  namespace proto {
    /** Device enum. */
    enum Device {
      Android = 0,
      IOS = 1,
    }

    /** Properties of a Login. */
    interface ILogin {
      /** Login device */
      device?: dtalk.proto.Device | null;

      /** Login username */
      username?: string | null;
    }

    /** Represents a Login. */
    class Login implements ILogin {
      /**
       * Constructs a new Login.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.ILogin);

      /** Login device. */
      public device: dtalk.proto.Device;

      /** Login username. */
      public username: string;

      /**
       * Creates a new Login instance using the specified properties.
       * @param [properties] Properties to set
       * @returns Login instance
       */
      public static create(properties?: dtalk.proto.ILogin): dtalk.proto.Login;

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

      /**
       * Encodes the specified Login message, length delimited. Does not implicitly {@link dtalk.proto.Login.verify|verify} messages.
       * @param message Login message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.ILogin,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a Login message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns Login
       * @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
      ): dtalk.proto.Login;

      /**
       * Decodes a Login message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns Login
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.Login;

      /**
       * Verifies a Login 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 Login message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns Login
       */
      public static fromObject(object: { [k: string]: any }): dtalk.proto.Login;

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

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

    /** EventType enum. */
    enum EventType {
      commonMsg = 0,
      commonMsgAck = 1,
      Notice = 2,
    }

    /** Properties of a Proto. */
    interface IProto {
      /** Proto eventType */
      eventType?: dtalk.proto.EventType | null;

      /** Proto body */
      body?: Uint8Array | null;
    }

    /** Represents a Proto. */
    class Proto implements IProto {
      /**
       * Constructs a new Proto.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IProto);

      /** Proto eventType. */
      public eventType: dtalk.proto.EventType;

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

      /**
       * Creates a new Proto instance using the specified properties.
       * @param [properties] Properties to set
       * @returns Proto instance
       */
      public static create(properties?: dtalk.proto.IProto): dtalk.proto.Proto;

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

      /**
       * Encodes the specified Proto message, length delimited. Does not implicitly {@link dtalk.proto.Proto.verify|verify} messages.
       * @param message Proto message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IProto,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a Proto message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns Proto
       * @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
      ): dtalk.proto.Proto;

      /**
       * Decodes a Proto message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns Proto
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.Proto;

      /**
       * Verifies a Proto 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 Proto message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns Proto
       */
      public static fromObject(object: { [k: string]: any }): dtalk.proto.Proto;

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

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

    /** MsgType enum. */
    enum MsgType {
      System = 0,
      Text = 1,
      Audio = 2,
      Image = 3,
      Video = 4,
      File = 5,
      Card = 6,
      Alert = 7,
      Forward = 8,
    }

    /** Properties of a CommonMsg. */
    interface ICommonMsg {
      /** CommonMsg channelType */
      channelType?: number | null;

      /** CommonMsg logId */
      logId?: number | Long | null;

      /** CommonMsg msgId */
      msgId?: string | null;

      /** CommonMsg from */
      from?: string | null;

      /** CommonMsg target */
      target?: string | null;

      /** CommonMsg msgType */
      msgType?: number | null;

      /** CommonMsg msg */
      msg?: Uint8Array | null;

      /** CommonMsg datetime */
      datetime?: number | Long | null;

      /** CommonMsg source */
      source?: dtalk.proto.ISource | null;
    }

    /** Represents a CommonMsg. */
    class CommonMsg implements ICommonMsg {
      /**
       * Constructs a new CommonMsg.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.ICommonMsg);

      /** CommonMsg channelType. */
      public channelType: number;

      /** CommonMsg logId. */
      public logId: number | Long;

      /** CommonMsg msgId. */
      public msgId: string;

      /** CommonMsg from. */
      public from: string;

      /** CommonMsg target. */
      public target: string;

      /** CommonMsg msgType. */
      public msgType: number;

      /** CommonMsg msg. */
      public msg: Uint8Array;

      /** CommonMsg datetime. */
      public datetime: number | Long;

      /** CommonMsg source. */
      public source?: dtalk.proto.ISource | null;

      /**
       * Creates a new CommonMsg instance using the specified properties.
       * @param [properties] Properties to set
       * @returns CommonMsg instance
       */
      public static create(
        properties?: dtalk.proto.ICommonMsg
      ): dtalk.proto.CommonMsg;

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

      /**
       * Encodes the specified CommonMsg message, length delimited. Does not implicitly {@link dtalk.proto.CommonMsg.verify|verify} messages.
       * @param message CommonMsg message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.ICommonMsg,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a CommonMsg message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns CommonMsg
       * @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
      ): dtalk.proto.CommonMsg;

      /**
       * Decodes a CommonMsg message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns CommonMsg
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.CommonMsg;

      /**
       * Verifies a CommonMsg 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 CommonMsg message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns CommonMsg
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.CommonMsg;

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

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

    /** Properties of a Source. */
    interface ISource {
      /** Source channelType */
      channelType?: number | null;

      /** Source from */
      from?: dtalk.proto.ISourceUser | null;

      /** Source target */
      target?: dtalk.proto.ISourceUser | null;
    }

    /** Represents a Source. */
    class Source implements ISource {
      /**
       * Constructs a new Source.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.ISource);

      /** Source channelType. */
      public channelType: number;

      /** Source from. */
      public from?: dtalk.proto.ISourceUser | null;

      /** Source target. */
      public target?: dtalk.proto.ISourceUser | null;

      /**
       * Creates a new Source instance using the specified properties.
       * @param [properties] Properties to set
       * @returns Source instance
       */
      public static create(
        properties?: dtalk.proto.ISource
      ): dtalk.proto.Source;

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

      /**
       * Encodes the specified Source message, length delimited. Does not implicitly {@link dtalk.proto.Source.verify|verify} messages.
       * @param message Source message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.ISource,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a Source message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns Source
       * @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
      ): dtalk.proto.Source;

      /**
       * Decodes a Source message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns Source
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.Source;

      /**
       * Verifies a Source 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 Source message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns Source
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.Source;

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

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

    /** Properties of a SourceUser. */
    interface ISourceUser {
      /** SourceUser id */
      id?: string | null;

      /** SourceUser name */
      name?: string | null;
    }

    /** Represents a SourceUser. */
    class SourceUser implements ISourceUser {
      /**
       * Constructs a new SourceUser.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.ISourceUser);

      /** SourceUser id. */
      public id: string;

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

      /**
       * Creates a new SourceUser instance using the specified properties.
       * @param [properties] Properties to set
       * @returns SourceUser instance
       */
      public static create(
        properties?: dtalk.proto.ISourceUser
      ): dtalk.proto.SourceUser;

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

      /**
       * Encodes the specified SourceUser message, length delimited. Does not implicitly {@link dtalk.proto.SourceUser.verify|verify} messages.
       * @param message SourceUser message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.ISourceUser,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a SourceUser message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns SourceUser
       * @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
      ): dtalk.proto.SourceUser;

      /**
       * Decodes a SourceUser message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns SourceUser
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.SourceUser;

      /**
       * Verifies a SourceUser 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 SourceUser message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns SourceUser
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.SourceUser;

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

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

    /** Properties of a CommonMsgAck. */
    interface ICommonMsgAck {
      /** CommonMsgAck logId */
      logId?: number | Long | null;

      /** CommonMsgAck datetime */
      datetime?: number | Long | null;
    }

    /** Represents a CommonMsgAck. */
    class CommonMsgAck implements ICommonMsgAck {
      /**
       * Constructs a new CommonMsgAck.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.ICommonMsgAck);

      /** CommonMsgAck logId. */
      public logId: number | Long;

      /** CommonMsgAck datetime. */
      public datetime: number | Long;

      /**
       * Creates a new CommonMsgAck instance using the specified properties.
       * @param [properties] Properties to set
       * @returns CommonMsgAck instance
       */
      public static create(
        properties?: dtalk.proto.ICommonMsgAck
      ): dtalk.proto.CommonMsgAck;

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

      /**
       * Encodes the specified CommonMsgAck message, length delimited. Does not implicitly {@link dtalk.proto.CommonMsgAck.verify|verify} messages.
       * @param message CommonMsgAck message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.ICommonMsgAck,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a CommonMsgAck message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns CommonMsgAck
       * @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
      ): dtalk.proto.CommonMsgAck;

      /**
       * Decodes a CommonMsgAck message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns CommonMsgAck
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.CommonMsgAck;

      /**
       * Verifies a CommonMsgAck 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 CommonMsgAck message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns CommonMsgAck
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.CommonMsgAck;

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

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

    /** Properties of an EncryptMsg. */
    interface IEncryptMsg {
      /** EncryptMsg content */
      content?: string | null;
    }

    /** Represents an EncryptMsg. */
    class EncryptMsg implements IEncryptMsg {
      /**
       * Constructs a new EncryptMsg.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IEncryptMsg);

      /** EncryptMsg content. */
      public content: string;

      /**
       * Creates a new EncryptMsg instance using the specified properties.
       * @param [properties] Properties to set
       * @returns EncryptMsg instance
       */
      public static create(
        properties?: dtalk.proto.IEncryptMsg
      ): dtalk.proto.EncryptMsg;

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

      /**
       * Encodes the specified EncryptMsg message, length delimited. Does not implicitly {@link dtalk.proto.EncryptMsg.verify|verify} messages.
       * @param message EncryptMsg message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IEncryptMsg,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an EncryptMsg message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns EncryptMsg
       * @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
      ): dtalk.proto.EncryptMsg;

      /**
       * Decodes an EncryptMsg message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns EncryptMsg
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.EncryptMsg;

      /**
       * Verifies an EncryptMsg 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 EncryptMsg message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns EncryptMsg
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.EncryptMsg;

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

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

    /** Properties of a TextMsg. */
    interface ITextMsg {
      /** TextMsg content */
      content?: string | null;
    }

    /** Represents a TextMsg. */
    class TextMsg implements ITextMsg {
      /**
       * Constructs a new TextMsg.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.ITextMsg);

      /** TextMsg content. */
      public content: string;

      /**
       * Creates a new TextMsg instance using the specified properties.
       * @param [properties] Properties to set
       * @returns TextMsg instance
       */
      public static create(
        properties?: dtalk.proto.ITextMsg
      ): dtalk.proto.TextMsg;

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

      /**
       * Encodes the specified TextMsg message, length delimited. Does not implicitly {@link dtalk.proto.TextMsg.verify|verify} messages.
       * @param message TextMsg message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.ITextMsg,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a TextMsg message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns TextMsg
       * @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
      ): dtalk.proto.TextMsg;

      /**
       * Decodes a TextMsg message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns TextMsg
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.TextMsg;

      /**
       * Verifies a TextMsg 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 TextMsg message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns TextMsg
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.TextMsg;

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

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

    /** Properties of an AudioMsg. */
    interface IAudioMsg {
      /** AudioMsg mediaUrl */
      mediaUrl?: string | null;

      /** AudioMsg time */
      time?: number | null;
    }

    /** Represents an AudioMsg. */
    class AudioMsg implements IAudioMsg {
      /**
       * Constructs a new AudioMsg.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IAudioMsg);

      /** AudioMsg mediaUrl. */
      public mediaUrl: string;

      /** AudioMsg time. */
      public time: number;

      /**
       * Creates a new AudioMsg instance using the specified properties.
       * @param [properties] Properties to set
       * @returns AudioMsg instance
       */
      public static create(
        properties?: dtalk.proto.IAudioMsg
      ): dtalk.proto.AudioMsg;

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

      /**
       * Encodes the specified AudioMsg message, length delimited. Does not implicitly {@link dtalk.proto.AudioMsg.verify|verify} messages.
       * @param message AudioMsg message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IAudioMsg,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an AudioMsg message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns AudioMsg
       * @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
      ): dtalk.proto.AudioMsg;

      /**
       * Decodes an AudioMsg message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns AudioMsg
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.AudioMsg;

      /**
       * Verifies an AudioMsg 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 AudioMsg message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns AudioMsg
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.AudioMsg;

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

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

    /** Properties of an ImageMsg. */
    interface IImageMsg {
      /** ImageMsg mediaUrl */
      mediaUrl?: string | null;

      /** ImageMsg height */
      height?: number | null;

      /** ImageMsg width */
      width?: number | null;
    }

    /** Represents an ImageMsg. */
    class ImageMsg implements IImageMsg {
      /**
       * Constructs a new ImageMsg.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IImageMsg);

      /** ImageMsg mediaUrl. */
      public mediaUrl: string;

      /** ImageMsg height. */
      public height: number;

      /** ImageMsg width. */
      public width: number;

      /**
       * Creates a new ImageMsg instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ImageMsg instance
       */
      public static create(
        properties?: dtalk.proto.IImageMsg
      ): dtalk.proto.ImageMsg;

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

      /**
       * Encodes the specified ImageMsg message, length delimited. Does not implicitly {@link dtalk.proto.ImageMsg.verify|verify} messages.
       * @param message ImageMsg message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IImageMsg,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an ImageMsg message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ImageMsg
       * @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
      ): dtalk.proto.ImageMsg;

      /**
       * Decodes an ImageMsg message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ImageMsg
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ImageMsg;

      /**
       * Verifies an ImageMsg 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 ImageMsg message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ImageMsg
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ImageMsg;

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

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

    /** Properties of a VideoMsg. */
    interface IVideoMsg {
      /** VideoMsg mediaUrl */
      mediaUrl?: string | null;

      /** VideoMsg time */
      time?: number | null;

      /** VideoMsg height */
      height?: number | null;

      /** VideoMsg width */
      width?: number | null;
    }

    /** Represents a VideoMsg. */
    class VideoMsg implements IVideoMsg {
      /**
       * Constructs a new VideoMsg.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IVideoMsg);

      /** VideoMsg mediaUrl. */
      public mediaUrl: string;

      /** VideoMsg time. */
      public time: number;

      /** VideoMsg height. */
      public height: number;

      /** VideoMsg width. */
      public width: number;

      /**
       * Creates a new VideoMsg instance using the specified properties.
       * @param [properties] Properties to set
       * @returns VideoMsg instance
       */
      public static create(
        properties?: dtalk.proto.IVideoMsg
      ): dtalk.proto.VideoMsg;

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

      /**
       * Encodes the specified VideoMsg message, length delimited. Does not implicitly {@link dtalk.proto.VideoMsg.verify|verify} messages.
       * @param message VideoMsg message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IVideoMsg,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a VideoMsg message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns VideoMsg
       * @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
      ): dtalk.proto.VideoMsg;

      /**
       * Decodes a VideoMsg message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns VideoMsg
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.VideoMsg;

      /**
       * Verifies a VideoMsg 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 VideoMsg message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns VideoMsg
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.VideoMsg;

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

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

    /** Properties of a FileMsg. */
    interface IFileMsg {
      /** FileMsg mediaUrl */
      mediaUrl?: string | null;

      /** FileMsg name */
      name?: string | null;

      /** FileMsg md5 */
      md5?: string | null;

      /** FileMsg size */
      size?: number | Long | null;
    }

    /** Represents a FileMsg. */
    class FileMsg implements IFileMsg {
      /**
       * Constructs a new FileMsg.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IFileMsg);

      /** FileMsg mediaUrl. */
      public mediaUrl: string;

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

      /** FileMsg md5. */
      public md5: string;

      /** FileMsg size. */
      public size: number | Long;

      /**
       * Creates a new FileMsg instance using the specified properties.
       * @param [properties] Properties to set
       * @returns FileMsg instance
       */
      public static create(
        properties?: dtalk.proto.IFileMsg
      ): dtalk.proto.FileMsg;

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

      /**
       * Encodes the specified FileMsg message, length delimited. Does not implicitly {@link dtalk.proto.FileMsg.verify|verify} messages.
       * @param message FileMsg message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IFileMsg,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a FileMsg message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns FileMsg
       * @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
      ): dtalk.proto.FileMsg;

      /**
       * Decodes a FileMsg message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns FileMsg
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.FileMsg;

      /**
       * Verifies a FileMsg 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 FileMsg message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns FileMsg
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.FileMsg;

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

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

    /** Properties of a CardMsg. */
    interface ICardMsg {
      /** CardMsg bank */
      bank?: string | null;

      /** CardMsg name */
      name?: string | null;

      /** CardMsg account */
      account?: string | null;
    }

    /** Represents a CardMsg. */
    class CardMsg implements ICardMsg {
      /**
       * Constructs a new CardMsg.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.ICardMsg);

      /** CardMsg bank. */
      public bank: string;

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

      /** CardMsg account. */
      public account: string;

      /**
       * Creates a new CardMsg instance using the specified properties.
       * @param [properties] Properties to set
       * @returns CardMsg instance
       */
      public static create(
        properties?: dtalk.proto.ICardMsg
      ): dtalk.proto.CardMsg;

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

      /**
       * Encodes the specified CardMsg message, length delimited. Does not implicitly {@link dtalk.proto.CardMsg.verify|verify} messages.
       * @param message CardMsg message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.ICardMsg,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a CardMsg message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns CardMsg
       * @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
      ): dtalk.proto.CardMsg;

      /**
       * Decodes a CardMsg message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns CardMsg
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.CardMsg;

      /**
       * Verifies a CardMsg 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 CardMsg message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns CardMsg
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.CardMsg;

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

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

    /** Properties of an AlertMsg. */
    interface IAlertMsg {
      /** AlertMsg type */
      type?: dtalk.proto.AlertType | null;

      /** AlertMsg body */
      body?: Uint8Array | null;
    }

    /** Represents an AlertMsg. */
    class AlertMsg implements IAlertMsg {
      /**
       * Constructs a new AlertMsg.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IAlertMsg);

      /** AlertMsg type. */
      public type: dtalk.proto.AlertType;

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

      /**
       * Creates a new AlertMsg instance using the specified properties.
       * @param [properties] Properties to set
       * @returns AlertMsg instance
       */
      public static create(
        properties?: dtalk.proto.IAlertMsg
      ): dtalk.proto.AlertMsg;

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

      /**
       * Encodes the specified AlertMsg message, length delimited. Does not implicitly {@link dtalk.proto.AlertMsg.verify|verify} messages.
       * @param message AlertMsg message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IAlertMsg,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an AlertMsg message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns AlertMsg
       * @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
      ): dtalk.proto.AlertMsg;

      /**
       * Decodes an AlertMsg message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns AlertMsg
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.AlertMsg;

      /**
       * Verifies an AlertMsg 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 AlertMsg message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns AlertMsg
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.AlertMsg;

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

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

    /** Properties of a ForwardMsg. */
    interface IForwardMsg {
      /** ForwardMsg items */
      items?: dtalk.proto.IForwardItem[] | null;
    }

    /** Represents a ForwardMsg. */
    class ForwardMsg implements IForwardMsg {
      /**
       * Constructs a new ForwardMsg.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IForwardMsg);

      /** ForwardMsg items. */
      public items: dtalk.proto.IForwardItem[];

      /**
       * Creates a new ForwardMsg instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ForwardMsg instance
       */
      public static create(
        properties?: dtalk.proto.IForwardMsg
      ): dtalk.proto.ForwardMsg;

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

      /**
       * Encodes the specified ForwardMsg message, length delimited. Does not implicitly {@link dtalk.proto.ForwardMsg.verify|verify} messages.
       * @param message ForwardMsg message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IForwardMsg,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a ForwardMsg message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ForwardMsg
       * @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
      ): dtalk.proto.ForwardMsg;

      /**
       * Decodes a ForwardMsg message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ForwardMsg
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ForwardMsg;

      /**
       * Verifies a ForwardMsg 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 ForwardMsg message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ForwardMsg
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ForwardMsg;

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

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

    /** Properties of a ForwardItem. */
    interface IForwardItem {
      /** ForwardItem avatar */
      avatar?: string | null;

      /** ForwardItem name */
      name?: string | null;

      /** ForwardItem msgType */
      msgType?: number | null;

      /** ForwardItem msg */
      msg?: Uint8Array | null;

      /** ForwardItem datetime */
      datetime?: number | Long | null;
    }

    /** Represents a ForwardItem. */
    class ForwardItem implements IForwardItem {
      /**
       * Constructs a new ForwardItem.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IForwardItem);

      /** ForwardItem avatar. */
      public avatar: string;

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

      /** ForwardItem msgType. */
      public msgType: number;

      /** ForwardItem msg. */
      public msg: Uint8Array;

      /** ForwardItem datetime. */
      public datetime: number | Long;

      /**
       * Creates a new ForwardItem instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ForwardItem instance
       */
      public static create(
        properties?: dtalk.proto.IForwardItem
      ): dtalk.proto.ForwardItem;

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

      /**
       * Encodes the specified ForwardItem message, length delimited. Does not implicitly {@link dtalk.proto.ForwardItem.verify|verify} messages.
       * @param message ForwardItem message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IForwardItem,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a ForwardItem message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ForwardItem
       * @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
      ): dtalk.proto.ForwardItem;

      /**
       * Decodes a ForwardItem message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ForwardItem
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ForwardItem;

      /**
       * Verifies a ForwardItem 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 ForwardItem message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ForwardItem
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ForwardItem;

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

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

    /** AlertType enum. */
    enum AlertType {
      UpdateGroupNameAlert = 0,
      SignInGroupAlert = 1,
      SignOutGroupAlert = 2,
      KickOutGroupAlert = 3,
      DeleteGroupAlert = 4,
      UpdateGroupMutedAlert = 5,
      UpdateGroupMemberMutedAlert = 6,
      UpdateGroupOwnerAlert = 7,
      CommonMsg = 8,
    }

    /** Properties of an AlertUpdateGroupName. */
    interface IAlertUpdateGroupName {
      /** AlertUpdateGroupName group */
      group?: number | Long | null;

      /** AlertUpdateGroupName operator */
      operator?: string | null;

      /** AlertUpdateGroupName name */
      name?: string | null;
    }

    /** Represents an AlertUpdateGroupName. */
    class AlertUpdateGroupName implements IAlertUpdateGroupName {
      /**
       * Constructs a new AlertUpdateGroupName.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IAlertUpdateGroupName);

      /** AlertUpdateGroupName group. */
      public group: number | Long;

      /** AlertUpdateGroupName operator. */
      public operator: string;

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

      /**
       * Creates a new AlertUpdateGroupName instance using the specified properties.
       * @param [properties] Properties to set
       * @returns AlertUpdateGroupName instance
       */
      public static create(
        properties?: dtalk.proto.IAlertUpdateGroupName
      ): dtalk.proto.AlertUpdateGroupName;

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

      /**
       * Encodes the specified AlertUpdateGroupName message, length delimited. Does not implicitly {@link dtalk.proto.AlertUpdateGroupName.verify|verify} messages.
       * @param message AlertUpdateGroupName message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IAlertUpdateGroupName,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an AlertUpdateGroupName message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns AlertUpdateGroupName
       * @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
      ): dtalk.proto.AlertUpdateGroupName;

      /**
       * Decodes an AlertUpdateGroupName message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns AlertUpdateGroupName
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.AlertUpdateGroupName;

      /**
       * Verifies an AlertUpdateGroupName 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 AlertUpdateGroupName message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns AlertUpdateGroupName
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.AlertUpdateGroupName;

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

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

    /** Properties of an AlertSignInGroup. */
    interface IAlertSignInGroup {
      /** AlertSignInGroup group */
      group?: number | Long | null;

      /** AlertSignInGroup inviter */
      inviter?: string | null;

      /** AlertSignInGroup members */
      members?: string[] | null;
    }

    /** Represents an AlertSignInGroup. */
    class AlertSignInGroup implements IAlertSignInGroup {
      /**
       * Constructs a new AlertSignInGroup.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IAlertSignInGroup);

      /** AlertSignInGroup group. */
      public group: number | Long;

      /** AlertSignInGroup inviter. */
      public inviter: string;

      /** AlertSignInGroup members. */
      public members: string[];

      /**
       * Creates a new AlertSignInGroup instance using the specified properties.
       * @param [properties] Properties to set
       * @returns AlertSignInGroup instance
       */
      public static create(
        properties?: dtalk.proto.IAlertSignInGroup
      ): dtalk.proto.AlertSignInGroup;

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

      /**
       * Encodes the specified AlertSignInGroup message, length delimited. Does not implicitly {@link dtalk.proto.AlertSignInGroup.verify|verify} messages.
       * @param message AlertSignInGroup message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IAlertSignInGroup,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an AlertSignInGroup message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns AlertSignInGroup
       * @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
      ): dtalk.proto.AlertSignInGroup;

      /**
       * Decodes an AlertSignInGroup message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns AlertSignInGroup
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.AlertSignInGroup;

      /**
       * Verifies an AlertSignInGroup 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 AlertSignInGroup message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns AlertSignInGroup
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.AlertSignInGroup;

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

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

    /** Properties of an AlertSignOutGroup. */
    interface IAlertSignOutGroup {
      /** AlertSignOutGroup group */
      group?: number | Long | null;

      /** AlertSignOutGroup operator */
      operator?: string | null;
    }

    /** Represents an AlertSignOutGroup. */
    class AlertSignOutGroup implements IAlertSignOutGroup {
      /**
       * Constructs a new AlertSignOutGroup.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IAlertSignOutGroup);

      /** AlertSignOutGroup group. */
      public group: number | Long;

      /** AlertSignOutGroup operator. */
      public operator: string;

      /**
       * Creates a new AlertSignOutGroup instance using the specified properties.
       * @param [properties] Properties to set
       * @returns AlertSignOutGroup instance
       */
      public static create(
        properties?: dtalk.proto.IAlertSignOutGroup
      ): dtalk.proto.AlertSignOutGroup;

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

      /**
       * Encodes the specified AlertSignOutGroup message, length delimited. Does not implicitly {@link dtalk.proto.AlertSignOutGroup.verify|verify} messages.
       * @param message AlertSignOutGroup message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IAlertSignOutGroup,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an AlertSignOutGroup message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns AlertSignOutGroup
       * @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
      ): dtalk.proto.AlertSignOutGroup;

      /**
       * Decodes an AlertSignOutGroup message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns AlertSignOutGroup
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.AlertSignOutGroup;

      /**
       * Verifies an AlertSignOutGroup 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 AlertSignOutGroup message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns AlertSignOutGroup
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.AlertSignOutGroup;

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

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

    /** Properties of an AlertKickOutGroup. */
    interface IAlertKickOutGroup {
      /** AlertKickOutGroup group */
      group?: number | Long | null;

      /** AlertKickOutGroup operator */
      operator?: string | null;

      /** AlertKickOutGroup members */
      members?: string[] | null;
    }

    /** Represents an AlertKickOutGroup. */
    class AlertKickOutGroup implements IAlertKickOutGroup {
      /**
       * Constructs a new AlertKickOutGroup.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IAlertKickOutGroup);

      /** AlertKickOutGroup group. */
      public group: number | Long;

      /** AlertKickOutGroup operator. */
      public operator: string;

      /** AlertKickOutGroup members. */
      public members: string[];

      /**
       * Creates a new AlertKickOutGroup instance using the specified properties.
       * @param [properties] Properties to set
       * @returns AlertKickOutGroup instance
       */
      public static create(
        properties?: dtalk.proto.IAlertKickOutGroup
      ): dtalk.proto.AlertKickOutGroup;

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

      /**
       * Encodes the specified AlertKickOutGroup message, length delimited. Does not implicitly {@link dtalk.proto.AlertKickOutGroup.verify|verify} messages.
       * @param message AlertKickOutGroup message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IAlertKickOutGroup,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an AlertKickOutGroup message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns AlertKickOutGroup
       * @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
      ): dtalk.proto.AlertKickOutGroup;

      /**
       * Decodes an AlertKickOutGroup message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns AlertKickOutGroup
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.AlertKickOutGroup;

      /**
       * Verifies an AlertKickOutGroup 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 AlertKickOutGroup message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns AlertKickOutGroup
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.AlertKickOutGroup;

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

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

    /** Properties of an AlertDeleteGroup. */
    interface IAlertDeleteGroup {
      /** AlertDeleteGroup group */
      group?: number | Long | null;

      /** AlertDeleteGroup operator */
      operator?: string | null;
    }

    /** Represents an AlertDeleteGroup. */
    class AlertDeleteGroup implements IAlertDeleteGroup {
      /**
       * Constructs a new AlertDeleteGroup.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IAlertDeleteGroup);

      /** AlertDeleteGroup group. */
      public group: number | Long;

      /** AlertDeleteGroup operator. */
      public operator: string;

      /**
       * Creates a new AlertDeleteGroup instance using the specified properties.
       * @param [properties] Properties to set
       * @returns AlertDeleteGroup instance
       */
      public static create(
        properties?: dtalk.proto.IAlertDeleteGroup
      ): dtalk.proto.AlertDeleteGroup;

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

      /**
       * Encodes the specified AlertDeleteGroup message, length delimited. Does not implicitly {@link dtalk.proto.AlertDeleteGroup.verify|verify} messages.
       * @param message AlertDeleteGroup message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IAlertDeleteGroup,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an AlertDeleteGroup message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns AlertDeleteGroup
       * @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
      ): dtalk.proto.AlertDeleteGroup;

      /**
       * Decodes an AlertDeleteGroup message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns AlertDeleteGroup
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.AlertDeleteGroup;

      /**
       * Verifies an AlertDeleteGroup 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 AlertDeleteGroup message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns AlertDeleteGroup
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.AlertDeleteGroup;

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

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

    /** Properties of an AlertUpdateGroupMuted. */
    interface IAlertUpdateGroupMuted {
      /** AlertUpdateGroupMuted group */
      group?: number | Long | null;

      /** AlertUpdateGroupMuted operator */
      operator?: string | null;

      /** AlertUpdateGroupMuted type */
      type?: dtalk.proto.MuteType | null;
    }

    /** Represents an AlertUpdateGroupMuted. */
    class AlertUpdateGroupMuted implements IAlertUpdateGroupMuted {
      /**
       * Constructs a new AlertUpdateGroupMuted.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IAlertUpdateGroupMuted);

      /** AlertUpdateGroupMuted group. */
      public group: number | Long;

      /** AlertUpdateGroupMuted operator. */
      public operator: string;

      /** AlertUpdateGroupMuted type. */
      public type: dtalk.proto.MuteType;

      /**
       * Creates a new AlertUpdateGroupMuted instance using the specified properties.
       * @param [properties] Properties to set
       * @returns AlertUpdateGroupMuted instance
       */
      public static create(
        properties?: dtalk.proto.IAlertUpdateGroupMuted
      ): dtalk.proto.AlertUpdateGroupMuted;

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

      /**
       * Encodes the specified AlertUpdateGroupMuted message, length delimited. Does not implicitly {@link dtalk.proto.AlertUpdateGroupMuted.verify|verify} messages.
       * @param message AlertUpdateGroupMuted message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IAlertUpdateGroupMuted,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an AlertUpdateGroupMuted message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns AlertUpdateGroupMuted
       * @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
      ): dtalk.proto.AlertUpdateGroupMuted;

      /**
       * Decodes an AlertUpdateGroupMuted message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns AlertUpdateGroupMuted
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.AlertUpdateGroupMuted;

      /**
       * Verifies an AlertUpdateGroupMuted 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 AlertUpdateGroupMuted message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns AlertUpdateGroupMuted
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.AlertUpdateGroupMuted;

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

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

    /** Properties of an AlertUpdateGroupMemberMutedTime. */
    interface IAlertUpdateGroupMemberMutedTime {
      /** AlertUpdateGroupMemberMutedTime group */
      group?: number | Long | null;

      /** AlertUpdateGroupMemberMutedTime operator */
      operator?: string | null;

      /** AlertUpdateGroupMemberMutedTime members */
      members?: string[] | null;
    }

    /** Represents an AlertUpdateGroupMemberMutedTime. */
    class AlertUpdateGroupMemberMutedTime
      implements IAlertUpdateGroupMemberMutedTime
    {
      /**
       * Constructs a new AlertUpdateGroupMemberMutedTime.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IAlertUpdateGroupMemberMutedTime);

      /** AlertUpdateGroupMemberMutedTime group. */
      public group: number | Long;

      /** AlertUpdateGroupMemberMutedTime operator. */
      public operator: string;

      /** AlertUpdateGroupMemberMutedTime members. */
      public members: string[];

      /**
       * Creates a new AlertUpdateGroupMemberMutedTime instance using the specified properties.
       * @param [properties] Properties to set
       * @returns AlertUpdateGroupMemberMutedTime instance
       */
      public static create(
        properties?: dtalk.proto.IAlertUpdateGroupMemberMutedTime
      ): dtalk.proto.AlertUpdateGroupMemberMutedTime;

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

      /**
       * Encodes the specified AlertUpdateGroupMemberMutedTime message, length delimited. Does not implicitly {@link dtalk.proto.AlertUpdateGroupMemberMutedTime.verify|verify} messages.
       * @param message AlertUpdateGroupMemberMutedTime message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IAlertUpdateGroupMemberMutedTime,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an AlertUpdateGroupMemberMutedTime message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns AlertUpdateGroupMemberMutedTime
       * @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
      ): dtalk.proto.AlertUpdateGroupMemberMutedTime;

      /**
       * Decodes an AlertUpdateGroupMemberMutedTime message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns AlertUpdateGroupMemberMutedTime
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.AlertUpdateGroupMemberMutedTime;

      /**
       * Verifies an AlertUpdateGroupMemberMutedTime 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 AlertUpdateGroupMemberMutedTime message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns AlertUpdateGroupMemberMutedTime
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.AlertUpdateGroupMemberMutedTime;

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

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

    /** Properties of an AlertUpdateGroupOwner. */
    interface IAlertUpdateGroupOwner {
      /** AlertUpdateGroupOwner group */
      group?: number | Long | null;

      /** AlertUpdateGroupOwner newOwner */
      newOwner?: string | null;
    }

    /** Represents an AlertUpdateGroupOwner. */
    class AlertUpdateGroupOwner implements IAlertUpdateGroupOwner {
      /**
       * Constructs a new AlertUpdateGroupOwner.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IAlertUpdateGroupOwner);

      /** AlertUpdateGroupOwner group. */
      public group: number | Long;

      /** AlertUpdateGroupOwner newOwner. */
      public newOwner: string;

      /**
       * Creates a new AlertUpdateGroupOwner instance using the specified properties.
       * @param [properties] Properties to set
       * @returns AlertUpdateGroupOwner instance
       */
      public static create(
        properties?: dtalk.proto.IAlertUpdateGroupOwner
      ): dtalk.proto.AlertUpdateGroupOwner;

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

      /**
       * Encodes the specified AlertUpdateGroupOwner message, length delimited. Does not implicitly {@link dtalk.proto.AlertUpdateGroupOwner.verify|verify} messages.
       * @param message AlertUpdateGroupOwner message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IAlertUpdateGroupOwner,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an AlertUpdateGroupOwner message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns AlertUpdateGroupOwner
       * @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
      ): dtalk.proto.AlertUpdateGroupOwner;

      /**
       * Decodes an AlertUpdateGroupOwner message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns AlertUpdateGroupOwner
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.AlertUpdateGroupOwner;

      /**
       * Verifies an AlertUpdateGroupOwner 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 AlertUpdateGroupOwner message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns AlertUpdateGroupOwner
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.AlertUpdateGroupOwner;

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

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

    /** Properties of an AlertCommonMsg. */
    interface IAlertCommonMsg {
      /** AlertCommonMsg user */
      user?: string | null;

      /** AlertCommonMsg staff */
      staff?: string | null;
    }

    /** Represents an AlertCommonMsg. */
    class AlertCommonMsg implements IAlertCommonMsg {
      /**
       * Constructs a new AlertCommonMsg.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IAlertCommonMsg);

      /** AlertCommonMsg user. */
      public user: string;

      /** AlertCommonMsg staff. */
      public staff: string;

      /**
       * Creates a new AlertCommonMsg instance using the specified properties.
       * @param [properties] Properties to set
       * @returns AlertCommonMsg instance
       */
      public static create(
        properties?: dtalk.proto.IAlertCommonMsg
      ): dtalk.proto.AlertCommonMsg;

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

      /**
       * Encodes the specified AlertCommonMsg message, length delimited. Does not implicitly {@link dtalk.proto.AlertCommonMsg.verify|verify} messages.
       * @param message AlertCommonMsg message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IAlertCommonMsg,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an AlertCommonMsg message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns AlertCommonMsg
       * @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
      ): dtalk.proto.AlertCommonMsg;

      /**
       * Decodes an AlertCommonMsg message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns AlertCommonMsg
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.AlertCommonMsg;

      /**
       * Verifies an AlertCommonMsg 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 AlertCommonMsg message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns AlertCommonMsg
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.AlertCommonMsg;

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

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

    /** Properties of a NotifyMsg. */
    interface INotifyMsg {
      /** NotifyMsg action */
      action?: dtalk.proto.ActionType | null;

      /** NotifyMsg body */
      body?: Uint8Array | null;
    }

    /** Represents a NotifyMsg. */
    class NotifyMsg implements INotifyMsg {
      /**
       * Constructs a new NotifyMsg.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.INotifyMsg);

      /** NotifyMsg action. */
      public action: dtalk.proto.ActionType;

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

      /**
       * Creates a new NotifyMsg instance using the specified properties.
       * @param [properties] Properties to set
       * @returns NotifyMsg instance
       */
      public static create(
        properties?: dtalk.proto.INotifyMsg
      ): dtalk.proto.NotifyMsg;

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

      /**
       * Encodes the specified NotifyMsg message, length delimited. Does not implicitly {@link dtalk.proto.NotifyMsg.verify|verify} messages.
       * @param message NotifyMsg message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.INotifyMsg,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes a NotifyMsg message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns NotifyMsg
       * @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
      ): dtalk.proto.NotifyMsg;

      /**
       * Decodes a NotifyMsg message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns NotifyMsg
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.NotifyMsg;

      /**
       * Verifies a NotifyMsg 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 NotifyMsg message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns NotifyMsg
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.NotifyMsg;

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

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

    /** ActionType enum. */
    enum ActionType {
      Received = 0,
      SignInGroup = 10,
      SignOutGroup = 11,
      DeleteGroup = 12,
      UpdateGroupJoinType = 20,
      UpdateGroupFriendType = 21,
      UpdateGroupMuteType = 22,
      UpdateGroupMemberType = 23,
      UpdateGroupMemberMuteTime = 24,
      UpdateGroupName = 25,
      UpdateGroupAvatar = 26,
    }

    /** Properties of an ActionReceived. */
    interface IActionReceived {
      /** ActionReceived logs */
      logs?: (number | Long)[] | null;
    }

    /** Represents an ActionReceived. */
    class ActionReceived implements IActionReceived {
      /**
       * Constructs a new ActionReceived.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IActionReceived);

      /** ActionReceived logs. */
      public logs: (number | Long)[];

      /**
       * Creates a new ActionReceived instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ActionReceived instance
       */
      public static create(
        properties?: dtalk.proto.IActionReceived
      ): dtalk.proto.ActionReceived;

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

      /**
       * Encodes the specified ActionReceived message, length delimited. Does not implicitly {@link dtalk.proto.ActionReceived.verify|verify} messages.
       * @param message ActionReceived message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IActionReceived,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an ActionReceived message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ActionReceived
       * @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
      ): dtalk.proto.ActionReceived;

      /**
       * Decodes an ActionReceived message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ActionReceived
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ActionReceived;

      /**
       * Verifies an ActionReceived 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 ActionReceived message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ActionReceived
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ActionReceived;

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

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

    /** Properties of an ActionSignInGroup. */
    interface IActionSignInGroup {
      /** ActionSignInGroup uid */
      uid?: string[] | null;

      /** ActionSignInGroup group */
      group?: number | Long | null;

      /** ActionSignInGroup time */
      time?: number | Long | null;
    }

    /** Represents an ActionSignInGroup. */
    class ActionSignInGroup implements IActionSignInGroup {
      /**
       * Constructs a new ActionSignInGroup.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IActionSignInGroup);

      /** ActionSignInGroup uid. */
      public uid: string[];

      /** ActionSignInGroup group. */
      public group: number | Long;

      /** ActionSignInGroup time. */
      public time: number | Long;

      /**
       * Creates a new ActionSignInGroup instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ActionSignInGroup instance
       */
      public static create(
        properties?: dtalk.proto.IActionSignInGroup
      ): dtalk.proto.ActionSignInGroup;

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

      /**
       * Encodes the specified ActionSignInGroup message, length delimited. Does not implicitly {@link dtalk.proto.ActionSignInGroup.verify|verify} messages.
       * @param message ActionSignInGroup message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IActionSignInGroup,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an ActionSignInGroup message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ActionSignInGroup
       * @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
      ): dtalk.proto.ActionSignInGroup;

      /**
       * Decodes an ActionSignInGroup message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ActionSignInGroup
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ActionSignInGroup;

      /**
       * Verifies an ActionSignInGroup 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 ActionSignInGroup message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ActionSignInGroup
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ActionSignInGroup;

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

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

    /** Properties of an ActionSignOutGroup. */
    interface IActionSignOutGroup {
      /** ActionSignOutGroup uid */
      uid?: string[] | null;

      /** ActionSignOutGroup group */
      group?: number | Long | null;

      /** ActionSignOutGroup time */
      time?: number | Long | null;
    }

    /** Represents an ActionSignOutGroup. */
    class ActionSignOutGroup implements IActionSignOutGroup {
      /**
       * Constructs a new ActionSignOutGroup.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IActionSignOutGroup);

      /** ActionSignOutGroup uid. */
      public uid: string[];

      /** ActionSignOutGroup group. */
      public group: number | Long;

      /** ActionSignOutGroup time. */
      public time: number | Long;

      /**
       * Creates a new ActionSignOutGroup instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ActionSignOutGroup instance
       */
      public static create(
        properties?: dtalk.proto.IActionSignOutGroup
      ): dtalk.proto.ActionSignOutGroup;

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

      /**
       * Encodes the specified ActionSignOutGroup message, length delimited. Does not implicitly {@link dtalk.proto.ActionSignOutGroup.verify|verify} messages.
       * @param message ActionSignOutGroup message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IActionSignOutGroup,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an ActionSignOutGroup message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ActionSignOutGroup
       * @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
      ): dtalk.proto.ActionSignOutGroup;

      /**
       * Decodes an ActionSignOutGroup message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ActionSignOutGroup
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ActionSignOutGroup;

      /**
       * Verifies an ActionSignOutGroup 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 ActionSignOutGroup message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ActionSignOutGroup
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ActionSignOutGroup;

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

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

    /** Properties of an ActionDeleteGroup. */
    interface IActionDeleteGroup {
      /** ActionDeleteGroup group */
      group?: number | Long | null;

      /** ActionDeleteGroup time */
      time?: number | Long | null;
    }

    /** Represents an ActionDeleteGroup. */
    class ActionDeleteGroup implements IActionDeleteGroup {
      /**
       * Constructs a new ActionDeleteGroup.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IActionDeleteGroup);

      /** ActionDeleteGroup group. */
      public group: number | Long;

      /** ActionDeleteGroup time. */
      public time: number | Long;

      /**
       * Creates a new ActionDeleteGroup instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ActionDeleteGroup instance
       */
      public static create(
        properties?: dtalk.proto.IActionDeleteGroup
      ): dtalk.proto.ActionDeleteGroup;

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

      /**
       * Encodes the specified ActionDeleteGroup message, length delimited. Does not implicitly {@link dtalk.proto.ActionDeleteGroup.verify|verify} messages.
       * @param message ActionDeleteGroup message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IActionDeleteGroup,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an ActionDeleteGroup message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ActionDeleteGroup
       * @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
      ): dtalk.proto.ActionDeleteGroup;

      /**
       * Decodes an ActionDeleteGroup message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ActionDeleteGroup
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ActionDeleteGroup;

      /**
       * Verifies an ActionDeleteGroup 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 ActionDeleteGroup message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ActionDeleteGroup
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ActionDeleteGroup;

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

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

    /** JoinType enum. */
    enum JoinType {
      JoinAllow = 0,
      JoinDeny = 1,
    }

    /** Properties of an ActionUpdateGroupJoinType. */
    interface IActionUpdateGroupJoinType {
      /** ActionUpdateGroupJoinType group */
      group?: number | Long | null;

      /** ActionUpdateGroupJoinType type */
      type?: dtalk.proto.JoinType | null;

      /** ActionUpdateGroupJoinType time */
      time?: number | Long | null;
    }

    /** Represents an ActionUpdateGroupJoinType. */
    class ActionUpdateGroupJoinType implements IActionUpdateGroupJoinType {
      /**
       * Constructs a new ActionUpdateGroupJoinType.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IActionUpdateGroupJoinType);

      /** ActionUpdateGroupJoinType group. */
      public group: number | Long;

      /** ActionUpdateGroupJoinType type. */
      public type: dtalk.proto.JoinType;

      /** ActionUpdateGroupJoinType time. */
      public time: number | Long;

      /**
       * Creates a new ActionUpdateGroupJoinType instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ActionUpdateGroupJoinType instance
       */
      public static create(
        properties?: dtalk.proto.IActionUpdateGroupJoinType
      ): dtalk.proto.ActionUpdateGroupJoinType;

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

      /**
       * Encodes the specified ActionUpdateGroupJoinType message, length delimited. Does not implicitly {@link dtalk.proto.ActionUpdateGroupJoinType.verify|verify} messages.
       * @param message ActionUpdateGroupJoinType message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IActionUpdateGroupJoinType,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an ActionUpdateGroupJoinType message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ActionUpdateGroupJoinType
       * @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
      ): dtalk.proto.ActionUpdateGroupJoinType;

      /**
       * Decodes an ActionUpdateGroupJoinType message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ActionUpdateGroupJoinType
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ActionUpdateGroupJoinType;

      /**
       * Verifies an ActionUpdateGroupJoinType 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 ActionUpdateGroupJoinType message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ActionUpdateGroupJoinType
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ActionUpdateGroupJoinType;

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

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

    /** FriendType enum. */
    enum FriendType {
      FriendAllow = 0,
      FriendDeny = 1,
    }

    /** Properties of an ActionUpdateGroupFriendType. */
    interface IActionUpdateGroupFriendType {
      /** ActionUpdateGroupFriendType group */
      group?: number | Long | null;

      /** ActionUpdateGroupFriendType type */
      type?: dtalk.proto.FriendType | null;

      /** ActionUpdateGroupFriendType time */
      time?: number | Long | null;
    }

    /** Represents an ActionUpdateGroupFriendType. */
    class ActionUpdateGroupFriendType implements IActionUpdateGroupFriendType {
      /**
       * Constructs a new ActionUpdateGroupFriendType.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IActionUpdateGroupFriendType);

      /** ActionUpdateGroupFriendType group. */
      public group: number | Long;

      /** ActionUpdateGroupFriendType type. */
      public type: dtalk.proto.FriendType;

      /** ActionUpdateGroupFriendType time. */
      public time: number | Long;

      /**
       * Creates a new ActionUpdateGroupFriendType instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ActionUpdateGroupFriendType instance
       */
      public static create(
        properties?: dtalk.proto.IActionUpdateGroupFriendType
      ): dtalk.proto.ActionUpdateGroupFriendType;

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

      /**
       * Encodes the specified ActionUpdateGroupFriendType message, length delimited. Does not implicitly {@link dtalk.proto.ActionUpdateGroupFriendType.verify|verify} messages.
       * @param message ActionUpdateGroupFriendType message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IActionUpdateGroupFriendType,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an ActionUpdateGroupFriendType message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ActionUpdateGroupFriendType
       * @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
      ): dtalk.proto.ActionUpdateGroupFriendType;

      /**
       * Decodes an ActionUpdateGroupFriendType message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ActionUpdateGroupFriendType
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ActionUpdateGroupFriendType;

      /**
       * Verifies an ActionUpdateGroupFriendType 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 ActionUpdateGroupFriendType message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ActionUpdateGroupFriendType
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ActionUpdateGroupFriendType;

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

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

    /** MuteType enum. */
    enum MuteType {
      MuteAllow = 0,
      MuteDeny = 1,
    }

    /** Properties of an ActionUpdateGroupMuteType. */
    interface IActionUpdateGroupMuteType {
      /** ActionUpdateGroupMuteType group */
      group?: number | Long | null;

      /** ActionUpdateGroupMuteType type */
      type?: dtalk.proto.MuteType | null;

      /** ActionUpdateGroupMuteType time */
      time?: number | Long | null;
    }

    /** Represents an ActionUpdateGroupMuteType. */
    class ActionUpdateGroupMuteType implements IActionUpdateGroupMuteType {
      /**
       * Constructs a new ActionUpdateGroupMuteType.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IActionUpdateGroupMuteType);

      /** ActionUpdateGroupMuteType group. */
      public group: number | Long;

      /** ActionUpdateGroupMuteType type. */
      public type: dtalk.proto.MuteType;

      /** ActionUpdateGroupMuteType time. */
      public time: number | Long;

      /**
       * Creates a new ActionUpdateGroupMuteType instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ActionUpdateGroupMuteType instance
       */
      public static create(
        properties?: dtalk.proto.IActionUpdateGroupMuteType
      ): dtalk.proto.ActionUpdateGroupMuteType;

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

      /**
       * Encodes the specified ActionUpdateGroupMuteType message, length delimited. Does not implicitly {@link dtalk.proto.ActionUpdateGroupMuteType.verify|verify} messages.
       * @param message ActionUpdateGroupMuteType message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IActionUpdateGroupMuteType,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an ActionUpdateGroupMuteType message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ActionUpdateGroupMuteType
       * @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
      ): dtalk.proto.ActionUpdateGroupMuteType;

      /**
       * Decodes an ActionUpdateGroupMuteType message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ActionUpdateGroupMuteType
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ActionUpdateGroupMuteType;

      /**
       * Verifies an ActionUpdateGroupMuteType 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 ActionUpdateGroupMuteType message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ActionUpdateGroupMuteType
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ActionUpdateGroupMuteType;

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

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

    /** MemberType enum. */
    enum MemberType {
      Normal = 0,
      Admin = 1,
      Owner = 2,
    }

    /** Properties of an ActionUpdateGroupMemberType. */
    interface IActionUpdateGroupMemberType {
      /** ActionUpdateGroupMemberType group */
      group?: number | Long | null;

      /** ActionUpdateGroupMemberType uid */
      uid?: string | null;

      /** ActionUpdateGroupMemberType type */
      type?: dtalk.proto.MemberType | null;

      /** ActionUpdateGroupMemberType time */
      time?: number | Long | null;
    }

    /** Represents an ActionUpdateGroupMemberType. */
    class ActionUpdateGroupMemberType implements IActionUpdateGroupMemberType {
      /**
       * Constructs a new ActionUpdateGroupMemberType.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IActionUpdateGroupMemberType);

      /** ActionUpdateGroupMemberType group. */
      public group: number | Long;

      /** ActionUpdateGroupMemberType uid. */
      public uid: string;

      /** ActionUpdateGroupMemberType type. */
      public type: dtalk.proto.MemberType;

      /** ActionUpdateGroupMemberType time. */
      public time: number | Long;

      /**
       * Creates a new ActionUpdateGroupMemberType instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ActionUpdateGroupMemberType instance
       */
      public static create(
        properties?: dtalk.proto.IActionUpdateGroupMemberType
      ): dtalk.proto.ActionUpdateGroupMemberType;

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

      /**
       * Encodes the specified ActionUpdateGroupMemberType message, length delimited. Does not implicitly {@link dtalk.proto.ActionUpdateGroupMemberType.verify|verify} messages.
       * @param message ActionUpdateGroupMemberType message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IActionUpdateGroupMemberType,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an ActionUpdateGroupMemberType message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ActionUpdateGroupMemberType
       * @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
      ): dtalk.proto.ActionUpdateGroupMemberType;

      /**
       * Decodes an ActionUpdateGroupMemberType message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ActionUpdateGroupMemberType
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ActionUpdateGroupMemberType;

      /**
       * Verifies an ActionUpdateGroupMemberType 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 ActionUpdateGroupMemberType message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ActionUpdateGroupMemberType
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ActionUpdateGroupMemberType;

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

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

    /** Properties of an ActionUpdateGroupMemberMuteTime. */
    interface IActionUpdateGroupMemberMuteTime {
      /** ActionUpdateGroupMemberMuteTime group */
      group?: number | Long | null;

      /** ActionUpdateGroupMemberMuteTime uid */
      uid?: string[] | null;

      /** ActionUpdateGroupMemberMuteTime muteTime */
      muteTime?: number | Long | null;

      /** ActionUpdateGroupMemberMuteTime time */
      time?: number | Long | null;
    }

    /** Represents an ActionUpdateGroupMemberMuteTime. */
    class ActionUpdateGroupMemberMuteTime
      implements IActionUpdateGroupMemberMuteTime
    {
      /**
       * Constructs a new ActionUpdateGroupMemberMuteTime.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IActionUpdateGroupMemberMuteTime);

      /** ActionUpdateGroupMemberMuteTime group. */
      public group: number | Long;

      /** ActionUpdateGroupMemberMuteTime uid. */
      public uid: string[];

      /** ActionUpdateGroupMemberMuteTime muteTime. */
      public muteTime: number | Long;

      /** ActionUpdateGroupMemberMuteTime time. */
      public time: number | Long;

      /**
       * Creates a new ActionUpdateGroupMemberMuteTime instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ActionUpdateGroupMemberMuteTime instance
       */
      public static create(
        properties?: dtalk.proto.IActionUpdateGroupMemberMuteTime
      ): dtalk.proto.ActionUpdateGroupMemberMuteTime;

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

      /**
       * Encodes the specified ActionUpdateGroupMemberMuteTime message, length delimited. Does not implicitly {@link dtalk.proto.ActionUpdateGroupMemberMuteTime.verify|verify} messages.
       * @param message ActionUpdateGroupMemberMuteTime message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IActionUpdateGroupMemberMuteTime,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an ActionUpdateGroupMemberMuteTime message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ActionUpdateGroupMemberMuteTime
       * @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
      ): dtalk.proto.ActionUpdateGroupMemberMuteTime;

      /**
       * Decodes an ActionUpdateGroupMemberMuteTime message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ActionUpdateGroupMemberMuteTime
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ActionUpdateGroupMemberMuteTime;

      /**
       * Verifies an ActionUpdateGroupMemberMuteTime 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 ActionUpdateGroupMemberMuteTime message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ActionUpdateGroupMemberMuteTime
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ActionUpdateGroupMemberMuteTime;

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

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

    /** Properties of an ActionUpdateGroupName. */
    interface IActionUpdateGroupName {
      /** ActionUpdateGroupName group */
      group?: number | Long | null;

      /** ActionUpdateGroupName name */
      name?: string | null;

      /** ActionUpdateGroupName time */
      time?: number | Long | null;
    }

    /** Represents an ActionUpdateGroupName. */
    class ActionUpdateGroupName implements IActionUpdateGroupName {
      /**
       * Constructs a new ActionUpdateGroupName.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IActionUpdateGroupName);

      /** ActionUpdateGroupName group. */
      public group: number | Long;

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

      /** ActionUpdateGroupName time. */
      public time: number | Long;

      /**
       * Creates a new ActionUpdateGroupName instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ActionUpdateGroupName instance
       */
      public static create(
        properties?: dtalk.proto.IActionUpdateGroupName
      ): dtalk.proto.ActionUpdateGroupName;

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

      /**
       * Encodes the specified ActionUpdateGroupName message, length delimited. Does not implicitly {@link dtalk.proto.ActionUpdateGroupName.verify|verify} messages.
       * @param message ActionUpdateGroupName message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IActionUpdateGroupName,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an ActionUpdateGroupName message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ActionUpdateGroupName
       * @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
      ): dtalk.proto.ActionUpdateGroupName;

      /**
       * Decodes an ActionUpdateGroupName message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ActionUpdateGroupName
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ActionUpdateGroupName;

      /**
       * Verifies an ActionUpdateGroupName 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 ActionUpdateGroupName message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ActionUpdateGroupName
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ActionUpdateGroupName;

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

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

    /** Properties of an ActionUpdateGroupAvatar. */
    interface IActionUpdateGroupAvatar {
      /** ActionUpdateGroupAvatar group */
      group?: number | Long | null;

      /** ActionUpdateGroupAvatar avatar */
      avatar?: string | null;

      /** ActionUpdateGroupAvatar time */
      time?: number | Long | null;
    }

    /** Represents an ActionUpdateGroupAvatar. */
    class ActionUpdateGroupAvatar implements IActionUpdateGroupAvatar {
      /**
       * Constructs a new ActionUpdateGroupAvatar.
       * @param [properties] Properties to set
       */
      constructor(properties?: dtalk.proto.IActionUpdateGroupAvatar);

      /** ActionUpdateGroupAvatar group. */
      public group: number | Long;

      /** ActionUpdateGroupAvatar avatar. */
      public avatar: string;

      /** ActionUpdateGroupAvatar time. */
      public time: number | Long;

      /**
       * Creates a new ActionUpdateGroupAvatar instance using the specified properties.
       * @param [properties] Properties to set
       * @returns ActionUpdateGroupAvatar instance
       */
      public static create(
        properties?: dtalk.proto.IActionUpdateGroupAvatar
      ): dtalk.proto.ActionUpdateGroupAvatar;

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

      /**
       * Encodes the specified ActionUpdateGroupAvatar message, length delimited. Does not implicitly {@link dtalk.proto.ActionUpdateGroupAvatar.verify|verify} messages.
       * @param message ActionUpdateGroupAvatar message or plain object to encode
       * @param [writer] Writer to encode to
       * @returns Writer
       */
      public static encodeDelimited(
        message: dtalk.proto.IActionUpdateGroupAvatar,
        writer?: $protobuf.Writer
      ): $protobuf.Writer;

      /**
       * Decodes an ActionUpdateGroupAvatar message from the specified reader or buffer.
       * @param reader Reader or buffer to decode from
       * @param [length] Message length if known beforehand
       * @returns ActionUpdateGroupAvatar
       * @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
      ): dtalk.proto.ActionUpdateGroupAvatar;

      /**
       * Decodes an ActionUpdateGroupAvatar message from the specified reader or buffer, length delimited.
       * @param reader Reader or buffer to decode from
       * @returns ActionUpdateGroupAvatar
       * @throws {Error} If the payload is not a reader or valid buffer
       * @throws {$protobuf.util.ProtocolError} If required fields are missing
       */
      public static decodeDelimited(
        reader: $protobuf.Reader | Uint8Array
      ): dtalk.proto.ActionUpdateGroupAvatar;

      /**
       * Verifies an ActionUpdateGroupAvatar 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 ActionUpdateGroupAvatar message from a plain object. Also converts values to their respective internal types.
       * @param object Plain object
       * @returns ActionUpdateGroupAvatar
       */
      public static fromObject(object: {
        [k: string]: any;
      }): dtalk.proto.ActionUpdateGroupAvatar;

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

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