import * as $protobuf from 'protobufjs';
/** Namespace base. */
export namespace base {
  /** Properties of a Base. */
  interface IBase {
    /** Base extra */
    extra?: { [k: string]: string } | null;
  }

  /** Represents a Base. */
  class Base implements IBase {
    /**
     * Constructs a new Base.
     * @param [properties] Properties to set
     */
    constructor(properties?: base.IBase);

    /** Base extra. */
    public extra: { [k: string]: string };

    /**
     * Creates a new Base instance using the specified properties.
     * @param [properties] Properties to set
     * @returns Base instance
     */
    public static create(properties?: base.IBase): base.Base;

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

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

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

    /**
     * Decodes a Base message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns Base
     * @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
    ): base.Base;

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

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

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

  /** Properties of a BaseResp. */
  interface IBaseResp {
    /** BaseResp statusCode */
    statusCode?: number | null;

    /** BaseResp statusMessage */
    statusMessage?: string | null;

    /** BaseResp extra */
    extra?: { [k: string]: string } | null;
  }

  /** Represents a BaseResp. */
  class BaseResp implements IBaseResp {
    /**
     * Constructs a new BaseResp.
     * @param [properties] Properties to set
     */
    constructor(properties?: base.IBaseResp);

    /** BaseResp statusCode. */
    public statusCode: number;

    /** BaseResp statusMessage. */
    public statusMessage: string;

    /** BaseResp extra. */
    public extra: { [k: string]: string };

    /**
     * Creates a new BaseResp instance using the specified properties.
     * @param [properties] Properties to set
     * @returns BaseResp instance
     */
    public static create(properties?: base.IBaseResp): base.BaseResp;

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

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

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

    /**
     * Decodes a BaseResp message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns BaseResp
     * @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
    ): base.BaseResp;

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

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

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

  /** Properties of a MapEntry. */
  interface IMapEntry {
    /** MapEntry key */
    key?: string | null;

    /** MapEntry value */
    value?: string | null;
  }

  /** Represents a MapEntry. */
  class MapEntry implements IMapEntry {
    /**
     * Constructs a new MapEntry.
     * @param [properties] Properties to set
     */
    constructor(properties?: base.IMapEntry);

    /** MapEntry key. */
    public key: string;

    /** MapEntry value. */
    public value: string;

    /**
     * Creates a new MapEntry instance using the specified properties.
     * @param [properties] Properties to set
     * @returns MapEntry instance
     */
    public static create(properties?: base.IMapEntry): base.MapEntry;

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

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

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

    /**
     * Decodes a MapEntry message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns MapEntry
     * @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
    ): base.MapEntry;

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

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

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

/** Namespace live. */
export namespace live {
  /** Properties of a Subtitle. */
  interface ISubtitle {
    /** Subtitle language */
    language?: string | null;

    /** Subtitle text */
    text?: string | null;

    /** Subtitle isSpoken */
    isSpoken?: boolean | null;

    /** Subtitle extra */
    extra?: base.IMapEntry[] | null;
  }

  /** Represents a Subtitle. */
  class Subtitle implements ISubtitle {
    /**
     * Constructs a new Subtitle.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.ISubtitle);

    /** Subtitle language. */
    public language: string;

    /** Subtitle text. */
    public text: string;

    /** Subtitle isSpoken. */
    public isSpoken: boolean;

    /** Subtitle extra. */
    public extra: base.IMapEntry[];

    /**
     * Creates a new Subtitle instance using the specified properties.
     * @param [properties] Properties to set
     * @returns Subtitle instance
     */
    public static create(properties?: live.ISubtitle): live.Subtitle;

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

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

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

    /**
     * Decodes a Subtitle message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns Subtitle
     * @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
    ): live.Subtitle;

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

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

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

  /** Properties of a FinalSubtitle. */
  interface IFinalSubtitle {
    /** FinalSubtitle key */
    key?: number | null;

    /** FinalSubtitle version */
    version?: number | null;

    /** FinalSubtitle subversion */
    subversion?: number | null;

    /** FinalSubtitle subtitle */
    subtitle?: live.ISubtitle | null;

    /** FinalSubtitle range */
    range?: si.ITimestamp | null;
  }

  /** Represents a FinalSubtitle. */
  class FinalSubtitle implements IFinalSubtitle {
    /**
     * Constructs a new FinalSubtitle.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IFinalSubtitle);

    /** FinalSubtitle key. */
    public key: number;

    /** FinalSubtitle version. */
    public version: number;

    /** FinalSubtitle subversion. */
    public subversion: number;

    /** FinalSubtitle subtitle. */
    public subtitle?: live.ISubtitle | null;

    /** FinalSubtitle range. */
    public range?: si.ITimestamp | null;

    /**
     * Creates a new FinalSubtitle instance using the specified properties.
     * @param [properties] Properties to set
     * @returns FinalSubtitle instance
     */
    public static create(properties?: live.IFinalSubtitle): live.FinalSubtitle;

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

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

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

    /**
     * Decodes a FinalSubtitle message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns FinalSubtitle
     * @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
    ): live.FinalSubtitle;

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

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

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

  /** Properties of a VolatileSubtitle. */
  interface IVolatileSubtitle {
    /** VolatileSubtitle subtitle */
    subtitle?: live.ISubtitle | null;
  }

  /** Represents a VolatileSubtitle. */
  class VolatileSubtitle implements IVolatileSubtitle {
    /**
     * Constructs a new VolatileSubtitle.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IVolatileSubtitle);

    /** VolatileSubtitle subtitle. */
    public subtitle?: live.ISubtitle | null;

    /**
     * Creates a new VolatileSubtitle instance using the specified properties.
     * @param [properties] Properties to set
     * @returns VolatileSubtitle instance
     */
    public static create(
      properties?: live.IVolatileSubtitle
    ): live.VolatileSubtitle;

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

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

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

    /**
     * Decodes a VolatileSubtitle message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns VolatileSubtitle
     * @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
    ): live.VolatileSubtitle;

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

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

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

  /** Properties of a BroadcastFinalMsg. */
  interface IBroadcastFinalMsg {
    /** BroadcastFinalMsg finalSubtitle */
    finalSubtitle?: live.IFinalSubtitle | null;

    /** BroadcastFinalMsg isManual */
    isManual?: boolean | null;
  }

  /** Represents a BroadcastFinalMsg. */
  class BroadcastFinalMsg implements IBroadcastFinalMsg {
    /**
     * Constructs a new BroadcastFinalMsg.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IBroadcastFinalMsg);

    /** BroadcastFinalMsg finalSubtitle. */
    public finalSubtitle?: live.IFinalSubtitle | null;

    /** BroadcastFinalMsg isManual. */
    public isManual: boolean;

    /**
     * Creates a new BroadcastFinalMsg instance using the specified properties.
     * @param [properties] Properties to set
     * @returns BroadcastFinalMsg instance
     */
    public static create(
      properties?: live.IBroadcastFinalMsg
    ): live.BroadcastFinalMsg;

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

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

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

    /**
     * Decodes a BroadcastFinalMsg message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns BroadcastFinalMsg
     * @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
    ): live.BroadcastFinalMsg;

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

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

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

  /** Properties of a BroadcastVolatileMsg. */
  interface IBroadcastVolatileMsg {
    /** BroadcastVolatileMsg volatileSubtitle */
    volatileSubtitle?: live.IVolatileSubtitle | null;
  }

  /** Represents a BroadcastVolatileMsg. */
  class BroadcastVolatileMsg implements IBroadcastVolatileMsg {
    /**
     * Constructs a new BroadcastVolatileMsg.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IBroadcastVolatileMsg);

    /** BroadcastVolatileMsg volatileSubtitle. */
    public volatileSubtitle?: live.IVolatileSubtitle | null;

    /**
     * Creates a new BroadcastVolatileMsg instance using the specified properties.
     * @param [properties] Properties to set
     * @returns BroadcastVolatileMsg instance
     */
    public static create(
      properties?: live.IBroadcastVolatileMsg
    ): live.BroadcastVolatileMsg;

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

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

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

    /**
     * Decodes a BroadcastVolatileMsg message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns BroadcastVolatileMsg
     * @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
    ): live.BroadcastVolatileMsg;

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

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

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

  /** Properties of a BroadcastMsg. */
  interface IBroadcastMsg {
    /** BroadcastMsg baseResp */
    baseResp?: base.IBaseResp | null;

    /** BroadcastMsg msgType */
    msgType?: live.BroadcastMsg.Type | null;

    /** BroadcastMsg finalMsg */
    finalMsg?: live.IBroadcastFinalMsg | null;

    /** BroadcastMsg volatileMsg */
    volatileMsg?: live.IBroadcastVolatileMsg | null;

    /** BroadcastMsg terminalInfo */
    terminalInfo?: live.ITerminalInfo | null;
  }

  /** Represents a BroadcastMsg. */
  class BroadcastMsg implements IBroadcastMsg {
    /**
     * Constructs a new BroadcastMsg.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IBroadcastMsg);

    /** BroadcastMsg baseResp. */
    public baseResp?: base.IBaseResp | null;

    /** BroadcastMsg msgType. */
    public msgType: live.BroadcastMsg.Type;

    /** BroadcastMsg finalMsg. */
    public finalMsg?: live.IBroadcastFinalMsg | null;

    /** BroadcastMsg volatileMsg. */
    public volatileMsg?: live.IBroadcastVolatileMsg | null;

    /** BroadcastMsg terminalInfo. */
    public terminalInfo?: live.ITerminalInfo | null;

    /** BroadcastMsg msg. */
    public msg?: 'finalMsg' | 'volatileMsg';

    /**
     * Creates a new BroadcastMsg instance using the specified properties.
     * @param [properties] Properties to set
     * @returns BroadcastMsg instance
     */
    public static create(properties?: live.IBroadcastMsg): live.BroadcastMsg;

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

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

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

    /**
     * Decodes a BroadcastMsg message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns BroadcastMsg
     * @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
    ): live.BroadcastMsg;

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

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

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

  namespace BroadcastMsg {
    /** Type enum. */
    enum Type {
      UNSPECIFIED = 0,
      FINAL = 1,
      VOLATILE = 2,
    }
  }

  /** Properties of a TerminalInfo. */
  interface ITerminalInfo {
    /** TerminalInfo deviceId */
    deviceId?: number | null;

    /** TerminalInfo nid */
    nid?: number | null;

    /** TerminalInfo cid */
    cid?: string | null;
  }

  /** Represents a TerminalInfo. */
  class TerminalInfo implements ITerminalInfo {
    /**
     * Constructs a new TerminalInfo.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.ITerminalInfo);

    /** TerminalInfo deviceId. */
    public deviceId: number;

    /** TerminalInfo nid. */
    public nid: number;

    /** TerminalInfo cid. */
    public cid: string;

    /**
     * Creates a new TerminalInfo instance using the specified properties.
     * @param [properties] Properties to set
     * @returns TerminalInfo instance
     */
    public static create(properties?: live.ITerminalInfo): live.TerminalInfo;

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

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

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

    /**
     * Decodes a TerminalInfo message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns TerminalInfo
     * @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
    ): live.TerminalInfo;

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

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

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

  /** Properties of a ConferenceInfo. */
  interface IConferenceInfo {
    /** ConferenceInfo cname */
    cname?: string | null;

    /** ConferenceInfo entry */
    entry?: base.IMapEntry[] | null;
  }

  /** Represents a ConferenceInfo. */
  class ConferenceInfo implements IConferenceInfo {
    /**
     * Constructs a new ConferenceInfo.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IConferenceInfo);

    /** ConferenceInfo cname. */
    public cname: string;

    /** ConferenceInfo entry. */
    public entry: base.IMapEntry[];

    /**
     * Creates a new ConferenceInfo instance using the specified properties.
     * @param [properties] Properties to set
     * @returns ConferenceInfo instance
     */
    public static create(
      properties?: live.IConferenceInfo
    ): live.ConferenceInfo;

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

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

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

    /**
     * Decodes a ConferenceInfo message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns ConferenceInfo
     * @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
    ): live.ConferenceInfo;

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

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

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

  /** Properties of a GetLatestFinalSubtitleReq. */
  interface IGetLatestFinalSubtitleReq {
    /** GetLatestFinalSubtitleReq base */
    base?: base.IBase | null;

    /** GetLatestFinalSubtitleReq terminalInfo */
    terminalInfo?: live.ITerminalInfo | null;

    /** GetLatestFinalSubtitleReq language */
    language?: string | null;

    /** GetLatestFinalSubtitleReq isSpoken */
    isSpoken?: boolean | null;
  }

  /** Represents a GetLatestFinalSubtitleReq. */
  class GetLatestFinalSubtitleReq implements IGetLatestFinalSubtitleReq {
    /**
     * Constructs a new GetLatestFinalSubtitleReq.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IGetLatestFinalSubtitleReq);

    /** GetLatestFinalSubtitleReq base. */
    public base?: base.IBase | null;

    /** GetLatestFinalSubtitleReq terminalInfo. */
    public terminalInfo?: live.ITerminalInfo | null;

    /** GetLatestFinalSubtitleReq language. */
    public language: string;

    /** GetLatestFinalSubtitleReq isSpoken. */
    public isSpoken: boolean;

    /**
     * Creates a new GetLatestFinalSubtitleReq instance using the specified properties.
     * @param [properties] Properties to set
     * @returns GetLatestFinalSubtitleReq instance
     */
    public static create(
      properties?: live.IGetLatestFinalSubtitleReq
    ): live.GetLatestFinalSubtitleReq;

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

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

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

    /**
     * Decodes a GetLatestFinalSubtitleReq message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns GetLatestFinalSubtitleReq
     * @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
    ): live.GetLatestFinalSubtitleReq;

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

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

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

  /** Properties of a GetLatestFinalSubtitleResp. */
  interface IGetLatestFinalSubtitleResp {
    /** GetLatestFinalSubtitleResp baseResp */
    baseResp?: base.IBaseResp | null;

    /** GetLatestFinalSubtitleResp finalSubtitle */
    finalSubtitle?: live.IFinalSubtitle | null;
  }

  /** Represents a GetLatestFinalSubtitleResp. */
  class GetLatestFinalSubtitleResp implements IGetLatestFinalSubtitleResp {
    /**
     * Constructs a new GetLatestFinalSubtitleResp.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IGetLatestFinalSubtitleResp);

    /** GetLatestFinalSubtitleResp baseResp. */
    public baseResp?: base.IBaseResp | null;

    /** GetLatestFinalSubtitleResp finalSubtitle. */
    public finalSubtitle?: live.IFinalSubtitle | null;

    /**
     * Creates a new GetLatestFinalSubtitleResp instance using the specified properties.
     * @param [properties] Properties to set
     * @returns GetLatestFinalSubtitleResp instance
     */
    public static create(
      properties?: live.IGetLatestFinalSubtitleResp
    ): live.GetLatestFinalSubtitleResp;

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

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

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

    /**
     * Decodes a GetLatestFinalSubtitleResp message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns GetLatestFinalSubtitleResp
     * @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
    ): live.GetLatestFinalSubtitleResp;

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

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

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

  /** Properties of a GetFinalSubtitlesReq. */
  interface IGetFinalSubtitlesReq {
    /** GetFinalSubtitlesReq base */
    base?: base.IBase | null;

    /** GetFinalSubtitlesReq terminalInfo */
    terminalInfo?: live.ITerminalInfo | null;

    /** GetFinalSubtitlesReq keyList */
    keyList?: number[] | null;

    /** GetFinalSubtitlesReq language */
    language?: string | null;

    /** GetFinalSubtitlesReq isSpoken */
    isSpoken?: boolean | null;
  }

  /** Represents a GetFinalSubtitlesReq. */
  class GetFinalSubtitlesReq implements IGetFinalSubtitlesReq {
    /**
     * Constructs a new GetFinalSubtitlesReq.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IGetFinalSubtitlesReq);

    /** GetFinalSubtitlesReq base. */
    public base?: base.IBase | null;

    /** GetFinalSubtitlesReq terminalInfo. */
    public terminalInfo?: live.ITerminalInfo | null;

    /** GetFinalSubtitlesReq keyList. */
    public keyList: number[];

    /** GetFinalSubtitlesReq language. */
    public language: string;

    /** GetFinalSubtitlesReq isSpoken. */
    public isSpoken: boolean;

    /**
     * Creates a new GetFinalSubtitlesReq instance using the specified properties.
     * @param [properties] Properties to set
     * @returns GetFinalSubtitlesReq instance
     */
    public static create(
      properties?: live.IGetFinalSubtitlesReq
    ): live.GetFinalSubtitlesReq;

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

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

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

    /**
     * Decodes a GetFinalSubtitlesReq message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns GetFinalSubtitlesReq
     * @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
    ): live.GetFinalSubtitlesReq;

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

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

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

  /** Properties of a GetFinalSubtitlesResp. */
  interface IGetFinalSubtitlesResp {
    /** GetFinalSubtitlesResp baseResp */
    baseResp?: base.IBaseResp | null;

    /** GetFinalSubtitlesResp finalSubtitleList */
    finalSubtitleList?: live.IFinalSubtitle[] | null;
  }

  /** Represents a GetFinalSubtitlesResp. */
  class GetFinalSubtitlesResp implements IGetFinalSubtitlesResp {
    /**
     * Constructs a new GetFinalSubtitlesResp.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IGetFinalSubtitlesResp);

    /** GetFinalSubtitlesResp baseResp. */
    public baseResp?: base.IBaseResp | null;

    /** GetFinalSubtitlesResp finalSubtitleList. */
    public finalSubtitleList: live.IFinalSubtitle[];

    /**
     * Creates a new GetFinalSubtitlesResp instance using the specified properties.
     * @param [properties] Properties to set
     * @returns GetFinalSubtitlesResp instance
     */
    public static create(
      properties?: live.IGetFinalSubtitlesResp
    ): live.GetFinalSubtitlesResp;

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

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

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

    /**
     * Decodes a GetFinalSubtitlesResp message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns GetFinalSubtitlesResp
     * @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
    ): live.GetFinalSubtitlesResp;

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

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

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

  /** Properties of an UpdateFinalSubtitleReq. */
  interface IUpdateFinalSubtitleReq {
    /** UpdateFinalSubtitleReq base */
    base?: base.IBase | null;

    /** UpdateFinalSubtitleReq terminalInfo */
    terminalInfo?: live.ITerminalInfo | null;

    /** UpdateFinalSubtitleReq finalSubtitle */
    finalSubtitle?: live.IFinalSubtitle | null;
  }

  /** Represents an UpdateFinalSubtitleReq. */
  class UpdateFinalSubtitleReq implements IUpdateFinalSubtitleReq {
    /**
     * Constructs a new UpdateFinalSubtitleReq.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IUpdateFinalSubtitleReq);

    /** UpdateFinalSubtitleReq base. */
    public base?: base.IBase | null;

    /** UpdateFinalSubtitleReq terminalInfo. */
    public terminalInfo?: live.ITerminalInfo | null;

    /** UpdateFinalSubtitleReq finalSubtitle. */
    public finalSubtitle?: live.IFinalSubtitle | null;

    /**
     * Creates a new UpdateFinalSubtitleReq instance using the specified properties.
     * @param [properties] Properties to set
     * @returns UpdateFinalSubtitleReq instance
     */
    public static create(
      properties?: live.IUpdateFinalSubtitleReq
    ): live.UpdateFinalSubtitleReq;

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

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

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

    /**
     * Decodes an UpdateFinalSubtitleReq message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns UpdateFinalSubtitleReq
     * @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
    ): live.UpdateFinalSubtitleReq;

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

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

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

  /** Properties of an UpdateFinalSubtitleResp. */
  interface IUpdateFinalSubtitleResp {
    /** UpdateFinalSubtitleResp baseResp */
    baseResp?: base.IBaseResp | null;
  }

  /** Represents an UpdateFinalSubtitleResp. */
  class UpdateFinalSubtitleResp implements IUpdateFinalSubtitleResp {
    /**
     * Constructs a new UpdateFinalSubtitleResp.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IUpdateFinalSubtitleResp);

    /** UpdateFinalSubtitleResp baseResp. */
    public baseResp?: base.IBaseResp | null;

    /**
     * Creates a new UpdateFinalSubtitleResp instance using the specified properties.
     * @param [properties] Properties to set
     * @returns UpdateFinalSubtitleResp instance
     */
    public static create(
      properties?: live.IUpdateFinalSubtitleResp
    ): live.UpdateFinalSubtitleResp;

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

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

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

    /**
     * Decodes an UpdateFinalSubtitleResp message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns UpdateFinalSubtitleResp
     * @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
    ): live.UpdateFinalSubtitleResp;

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

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

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

  /** Properties of a Minutes. */
  interface IMinutes {
    /** Minutes subtitles */
    subtitles?: live.IFinalSubtitle[] | null;
  }

  /** Represents a Minutes. */
  class Minutes implements IMinutes {
    /**
     * Constructs a new Minutes.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IMinutes);

    /** Minutes subtitles. */
    public subtitles: live.IFinalSubtitle[];

    /**
     * Creates a new Minutes instance using the specified properties.
     * @param [properties] Properties to set
     * @returns Minutes instance
     */
    public static create(properties?: live.IMinutes): live.Minutes;

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

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

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

    /**
     * Decodes a Minutes message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns Minutes
     * @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
    ): live.Minutes;

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

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

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

  /** MinuteFormat enum. */
  enum MinuteFormat {
    UNSPECIFIED_FORMAT = 0,
    RAW = 1,
    PLAIN_TEXT = 2,
  }

  /** MinuteType enum. */
  enum MinuteType {
    UNSPECIFIED_TYPE = 0,
    UNMODIFIED_TRANSCRIPTS = 1,
    MANUAL_EDIT_TRANSCRIPTS = 2,
    MANUAL_EDIT_TRANSLATIONS = 4,
  }

  /** Properties of an OrganizeMinutesReq. */
  interface IOrganizeMinutesReq {
    /** OrganizeMinutesReq base */
    base?: base.IBase | null;

    /** OrganizeMinutesReq terminalInfo */
    terminalInfo?: live.ITerminalInfo | null;

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

    /** OrganizeMinutesReq language */
    language?: string | null;
  }

  /** Represents an OrganizeMinutesReq. */
  class OrganizeMinutesReq implements IOrganizeMinutesReq {
    /**
     * Constructs a new OrganizeMinutesReq.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IOrganizeMinutesReq);

    /** OrganizeMinutesReq base. */
    public base?: base.IBase | null;

    /** OrganizeMinutesReq terminalInfo. */
    public terminalInfo?: live.ITerminalInfo | null;

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

    /** OrganizeMinutesReq language. */
    public language: string;

    /**
     * Creates a new OrganizeMinutesReq instance using the specified properties.
     * @param [properties] Properties to set
     * @returns OrganizeMinutesReq instance
     */
    public static create(
      properties?: live.IOrganizeMinutesReq
    ): live.OrganizeMinutesReq;

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

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

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

    /**
     * Decodes an OrganizeMinutesReq message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns OrganizeMinutesReq
     * @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
    ): live.OrganizeMinutesReq;

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

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

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

  /** Properties of an OrganizeMinutesResp. */
  interface IOrganizeMinutesResp {
    /** OrganizeMinutesResp baseResp */
    baseResp?: base.IBaseResp | null;
  }

  /** Represents an OrganizeMinutesResp. */
  class OrganizeMinutesResp implements IOrganizeMinutesResp {
    /**
     * Constructs a new OrganizeMinutesResp.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IOrganizeMinutesResp);

    /** OrganizeMinutesResp baseResp. */
    public baseResp?: base.IBaseResp | null;

    /**
     * Creates a new OrganizeMinutesResp instance using the specified properties.
     * @param [properties] Properties to set
     * @returns OrganizeMinutesResp instance
     */
    public static create(
      properties?: live.IOrganizeMinutesResp
    ): live.OrganizeMinutesResp;

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

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

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

    /**
     * Decodes an OrganizeMinutesResp message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns OrganizeMinutesResp
     * @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
    ): live.OrganizeMinutesResp;

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

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

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

  /** Properties of a DownloadMinutesReq. */
  interface IDownloadMinutesReq {
    /** DownloadMinutesReq base */
    base?: base.IBase | null;

    /** DownloadMinutesReq terminalInfo */
    terminalInfo?: live.ITerminalInfo | null;
  }

  /** Represents a DownloadMinutesReq. */
  class DownloadMinutesReq implements IDownloadMinutesReq {
    /**
     * Constructs a new DownloadMinutesReq.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IDownloadMinutesReq);

    /** DownloadMinutesReq base. */
    public base?: base.IBase | null;

    /** DownloadMinutesReq terminalInfo. */
    public terminalInfo?: live.ITerminalInfo | null;

    /**
     * Creates a new DownloadMinutesReq instance using the specified properties.
     * @param [properties] Properties to set
     * @returns DownloadMinutesReq instance
     */
    public static create(
      properties?: live.IDownloadMinutesReq
    ): live.DownloadMinutesReq;

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

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

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

    /**
     * Decodes a DownloadMinutesReq message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns DownloadMinutesReq
     * @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
    ): live.DownloadMinutesReq;

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

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

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

  /** Properties of a DownloadMinutesResp. */
  interface IDownloadMinutesResp {
    /** DownloadMinutesResp baseResp */
    baseResp?: base.IBaseResp | null;

    /** DownloadMinutesResp minutes */
    minutes?: base.IMapEntry[] | null;
  }

  /** Represents a DownloadMinutesResp. */
  class DownloadMinutesResp implements IDownloadMinutesResp {
    /**
     * Constructs a new DownloadMinutesResp.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IDownloadMinutesResp);

    /** DownloadMinutesResp baseResp. */
    public baseResp?: base.IBaseResp | null;

    /** DownloadMinutesResp minutes. */
    public minutes: base.IMapEntry[];

    /**
     * Creates a new DownloadMinutesResp instance using the specified properties.
     * @param [properties] Properties to set
     * @returns DownloadMinutesResp instance
     */
    public static create(
      properties?: live.IDownloadMinutesResp
    ): live.DownloadMinutesResp;

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

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

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

    /**
     * Decodes a DownloadMinutesResp message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns DownloadMinutesResp
     * @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
    ): live.DownloadMinutesResp;

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

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

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

  /** Properties of a CreateRoomReq. */
  interface ICreateRoomReq {
    /** CreateRoomReq base */
    base?: base.IBase | null;

    /** CreateRoomReq terminalInfo */
    terminalInfo?: live.ITerminalInfo | null;

    /** CreateRoomReq conferenceInfo */
    conferenceInfo?: live.IConferenceInfo | null;

    /** CreateRoomReq unixTimestamps */
    unixTimestamps?: Long | null;
  }

  /** Represents a CreateRoomReq. */
  class CreateRoomReq implements ICreateRoomReq {
    /**
     * Constructs a new CreateRoomReq.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.ICreateRoomReq);

    /** CreateRoomReq base. */
    public base?: base.IBase | null;

    /** CreateRoomReq terminalInfo. */
    public terminalInfo?: live.ITerminalInfo | null;

    /** CreateRoomReq conferenceInfo. */
    public conferenceInfo?: live.IConferenceInfo | null;

    /** CreateRoomReq unixTimestamps. */
    public unixTimestamps: Long;

    /**
     * Creates a new CreateRoomReq instance using the specified properties.
     * @param [properties] Properties to set
     * @returns CreateRoomReq instance
     */
    public static create(properties?: live.ICreateRoomReq): live.CreateRoomReq;

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

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

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

    /**
     * Decodes a CreateRoomReq message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns CreateRoomReq
     * @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
    ): live.CreateRoomReq;

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

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

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

  /** Properties of a CreateRoomResp. */
  interface ICreateRoomResp {
    /** CreateRoomResp baseResp */
    baseResp?: base.IBaseResp | null;

    /** CreateRoomResp terminalInfo */
    terminalInfo?: live.ITerminalInfo | null;
  }

  /** Represents a CreateRoomResp. */
  class CreateRoomResp implements ICreateRoomResp {
    /**
     * Constructs a new CreateRoomResp.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.ICreateRoomResp);

    /** CreateRoomResp baseResp. */
    public baseResp?: base.IBaseResp | null;

    /** CreateRoomResp terminalInfo. */
    public terminalInfo?: live.ITerminalInfo | null;

    /**
     * Creates a new CreateRoomResp instance using the specified properties.
     * @param [properties] Properties to set
     * @returns CreateRoomResp instance
     */
    public static create(
      properties?: live.ICreateRoomResp
    ): live.CreateRoomResp;

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

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

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

    /**
     * Decodes a CreateRoomResp message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns CreateRoomResp
     * @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
    ): live.CreateRoomResp;

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

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

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

  /** Properties of a StartRoomReq. */
  interface IStartRoomReq {
    /** StartRoomReq base */
    base?: base.IBase | null;

    /** StartRoomReq terminalInfo */
    terminalInfo?: live.ITerminalInfo | null;

    /** StartRoomReq unixTimestamps */
    unixTimestamps?: Long | null;
  }

  /** Represents a StartRoomReq. */
  class StartRoomReq implements IStartRoomReq {
    /**
     * Constructs a new StartRoomReq.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IStartRoomReq);

    /** StartRoomReq base. */
    public base?: base.IBase | null;

    /** StartRoomReq terminalInfo. */
    public terminalInfo?: live.ITerminalInfo | null;

    /** StartRoomReq unixTimestamps. */
    public unixTimestamps: Long;

    /**
     * Creates a new StartRoomReq instance using the specified properties.
     * @param [properties] Properties to set
     * @returns StartRoomReq instance
     */
    public static create(properties?: live.IStartRoomReq): live.StartRoomReq;

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

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

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

    /**
     * Decodes a StartRoomReq message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns StartRoomReq
     * @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
    ): live.StartRoomReq;

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

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

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

  /** Properties of a StartRoomResp. */
  interface IStartRoomResp {
    /** StartRoomResp baseResp */
    baseResp?: base.IBaseResp | null;

    /** StartRoomResp terminalInfo */
    terminalInfo?: live.ITerminalInfo | null;
  }

  /** Represents a StartRoomResp. */
  class StartRoomResp implements IStartRoomResp {
    /**
     * Constructs a new StartRoomResp.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IStartRoomResp);

    /** StartRoomResp baseResp. */
    public baseResp?: base.IBaseResp | null;

    /** StartRoomResp terminalInfo. */
    public terminalInfo?: live.ITerminalInfo | null;

    /**
     * Creates a new StartRoomResp instance using the specified properties.
     * @param [properties] Properties to set
     * @returns StartRoomResp instance
     */
    public static create(properties?: live.IStartRoomResp): live.StartRoomResp;

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

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

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

    /**
     * Decodes a StartRoomResp message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns StartRoomResp
     * @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
    ): live.StartRoomResp;

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

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

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

  /** Properties of a DeleteRoomReq. */
  interface IDeleteRoomReq {
    /** DeleteRoomReq base */
    base?: base.IBase | null;

    /** DeleteRoomReq terminalInfo */
    terminalInfo?: live.ITerminalInfo | null;
  }

  /** Represents a DeleteRoomReq. */
  class DeleteRoomReq implements IDeleteRoomReq {
    /**
     * Constructs a new DeleteRoomReq.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IDeleteRoomReq);

    /** DeleteRoomReq base. */
    public base?: base.IBase | null;

    /** DeleteRoomReq terminalInfo. */
    public terminalInfo?: live.ITerminalInfo | null;

    /**
     * Creates a new DeleteRoomReq instance using the specified properties.
     * @param [properties] Properties to set
     * @returns DeleteRoomReq instance
     */
    public static create(properties?: live.IDeleteRoomReq): live.DeleteRoomReq;

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

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

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

    /**
     * Decodes a DeleteRoomReq message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns DeleteRoomReq
     * @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
    ): live.DeleteRoomReq;

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

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

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

  /** Properties of a DeleteRoomResp. */
  interface IDeleteRoomResp {
    /** DeleteRoomResp baseResp */
    baseResp?: base.IBaseResp | null;
  }

  /** Represents a DeleteRoomResp. */
  class DeleteRoomResp implements IDeleteRoomResp {
    /**
     * Constructs a new DeleteRoomResp.
     * @param [properties] Properties to set
     */
    constructor(properties?: live.IDeleteRoomResp);

    /** DeleteRoomResp baseResp. */
    public baseResp?: base.IBaseResp | null;

    /**
     * Creates a new DeleteRoomResp instance using the specified properties.
     * @param [properties] Properties to set
     * @returns DeleteRoomResp instance
     */
    public static create(
      properties?: live.IDeleteRoomResp
    ): live.DeleteRoomResp;

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

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

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

    /**
     * Decodes a DeleteRoomResp message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns DeleteRoomResp
     * @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
    ): live.DeleteRoomResp;

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

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

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

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

    /**
     * Creates new LiveService service using the specified rpc implementation.
     * @param rpcImpl RPC implementation
     * @param [requestDelimited=false] Whether requests are length-delimited
     * @param [responseDelimited=false] Whether responses are length-delimited
     * @returns RPC service. Useful where requests and/or responses are streamed.
     */
    public static create(
      rpcImpl: $protobuf.RPCImpl,
      requestDelimited?: boolean,
      responseDelimited?: boolean
    ): LiveService;

    /**
     * Calls GetLatestFinalSubtitle.
     * @param request GetLatestFinalSubtitleReq message or plain object
     * @param callback Node-style callback called with the error, if any, and GetLatestFinalSubtitleResp
     */
    public getLatestFinalSubtitle(
      request: live.IGetLatestFinalSubtitleReq,
      callback: live.LiveService.GetLatestFinalSubtitleCallback
    ): void;

    /**
     * Calls GetLatestFinalSubtitle.
     * @param request GetLatestFinalSubtitleReq message or plain object
     * @returns Promise
     */
    public getLatestFinalSubtitle(
      request: live.IGetLatestFinalSubtitleReq
    ): Promise<live.GetLatestFinalSubtitleResp>;

    /**
     * Calls GetFinalSubtitles.
     * @param request GetFinalSubtitlesReq message or plain object
     * @param callback Node-style callback called with the error, if any, and GetFinalSubtitlesResp
     */
    public getFinalSubtitles(
      request: live.IGetFinalSubtitlesReq,
      callback: live.LiveService.GetFinalSubtitlesCallback
    ): void;

    /**
     * Calls GetFinalSubtitles.
     * @param request GetFinalSubtitlesReq message or plain object
     * @returns Promise
     */
    public getFinalSubtitles(
      request: live.IGetFinalSubtitlesReq
    ): Promise<live.GetFinalSubtitlesResp>;

    /**
     * Calls UpdateFinalSubtitle.
     * @param request UpdateFinalSubtitleReq message or plain object
     * @param callback Node-style callback called with the error, if any, and UpdateFinalSubtitleResp
     */
    public updateFinalSubtitle(
      request: live.IUpdateFinalSubtitleReq,
      callback: live.LiveService.UpdateFinalSubtitleCallback
    ): void;

    /**
     * Calls UpdateFinalSubtitle.
     * @param request UpdateFinalSubtitleReq message or plain object
     * @returns Promise
     */
    public updateFinalSubtitle(
      request: live.IUpdateFinalSubtitleReq
    ): Promise<live.UpdateFinalSubtitleResp>;

    /**
     * Calls OrganizeMinutes.
     * @param request OrganizeMinutesReq message or plain object
     * @param callback Node-style callback called with the error, if any, and OrganizeMinutesResp
     */
    public organizeMinutes(
      request: live.IOrganizeMinutesReq,
      callback: live.LiveService.OrganizeMinutesCallback
    ): void;

    /**
     * Calls OrganizeMinutes.
     * @param request OrganizeMinutesReq message or plain object
     * @returns Promise
     */
    public organizeMinutes(
      request: live.IOrganizeMinutesReq
    ): Promise<live.OrganizeMinutesResp>;

    /**
     * Calls DownloadMinutes.
     * @param request DownloadMinutesReq message or plain object
     * @param callback Node-style callback called with the error, if any, and DownloadMinutesResp
     */
    public downloadMinutes(
      request: live.IDownloadMinutesReq,
      callback: live.LiveService.DownloadMinutesCallback
    ): void;

    /**
     * Calls DownloadMinutes.
     * @param request DownloadMinutesReq message or plain object
     * @returns Promise
     */
    public downloadMinutes(
      request: live.IDownloadMinutesReq
    ): Promise<live.DownloadMinutesResp>;

    /**
     * Calls DeleteRoom.
     * @param request DeleteRoomReq message or plain object
     * @param callback Node-style callback called with the error, if any, and DeleteRoomResp
     */
    public deleteRoom(
      request: live.IDeleteRoomReq,
      callback: live.LiveService.DeleteRoomCallback
    ): void;

    /**
     * Calls DeleteRoom.
     * @param request DeleteRoomReq message or plain object
     * @returns Promise
     */
    public deleteRoom(
      request: live.IDeleteRoomReq
    ): Promise<live.DeleteRoomResp>;

    /**
     * Calls CreateRoom.
     * @param request CreateRoomReq message or plain object
     * @param callback Node-style callback called with the error, if any, and CreateRoomResp
     */
    public createRoom(
      request: live.ICreateRoomReq,
      callback: live.LiveService.CreateRoomCallback
    ): void;

    /**
     * Calls CreateRoom.
     * @param request CreateRoomReq message or plain object
     * @returns Promise
     */
    public createRoom(
      request: live.ICreateRoomReq
    ): Promise<live.CreateRoomResp>;

    /**
     * Calls StartRoom.
     * @param request StartRoomReq message or plain object
     * @param callback Node-style callback called with the error, if any, and StartRoomResp
     */
    public startRoom(
      request: live.IStartRoomReq,
      callback: live.LiveService.StartRoomCallback
    ): void;

    /**
     * Calls StartRoom.
     * @param request StartRoomReq message or plain object
     * @returns Promise
     */
    public startRoom(request: live.IStartRoomReq): Promise<live.StartRoomResp>;
  }

  namespace LiveService {
    /**
     * Callback as used by {@link live.LiveService#getLatestFinalSubtitle}.
     * @param error Error, if any
     * @param [response] GetLatestFinalSubtitleResp
     */
    type GetLatestFinalSubtitleCallback = (
      error: Error | null,
      response?: live.GetLatestFinalSubtitleResp
    ) => void;

    /**
     * Callback as used by {@link live.LiveService#getFinalSubtitles}.
     * @param error Error, if any
     * @param [response] GetFinalSubtitlesResp
     */
    type GetFinalSubtitlesCallback = (
      error: Error | null,
      response?: live.GetFinalSubtitlesResp
    ) => void;

    /**
     * Callback as used by {@link live.LiveService#updateFinalSubtitle}.
     * @param error Error, if any
     * @param [response] UpdateFinalSubtitleResp
     */
    type UpdateFinalSubtitleCallback = (
      error: Error | null,
      response?: live.UpdateFinalSubtitleResp
    ) => void;

    /**
     * Callback as used by {@link live.LiveService#organizeMinutes}.
     * @param error Error, if any
     * @param [response] OrganizeMinutesResp
     */
    type OrganizeMinutesCallback = (
      error: Error | null,
      response?: live.OrganizeMinutesResp
    ) => void;

    /**
     * Callback as used by {@link live.LiveService#downloadMinutes}.
     * @param error Error, if any
     * @param [response] DownloadMinutesResp
     */
    type DownloadMinutesCallback = (
      error: Error | null,
      response?: live.DownloadMinutesResp
    ) => void;

    /**
     * Callback as used by {@link live.LiveService#deleteRoom}.
     * @param error Error, if any
     * @param [response] DeleteRoomResp
     */
    type DeleteRoomCallback = (
      error: Error | null,
      response?: live.DeleteRoomResp
    ) => void;

    /**
     * Callback as used by {@link live.LiveService#createRoom}.
     * @param error Error, if any
     * @param [response] CreateRoomResp
     */
    type CreateRoomCallback = (
      error: Error | null,
      response?: live.CreateRoomResp
    ) => void;

    /**
     * Callback as used by {@link live.LiveService#startRoom}.
     * @param error Error, if any
     * @param [response] StartRoomResp
     */
    type StartRoomCallback = (
      error: Error | null,
      response?: live.StartRoomResp
    ) => void;
  }
}

/** Namespace si. */
export namespace si {
  /** Properties of a SpeechInputsMessage. */
  interface ISpeechInputsMessage {
    /** SpeechInputsMessage eventType */
    eventType?: si.SpeechInputsMessage.SpeechEventType | null;

    /** SpeechInputsMessage configuration */
    configuration?: si.ISimultaneousInterpretationConfiguration | null;

    /** SpeechInputsMessage audio */
    audio?: si.IAudioPacket | null;
  }

  /** Represents a SpeechInputsMessage. */
  class SpeechInputsMessage implements ISpeechInputsMessage {
    /**
     * Constructs a new SpeechInputsMessage.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ISpeechInputsMessage);

    /** SpeechInputsMessage eventType. */
    public eventType: si.SpeechInputsMessage.SpeechEventType;

    /** SpeechInputsMessage configuration. */
    public configuration?: si.ISimultaneousInterpretationConfiguration | null;

    /** SpeechInputsMessage audio. */
    public audio?: si.IAudioPacket | null;

    /** SpeechInputsMessage inputs. */
    public inputs?: 'configuration' | 'audio';

    /**
     * Creates a new SpeechInputsMessage instance using the specified properties.
     * @param [properties] Properties to set
     * @returns SpeechInputsMessage instance
     */
    public static create(
      properties?: si.ISpeechInputsMessage
    ): si.SpeechInputsMessage;

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

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

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

    /**
     * Decodes a SpeechInputsMessage message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns SpeechInputsMessage
     * @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
    ): si.SpeechInputsMessage;

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

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

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

  namespace SpeechInputsMessage {
    /** SpeechEventType enum. */
    enum SpeechEventType {
      UNSPECIFIED = 0,
      CONFIGURATION = 1,
      AUDIO = 2,
    }
  }

  /** Properties of a SpeechOutputsMessage. */
  interface ISpeechOutputsMessage {
    /** SpeechOutputsMessage baseResp */
    baseResp?: base.IBaseResp | null;

    /** SpeechOutputsMessage taskId */
    taskId?: string | null;
  }

  /** Represents a SpeechOutputsMessage. */
  class SpeechOutputsMessage implements ISpeechOutputsMessage {
    /**
     * Constructs a new SpeechOutputsMessage.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ISpeechOutputsMessage);

    /** SpeechOutputsMessage baseResp. */
    public baseResp?: base.IBaseResp | null;

    /** SpeechOutputsMessage taskId. */
    public taskId: string;

    /**
     * Creates a new SpeechOutputsMessage instance using the specified properties.
     * @param [properties] Properties to set
     * @returns SpeechOutputsMessage instance
     */
    public static create(
      properties?: si.ISpeechOutputsMessage
    ): si.SpeechOutputsMessage;

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

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

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

    /**
     * Decodes a SpeechOutputsMessage message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns SpeechOutputsMessage
     * @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
    ): si.SpeechOutputsMessage;

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

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

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

  /** Properties of an AudioPacket. */
  interface IAudioPacket {
    /** AudioPacket sequence */
    sequence?: Long | null;

    /** AudioPacket binary */
    binary?: Uint8Array | null;

    /** AudioPacket ptsMs */
    ptsMs?: Long | null;

    /** AudioPacket durationMs */
    durationMs?: Long | null;

    /** AudioPacket unixMs */
    unixMs?: Long | null;
  }

  /** Represents an AudioPacket. */
  class AudioPacket implements IAudioPacket {
    /**
     * Constructs a new AudioPacket.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.IAudioPacket);

    /** AudioPacket sequence. */
    public sequence: Long;

    /** AudioPacket binary. */
    public binary: Uint8Array;

    /** AudioPacket ptsMs. */
    public ptsMs: Long;

    /** AudioPacket durationMs. */
    public durationMs: Long;

    /** AudioPacket unixMs. */
    public unixMs: Long;

    /**
     * Creates a new AudioPacket instance using the specified properties.
     * @param [properties] Properties to set
     * @returns AudioPacket instance
     */
    public static create(properties?: si.IAudioPacket): si.AudioPacket;

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

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

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

    /**
     * Decodes an AudioPacket message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns AudioPacket
     * @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
    ): si.AudioPacket;

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

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

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

  /** Properties of a SimultaneousInterpretationConfiguration. */
  interface ISimultaneousInterpretationConfiguration {
    /** SimultaneousInterpretationConfiguration recognition */
    recognition?: si.ISpeechRecognitionConfiguration | null;

    /** SimultaneousInterpretationConfiguration translation */
    translation?: si.ITranslationConfiguration | null;
  }

  /** Represents a SimultaneousInterpretationConfiguration. */
  class SimultaneousInterpretationConfiguration
    implements ISimultaneousInterpretationConfiguration {
    /**
     * Constructs a new SimultaneousInterpretationConfiguration.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ISimultaneousInterpretationConfiguration);

    /** SimultaneousInterpretationConfiguration recognition. */
    public recognition?: si.ISpeechRecognitionConfiguration | null;

    /** SimultaneousInterpretationConfiguration translation. */
    public translation?: si.ITranslationConfiguration | null;

    /**
     * Creates a new SimultaneousInterpretationConfiguration instance using the specified properties.
     * @param [properties] Properties to set
     * @returns SimultaneousInterpretationConfiguration instance
     */
    public static create(
      properties?: si.ISimultaneousInterpretationConfiguration
    ): si.SimultaneousInterpretationConfiguration;

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

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

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

    /**
     * Decodes a SimultaneousInterpretationConfiguration message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns SimultaneousInterpretationConfiguration
     * @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
    ): si.SimultaneousInterpretationConfiguration;

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

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

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

  /** Properties of a SpeechRecognitionConfiguration. */
  interface ISpeechRecognitionConfiguration {
    /** SpeechRecognitionConfiguration languageCode */
    languageCode?: string | null;

    /** SpeechRecognitionConfiguration speechProvider */
    speechProvider?: string | null;

    /** SpeechRecognitionConfiguration speechContexts */
    speechContexts?: string[] | null;

    /** SpeechRecognitionConfiguration timestampAlignment */
    timestampAlignment?: boolean | null;
  }

  /** Represents a SpeechRecognitionConfiguration. */
  class SpeechRecognitionConfiguration
    implements ISpeechRecognitionConfiguration {
    /**
     * Constructs a new SpeechRecognitionConfiguration.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ISpeechRecognitionConfiguration);

    /** SpeechRecognitionConfiguration languageCode. */
    public languageCode: string;

    /** SpeechRecognitionConfiguration speechProvider. */
    public speechProvider: string;

    /** SpeechRecognitionConfiguration speechContexts. */
    public speechContexts: string[];

    /** SpeechRecognitionConfiguration timestampAlignment. */
    public timestampAlignment: boolean;

    /**
     * Creates a new SpeechRecognitionConfiguration instance using the specified properties.
     * @param [properties] Properties to set
     * @returns SpeechRecognitionConfiguration instance
     */
    public static create(
      properties?: si.ISpeechRecognitionConfiguration
    ): si.SpeechRecognitionConfiguration;

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

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

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

    /**
     * Decodes a SpeechRecognitionConfiguration message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns SpeechRecognitionConfiguration
     * @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
    ): si.SpeechRecognitionConfiguration;

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

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

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

  /** Properties of a TranslationConfiguration. */
  interface ITranslationConfiguration {
    /** TranslationConfiguration languageCodes */
    languageCodes?: string[] | null;
  }

  /** Represents a TranslationConfiguration. */
  class TranslationConfiguration implements ITranslationConfiguration {
    /**
     * Constructs a new TranslationConfiguration.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ITranslationConfiguration);

    /** TranslationConfiguration languageCodes. */
    public languageCodes: string[];

    /**
     * Creates a new TranslationConfiguration instance using the specified properties.
     * @param [properties] Properties to set
     * @returns TranslationConfiguration instance
     */
    public static create(
      properties?: si.ITranslationConfiguration
    ): si.TranslationConfiguration;

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

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

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

    /**
     * Decodes a TranslationConfiguration message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns TranslationConfiguration
     * @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
    ): si.TranslationConfiguration;

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

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

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

  /** Properties of a SimultaneousInterpretationResponse. */
  interface ISimultaneousInterpretationResponse {
    /** SimultaneousInterpretationResponse baseResp */
    baseResp?: base.IBaseResp | null;

    /** SimultaneousInterpretationResponse taskId */
    taskId?: string | null;

    /** SimultaneousInterpretationResponse subtitle */
    subtitle?: si.ISubtitleIRL | null;

    /** SimultaneousInterpretationResponse endFlag */
    endFlag?: boolean | null;

    /** SimultaneousInterpretationResponse createTime */
    createTime?: Long | null;
  }

  /** Represents a SimultaneousInterpretationResponse. */
  class SimultaneousInterpretationResponse
    implements ISimultaneousInterpretationResponse {
    /**
     * Constructs a new SimultaneousInterpretationResponse.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ISimultaneousInterpretationResponse);

    /** SimultaneousInterpretationResponse baseResp. */
    public baseResp?: base.IBaseResp | null;

    /** SimultaneousInterpretationResponse taskId. */
    public taskId: string;

    /** SimultaneousInterpretationResponse subtitle. */
    public subtitle?: si.ISubtitleIRL | null;

    /** SimultaneousInterpretationResponse endFlag. */
    public endFlag: boolean;

    /** SimultaneousInterpretationResponse createTime. */
    public createTime: Long;

    /**
     * Creates a new SimultaneousInterpretationResponse instance using the specified properties.
     * @param [properties] Properties to set
     * @returns SimultaneousInterpretationResponse instance
     */
    public static create(
      properties?: si.ISimultaneousInterpretationResponse
    ): si.SimultaneousInterpretationResponse;

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

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

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

    /**
     * Decodes a SimultaneousInterpretationResponse message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns SimultaneousInterpretationResponse
     * @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
    ): si.SimultaneousInterpretationResponse;

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

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

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

  /** Properties of a SimultaneousInterpretationScene. */
  interface ISimultaneousInterpretationScene {
    /** SimultaneousInterpretationScene env */
    env?: si.SimultaneousInterpretationScene.Environ | null;

    /** SimultaneousInterpretationScene scene */
    scene?: si.SimultaneousInterpretationScene.Scene | null;
  }

  /** Represents a SimultaneousInterpretationScene. */
  class SimultaneousInterpretationScene
    implements ISimultaneousInterpretationScene {
    /**
     * Constructs a new SimultaneousInterpretationScene.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ISimultaneousInterpretationScene);

    /** SimultaneousInterpretationScene env. */
    public env: si.SimultaneousInterpretationScene.Environ;

    /** SimultaneousInterpretationScene scene. */
    public scene: si.SimultaneousInterpretationScene.Scene;

    /**
     * Creates a new SimultaneousInterpretationScene instance using the specified properties.
     * @param [properties] Properties to set
     * @returns SimultaneousInterpretationScene instance
     */
    public static create(
      properties?: si.ISimultaneousInterpretationScene
    ): si.SimultaneousInterpretationScene;

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

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

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

    /**
     * Decodes a SimultaneousInterpretationScene message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns SimultaneousInterpretationScene
     * @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
    ): si.SimultaneousInterpretationScene;

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

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

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

  namespace SimultaneousInterpretationScene {
    /** Environ enum. */
    enum Environ {
      UNSPECIFIED = 0,
      RELEASE = 1,
      STAGING = 2,
      DEVELOP = 3,
    }

    /** Scene enum. */
    enum Scene {
      BYTE_SI = 0,
      BROADCAST = 1,
      EXTERNAL = 2,
    }
  }

  /** Properties of a Subtitle. */
  interface ISubtitle {
    /** Subtitle sequence */
    sequence?: Long | null;

    /** Subtitle isFinal */
    isFinal?: boolean | null;

    /** Subtitle utterance */
    utterance?: string | null;

    /** Subtitle languageCode */
    languageCode?: string | null;

    /** Subtitle beginTime */
    beginTime?: Long | null;

    /** Subtitle endTime */
    endTime?: Long | null;
  }

  /** Represents a Subtitle. */
  class Subtitle implements ISubtitle {
    /**
     * Constructs a new Subtitle.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ISubtitle);

    /** Subtitle sequence. */
    public sequence: Long;

    /** Subtitle isFinal. */
    public isFinal: boolean;

    /** Subtitle utterance. */
    public utterance: string;

    /** Subtitle languageCode. */
    public languageCode: string;

    /** Subtitle beginTime. */
    public beginTime: Long;

    /** Subtitle endTime. */
    public endTime: Long;

    /**
     * Creates a new Subtitle instance using the specified properties.
     * @param [properties] Properties to set
     * @returns Subtitle instance
     */
    public static create(properties?: si.ISubtitle): si.Subtitle;

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

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

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

    /**
     * Decodes a Subtitle message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns Subtitle
     * @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
    ): si.Subtitle;

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

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

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

  /** Properties of an AvPacketIRL. */
  interface IAvPacketIRL {
    /** AvPacketIRL sequence */
    sequence?: Long | null;

    /** AvPacketIRL bytes */
    bytes?: Uint8Array | null;

    /** AvPacketIRL pts */
    pts?: Long | null;

    /** AvPacketIRL duration */
    duration?: Long | null;

    /** AvPacketIRL unixMs */
    unixMs?: Long | null;
  }

  /** Represents an AvPacketIRL. */
  class AvPacketIRL implements IAvPacketIRL {
    /**
     * Constructs a new AvPacketIRL.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.IAvPacketIRL);

    /** AvPacketIRL sequence. */
    public sequence: Long;

    /** AvPacketIRL bytes. */
    public bytes: Uint8Array;

    /** AvPacketIRL pts. */
    public pts: Long;

    /** AvPacketIRL duration. */
    public duration: Long;

    /** AvPacketIRL unixMs. */
    public unixMs: Long;

    /**
     * Creates a new AvPacketIRL instance using the specified properties.
     * @param [properties] Properties to set
     * @returns AvPacketIRL instance
     */
    public static create(properties?: si.IAvPacketIRL): si.AvPacketIRL;

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

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

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

    /**
     * Decodes an AvPacketIRL message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns AvPacketIRL
     * @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
    ): si.AvPacketIRL;

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

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

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

  /** Properties of an AvMetaIRL. */
  interface IAvMetaIRL {
    /** AvMetaIRL format */
    format?: si.AvMetaIRL.AvFormat | null;

    /** AvMetaIRL rate */
    rate?: number | null;

    /** AvMetaIRL numChannels */
    numChannels?: number | null;
  }

  /** Represents an AvMetaIRL. */
  class AvMetaIRL implements IAvMetaIRL {
    /**
     * Constructs a new AvMetaIRL.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.IAvMetaIRL);

    /** AvMetaIRL format. */
    public format: si.AvMetaIRL.AvFormat;

    /** AvMetaIRL rate. */
    public rate: number;

    /** AvMetaIRL numChannels. */
    public numChannels: number;

    /**
     * Creates a new AvMetaIRL instance using the specified properties.
     * @param [properties] Properties to set
     * @returns AvMetaIRL instance
     */
    public static create(properties?: si.IAvMetaIRL): si.AvMetaIRL;

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

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

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

    /**
     * Decodes an AvMetaIRL message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns AvMetaIRL
     * @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
    ): si.AvMetaIRL;

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

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

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

  namespace AvMetaIRL {
    /** AvFormat enum. */
    enum AvFormat {
      UNSPECIFIED = 0,
      AUDIO_LINEAR16 = 1,
      AUDIO_MP3 = 2,
      AUDIO_AAC_ADTS = 3,
      AUDIO_MOV_MP4_M4A_3GP_3G2_MJ2 = 4,
    }
  }

  /** Properties of a Timestamp. */
  interface ITimestamp {
    /** Timestamp begin */
    begin?: Long | null;

    /** Timestamp end */
    end?: Long | null;
  }

  /** Represents a Timestamp. */
  class Timestamp implements ITimestamp {
    /**
     * Constructs a new Timestamp.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ITimestamp);

    /** Timestamp begin. */
    public begin: Long;

    /** Timestamp end. */
    public end: Long;

    /**
     * Creates a new Timestamp instance using the specified properties.
     * @param [properties] Properties to set
     * @returns Timestamp instance
     */
    public static create(properties?: si.ITimestamp): si.Timestamp;

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

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

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

    /**
     * Decodes a Timestamp message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns Timestamp
     * @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
    ): si.Timestamp;

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

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

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

  /** Properties of an AudioTs. */
  interface IAudioTs {
    /** AudioTs begin */
    begin?: Long | null;

    /** AudioTs end */
    end?: Long | null;

    /** AudioTs passThrough */
    passThrough?: si.ITimestamp[] | null;
  }

  /** Represents an AudioTs. */
  class AudioTs implements IAudioTs {
    /**
     * Constructs a new AudioTs.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.IAudioTs);

    /** AudioTs begin. */
    public begin: Long;

    /** AudioTs end. */
    public end: Long;

    /** AudioTs passThrough. */
    public passThrough: si.ITimestamp[];

    /**
     * Creates a new AudioTs instance using the specified properties.
     * @param [properties] Properties to set
     * @returns AudioTs instance
     */
    public static create(properties?: si.IAudioTs): si.AudioTs;

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

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

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

    /**
     * Decodes an AudioTs message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns AudioTs
     * @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
    ): si.AudioTs;

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

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

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

  /** Properties of a SubtitleTimestamp. */
  interface ISubtitleTimestamp {
    /** SubtitleTimestamp ats */
    ats?: si.ITimestamp | null;

    /** SubtitleTimestamp pts */
    pts?: si.ITimestamp | null;

    /** SubtitleTimestamp unix */
    unix?: si.ITimestamp | null;
  }

  /** Represents a SubtitleTimestamp. */
  class SubtitleTimestamp implements ISubtitleTimestamp {
    /**
     * Constructs a new SubtitleTimestamp.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ISubtitleTimestamp);

    /** SubtitleTimestamp ats. */
    public ats?: si.ITimestamp | null;

    /** SubtitleTimestamp pts. */
    public pts?: si.ITimestamp | null;

    /** SubtitleTimestamp unix. */
    public unix?: si.ITimestamp | null;

    /**
     * Creates a new SubtitleTimestamp instance using the specified properties.
     * @param [properties] Properties to set
     * @returns SubtitleTimestamp instance
     */
    public static create(
      properties?: si.ISubtitleTimestamp
    ): si.SubtitleTimestamp;

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

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

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

    /**
     * Decodes a SubtitleTimestamp message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns SubtitleTimestamp
     * @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
    ): si.SubtitleTimestamp;

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

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

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

  /** Properties of a SentenceInfo. */
  interface ISentenceInfo {
    /** SentenceInfo utterance */
    utterance?: string | null;

    /** SentenceInfo timestamps */
    timestamps?: si.ISubtitleTimestamp | null;

    /** SentenceInfo wordInfo */
    wordInfo?: si.IWordInfo[] | null;
  }

  /** Represents a SentenceInfo. */
  class SentenceInfo implements ISentenceInfo {
    /**
     * Constructs a new SentenceInfo.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ISentenceInfo);

    /** SentenceInfo utterance. */
    public utterance: string;

    /** SentenceInfo timestamps. */
    public timestamps?: si.ISubtitleTimestamp | null;

    /** SentenceInfo wordInfo. */
    public wordInfo: si.IWordInfo[];

    /**
     * Creates a new SentenceInfo instance using the specified properties.
     * @param [properties] Properties to set
     * @returns SentenceInfo instance
     */
    public static create(properties?: si.ISentenceInfo): si.SentenceInfo;

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

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

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

    /**
     * Decodes a SentenceInfo message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns SentenceInfo
     * @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
    ): si.SentenceInfo;

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

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

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

  /** Properties of a WordInfo. */
  interface IWordInfo {
    /** WordInfo token */
    token?: string | null;

    /** WordInfo vadEvent */
    vadEvent?: boolean | null;

    /** WordInfo ats */
    ats?: si.ITimestamp | null;
  }

  /** Represents a WordInfo. */
  class WordInfo implements IWordInfo {
    /**
     * Constructs a new WordInfo.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.IWordInfo);

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

    /** WordInfo vadEvent. */
    public vadEvent: boolean;

    /** WordInfo ats. */
    public ats?: si.ITimestamp | null;

    /**
     * Creates a new WordInfo instance using the specified properties.
     * @param [properties] Properties to set
     * @returns WordInfo instance
     */
    public static create(properties?: si.IWordInfo): si.WordInfo;

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

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

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

    /**
     * Decodes a WordInfo message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns WordInfo
     * @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
    ): si.WordInfo;

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

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

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

  /** Properties of a SubtitleIRL. */
  interface ISubtitleIRL {
    /** SubtitleIRL class */
    class?: si.SubtitleIRL.SubtitleType | null;

    /** SubtitleIRL languageCode */
    languageCode?: string | null;

    /** SubtitleIRL definite */
    definite?: boolean | null;

    /** SubtitleIRL seqId */
    seqId?: Long | null;

    /** SubtitleIRL transformations */
    transformations?: si.ISentenceInfo[] | null;

    /** SubtitleIRL createTime */
    createTime?: Long | null;

    /** SubtitleIRL session */
    session?: string | null;

    /** SubtitleIRL signature */
    signature?: string | null;
  }

  /** Represents a SubtitleIRL. */
  class SubtitleIRL implements ISubtitleIRL {
    /**
     * Constructs a new SubtitleIRL.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ISubtitleIRL);

    /** SubtitleIRL class. */
    public class: si.SubtitleIRL.SubtitleType;

    /** SubtitleIRL languageCode. */
    public languageCode: string;

    /** SubtitleIRL definite. */
    public definite: boolean;

    /** SubtitleIRL seqId. */
    public seqId: Long;

    /** SubtitleIRL transformations. */
    public transformations: si.ISentenceInfo[];

    /** SubtitleIRL createTime. */
    public createTime: Long;

    /** SubtitleIRL session. */
    public session: string;

    /** SubtitleIRL signature. */
    public signature: string;

    /**
     * Creates a new SubtitleIRL instance using the specified properties.
     * @param [properties] Properties to set
     * @returns SubtitleIRL instance
     */
    public static create(properties?: si.ISubtitleIRL): si.SubtitleIRL;

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

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

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

    /**
     * Decodes a SubtitleIRL message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns SubtitleIRL
     * @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
    ): si.SubtitleIRL;

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

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

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

  namespace SubtitleIRL {
    /** SubtitleType enum. */
    enum SubtitleType {
      UNSPECIFIED = 0,
      TRANSCRIPT = 1,
      SEGMENT = 2,
      TRANSLATION = 3,
    }
  }

  /** Properties of a SubtitleIRLArray. */
  interface ISubtitleIRLArray {
    /** SubtitleIRLArray subtitleIRLArray */
    subtitleIRLArray?: si.ISubtitleIRL[] | null;
  }

  /** Represents a SubtitleIRLArray. */
  class SubtitleIRLArray implements ISubtitleIRLArray {
    /**
     * Constructs a new SubtitleIRLArray.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ISubtitleIRLArray);

    /** SubtitleIRLArray subtitleIRLArray. */
    public subtitleIRLArray: si.ISubtitleIRL[];

    /**
     * Creates a new SubtitleIRLArray instance using the specified properties.
     * @param [properties] Properties to set
     * @returns SubtitleIRLArray instance
     */
    public static create(
      properties?: si.ISubtitleIRLArray
    ): si.SubtitleIRLArray;

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

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

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

    /**
     * Decodes a SubtitleIRLArray message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns SubtitleIRLArray
     * @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
    ): si.SubtitleIRLArray;

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

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

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

  /** Properties of a SubtitleIRLExtra. */
  interface ISubtitleIRLExtra {
    /** SubtitleIRLExtra subtitle */
    subtitle?: si.ISubtitleIRL | null;

    /** SubtitleIRLExtra sentenceBeginOffset */
    sentenceBeginOffset?: boolean | null;

    /** SubtitleIRLExtra sentenceEndOffset */
    sentenceEndOffset?: boolean | null;

    /** SubtitleIRLExtra mockTimestamps */
    mockTimestamps?: si.ITimestamp | null;

    /** SubtitleIRLExtra delayMs */
    delayMs?: Long | null;

    /** SubtitleIRLExtra speechProvider */
    speechProvider?: string | null;
  }

  /** Represents a SubtitleIRLExtra. */
  class SubtitleIRLExtra implements ISubtitleIRLExtra {
    /**
     * Constructs a new SubtitleIRLExtra.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.ISubtitleIRLExtra);

    /** SubtitleIRLExtra subtitle. */
    public subtitle?: si.ISubtitleIRL | null;

    /** SubtitleIRLExtra sentenceBeginOffset. */
    public sentenceBeginOffset: boolean;

    /** SubtitleIRLExtra sentenceEndOffset. */
    public sentenceEndOffset: boolean;

    /** SubtitleIRLExtra mockTimestamps. */
    public mockTimestamps?: si.ITimestamp | null;

    /** SubtitleIRLExtra delayMs. */
    public delayMs: Long;

    /** SubtitleIRLExtra speechProvider. */
    public speechProvider: string;

    /**
     * Creates a new SubtitleIRLExtra instance using the specified properties.
     * @param [properties] Properties to set
     * @returns SubtitleIRLExtra instance
     */
    public static create(
      properties?: si.ISubtitleIRLExtra
    ): si.SubtitleIRLExtra;

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

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

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

    /**
     * Decodes a SubtitleIRLExtra message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns SubtitleIRLExtra
     * @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
    ): si.SubtitleIRLExtra;

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

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

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

  /** Properties of an AllSubtitleIRLExtra. */
  interface IAllSubtitleIRLExtra {
    /** AllSubtitleIRLExtra subtitles */
    subtitles?: si.ISubtitleIRLExtra[] | null;
  }

  /** Represents an AllSubtitleIRLExtra. */
  class AllSubtitleIRLExtra implements IAllSubtitleIRLExtra {
    /**
     * Constructs a new AllSubtitleIRLExtra.
     * @param [properties] Properties to set
     */
    constructor(properties?: si.IAllSubtitleIRLExtra);

    /** AllSubtitleIRLExtra subtitles. */
    public subtitles: si.ISubtitleIRLExtra[];

    /**
     * Creates a new AllSubtitleIRLExtra instance using the specified properties.
     * @param [properties] Properties to set
     * @returns AllSubtitleIRLExtra instance
     */
    public static create(
      properties?: si.IAllSubtitleIRLExtra
    ): si.AllSubtitleIRLExtra;

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

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

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

    /**
     * Decodes an AllSubtitleIRLExtra message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns AllSubtitleIRLExtra
     * @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
    ): si.AllSubtitleIRLExtra;

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

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

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

/** Namespace pbbp2. */
export namespace pbbp2 {
  /** Properties of a Header. */
  interface IHeader {
    /** Header key */
    key: string;

    /** Header value */
    value: string;
  }

  /** Represents a Header. */
  class Header implements IHeader {
    /**
     * Constructs a new Header.
     * @param [properties] Properties to set
     */
    constructor(properties?: pbbp2.IHeader);

    /** Header key. */
    public key: string;

    /** Header value. */
    public value: string;

    /**
     * Creates a new Header instance using the specified properties.
     * @param [properties] Properties to set
     * @returns Header instance
     */
    public static create(properties?: pbbp2.IHeader): pbbp2.Header;

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

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

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

    /**
     * Decodes a Header message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns Header
     * @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
    ): pbbp2.Header;

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

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

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

  /** Properties of a Frame. */
  interface IFrame {
    /** Frame SeqID */
    SeqID: Long;

    /** Frame LogID */
    LogID: Long;

    /** Frame service */
    service: number;

    /** Frame method */
    method: number;

    /** Frame headers */
    headers?: pbbp2.IHeader[] | null;

    /** Frame payloadEncoding */
    payloadEncoding?: string | null;

    /** Frame payloadType */
    payloadType?: string | null;

    /** Frame payload */
    payload?: Uint8Array | null;
  }

  /** Represents a Frame. */
  class Frame implements IFrame {
    /**
     * Constructs a new Frame.
     * @param [properties] Properties to set
     */
    constructor(properties?: pbbp2.IFrame);

    /** Frame SeqID. */
    public SeqID: Long;

    /** Frame LogID. */
    public LogID: Long;

    /** Frame service. */
    public service: number;

    /** Frame method. */
    public method: number;

    /** Frame headers. */
    public headers: pbbp2.IHeader[];

    /** Frame payloadEncoding. */
    public payloadEncoding: string;

    /** Frame payloadType. */
    public payloadType: string;

    /** Frame payload. */
    public payload: Uint8Array;

    /**
     * Creates a new Frame instance using the specified properties.
     * @param [properties] Properties to set
     * @returns Frame instance
     */
    public static create(properties?: pbbp2.IFrame): pbbp2.Frame;

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

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

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

    /**
     * Decodes a Frame message from the specified reader or buffer, length delimited.
     * @param reader Reader or buffer to decode from
     * @returns Frame
     * @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
    ): pbbp2.Frame;

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

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

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