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

    /** Properties of a ADVDeviceIdentity. */
    interface IADVDeviceIdentity {

        /** ADVDeviceIdentity rawId */
        rawId?: (number|null);

        /** ADVDeviceIdentity timestamp */
        timestamp?: (number|Long|null);

        /** ADVDeviceIdentity keyIndex */
        keyIndex?: (number|null);

        /** ADVDeviceIdentity accountType */
        accountType?: (proto.ADVEncryptionType|null);

        /** ADVDeviceIdentity deviceType */
        deviceType?: (proto.ADVEncryptionType|null);
    }

    /** Represents a ADVDeviceIdentity. */
    class ADVDeviceIdentity implements IADVDeviceIdentity {

        /**
         * Constructs a new ADVDeviceIdentity.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IADVDeviceIdentity);

        /** ADVDeviceIdentity rawId. */
        public rawId: number;

        /** ADVDeviceIdentity timestamp. */
        public timestamp: (number|Long);

        /** ADVDeviceIdentity keyIndex. */
        public keyIndex: number;

        /** ADVDeviceIdentity accountType. */
        public accountType: proto.ADVEncryptionType;

        /** ADVDeviceIdentity deviceType. */
        public deviceType: proto.ADVEncryptionType;

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

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

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

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

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

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

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

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

    /** ADVEncryptionType enum. */
    enum ADVEncryptionType {
        E2EE = 0,
        HOSTED = 1
    }

    /** Properties of a ADVKeyIndexList. */
    interface IADVKeyIndexList {

        /** ADVKeyIndexList rawId */
        rawId?: (number|null);

        /** ADVKeyIndexList timestamp */
        timestamp?: (number|Long|null);

        /** ADVKeyIndexList currentIndex */
        currentIndex?: (number|null);

        /** ADVKeyIndexList validIndexes */
        validIndexes?: (number[]|null);

        /** ADVKeyIndexList accountType */
        accountType?: (proto.ADVEncryptionType|null);
    }

    /** Represents a ADVKeyIndexList. */
    class ADVKeyIndexList implements IADVKeyIndexList {

        /**
         * Constructs a new ADVKeyIndexList.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IADVKeyIndexList);

        /** ADVKeyIndexList rawId. */
        public rawId: number;

        /** ADVKeyIndexList timestamp. */
        public timestamp: (number|Long);

        /** ADVKeyIndexList currentIndex. */
        public currentIndex: number;

        /** ADVKeyIndexList validIndexes. */
        public validIndexes: number[];

        /** ADVKeyIndexList accountType. */
        public accountType: proto.ADVEncryptionType;

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

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

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

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

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

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

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

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

    /** Properties of a ADVSignedDeviceIdentity. */
    interface IADVSignedDeviceIdentity {

        /** ADVSignedDeviceIdentity details */
        details?: (Uint8Array|null);

        /** ADVSignedDeviceIdentity accountSignatureKey */
        accountSignatureKey?: (Uint8Array|null);

        /** ADVSignedDeviceIdentity accountSignature */
        accountSignature?: (Uint8Array|null);

        /** ADVSignedDeviceIdentity deviceSignature */
        deviceSignature?: (Uint8Array|null);
    }

    /** Represents a ADVSignedDeviceIdentity. */
    class ADVSignedDeviceIdentity implements IADVSignedDeviceIdentity {

        /**
         * Constructs a new ADVSignedDeviceIdentity.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IADVSignedDeviceIdentity);

        /** ADVSignedDeviceIdentity details. */
        public details: Uint8Array;

        /** ADVSignedDeviceIdentity accountSignatureKey. */
        public accountSignatureKey: Uint8Array;

        /** ADVSignedDeviceIdentity accountSignature. */
        public accountSignature: Uint8Array;

        /** ADVSignedDeviceIdentity deviceSignature. */
        public deviceSignature: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of a ADVSignedDeviceIdentityHMAC. */
    interface IADVSignedDeviceIdentityHMAC {

        /** ADVSignedDeviceIdentityHMAC details */
        details?: (Uint8Array|null);

        /** ADVSignedDeviceIdentityHMAC hmac */
        hmac?: (Uint8Array|null);

        /** ADVSignedDeviceIdentityHMAC accountType */
        accountType?: (proto.ADVEncryptionType|null);
    }

    /** Represents a ADVSignedDeviceIdentityHMAC. */
    class ADVSignedDeviceIdentityHMAC implements IADVSignedDeviceIdentityHMAC {

        /**
         * Constructs a new ADVSignedDeviceIdentityHMAC.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IADVSignedDeviceIdentityHMAC);

        /** ADVSignedDeviceIdentityHMAC details. */
        public details: Uint8Array;

        /** ADVSignedDeviceIdentityHMAC hmac. */
        public hmac: Uint8Array;

        /** ADVSignedDeviceIdentityHMAC accountType. */
        public accountType: proto.ADVEncryptionType;

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

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

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

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

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

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

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

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

    /** Properties of a ADVSignedKeyIndexList. */
    interface IADVSignedKeyIndexList {

        /** ADVSignedKeyIndexList details */
        details?: (Uint8Array|null);

        /** ADVSignedKeyIndexList accountSignature */
        accountSignature?: (Uint8Array|null);

        /** ADVSignedKeyIndexList accountSignatureKey */
        accountSignatureKey?: (Uint8Array|null);
    }

    /** Represents a ADVSignedKeyIndexList. */
    class ADVSignedKeyIndexList implements IADVSignedKeyIndexList {

        /**
         * Constructs a new ADVSignedKeyIndexList.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IADVSignedKeyIndexList);

        /** ADVSignedKeyIndexList details. */
        public details: Uint8Array;

        /** ADVSignedKeyIndexList accountSignature. */
        public accountSignature: Uint8Array;

        /** ADVSignedKeyIndexList accountSignatureKey. */
        public accountSignatureKey: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of an ActionLink. */
    interface IActionLink {

        /** ActionLink url */
        url?: (string|null);

        /** ActionLink buttonTitle */
        buttonTitle?: (string|null);
    }

    /** Represents an ActionLink. */
    class ActionLink implements IActionLink {

        /**
         * Constructs a new ActionLink.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IActionLink);

        /** ActionLink url. */
        public url: string;

        /** ActionLink buttonTitle. */
        public buttonTitle: string;

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

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

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

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

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

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

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

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

    /** Properties of an AutoDownloadSettings. */
    interface IAutoDownloadSettings {

        /** AutoDownloadSettings downloadImages */
        downloadImages?: (boolean|null);

        /** AutoDownloadSettings downloadAudio */
        downloadAudio?: (boolean|null);

        /** AutoDownloadSettings downloadVideo */
        downloadVideo?: (boolean|null);

        /** AutoDownloadSettings downloadDocuments */
        downloadDocuments?: (boolean|null);
    }

    /** Represents an AutoDownloadSettings. */
    class AutoDownloadSettings implements IAutoDownloadSettings {

        /**
         * Constructs a new AutoDownloadSettings.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IAutoDownloadSettings);

        /** AutoDownloadSettings downloadImages. */
        public downloadImages: boolean;

        /** AutoDownloadSettings downloadAudio. */
        public downloadAudio: boolean;

        /** AutoDownloadSettings downloadVideo. */
        public downloadVideo: boolean;

        /** AutoDownloadSettings downloadDocuments. */
        public downloadDocuments: boolean;

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

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

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

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

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

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

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

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

    /** Properties of an AvatarUserSettings. */
    interface IAvatarUserSettings {

        /** AvatarUserSettings fbid */
        fbid?: (string|null);

        /** AvatarUserSettings password */
        password?: (string|null);
    }

    /** Represents an AvatarUserSettings. */
    class AvatarUserSettings implements IAvatarUserSettings {

        /**
         * Constructs a new AvatarUserSettings.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IAvatarUserSettings);

        /** AvatarUserSettings fbid. */
        public fbid: string;

        /** AvatarUserSettings password. */
        public password: string;

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

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

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

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

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

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

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

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

    /** Properties of a BizAccountLinkInfo. */
    interface IBizAccountLinkInfo {

        /** BizAccountLinkInfo whatsappBizAcctFbid */
        whatsappBizAcctFbid?: (number|Long|null);

        /** BizAccountLinkInfo whatsappAcctNumber */
        whatsappAcctNumber?: (string|null);

        /** BizAccountLinkInfo issueTime */
        issueTime?: (number|Long|null);

        /** BizAccountLinkInfo hostStorage */
        hostStorage?: (proto.BizAccountLinkInfo.HostStorageType|null);

        /** BizAccountLinkInfo accountType */
        accountType?: (proto.BizAccountLinkInfo.AccountType|null);
    }

    /** Represents a BizAccountLinkInfo. */
    class BizAccountLinkInfo implements IBizAccountLinkInfo {

        /**
         * Constructs a new BizAccountLinkInfo.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IBizAccountLinkInfo);

        /** BizAccountLinkInfo whatsappBizAcctFbid. */
        public whatsappBizAcctFbid: (number|Long);

        /** BizAccountLinkInfo whatsappAcctNumber. */
        public whatsappAcctNumber: string;

        /** BizAccountLinkInfo issueTime. */
        public issueTime: (number|Long);

        /** BizAccountLinkInfo hostStorage. */
        public hostStorage: proto.BizAccountLinkInfo.HostStorageType;

        /** BizAccountLinkInfo accountType. */
        public accountType: proto.BizAccountLinkInfo.AccountType;

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

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

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

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

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

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

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

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

    namespace BizAccountLinkInfo {

        /** AccountType enum. */
        enum AccountType {
            ENTERPRISE = 0
        }

        /** HostStorageType enum. */
        enum HostStorageType {
            ON_PREMISE = 0,
            FACEBOOK = 1
        }
    }

    /** Properties of a BizAccountPayload. */
    interface IBizAccountPayload {

        /** BizAccountPayload vnameCert */
        vnameCert?: (proto.IVerifiedNameCertificate|null);

        /** BizAccountPayload bizAcctLinkInfo */
        bizAcctLinkInfo?: (Uint8Array|null);
    }

    /** Represents a BizAccountPayload. */
    class BizAccountPayload implements IBizAccountPayload {

        /**
         * Constructs a new BizAccountPayload.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IBizAccountPayload);

        /** BizAccountPayload vnameCert. */
        public vnameCert?: (proto.IVerifiedNameCertificate|null);

        /** BizAccountPayload bizAcctLinkInfo. */
        public bizAcctLinkInfo: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of a BizIdentityInfo. */
    interface IBizIdentityInfo {

        /** BizIdentityInfo vlevel */
        vlevel?: (proto.BizIdentityInfo.VerifiedLevelValue|null);

        /** BizIdentityInfo vnameCert */
        vnameCert?: (proto.IVerifiedNameCertificate|null);

        /** BizIdentityInfo signed */
        signed?: (boolean|null);

        /** BizIdentityInfo revoked */
        revoked?: (boolean|null);

        /** BizIdentityInfo hostStorage */
        hostStorage?: (proto.BizIdentityInfo.HostStorageType|null);

        /** BizIdentityInfo actualActors */
        actualActors?: (proto.BizIdentityInfo.ActualActorsType|null);

        /** BizIdentityInfo privacyModeTs */
        privacyModeTs?: (number|Long|null);

        /** BizIdentityInfo featureControls */
        featureControls?: (number|Long|null);
    }

    /** Represents a BizIdentityInfo. */
    class BizIdentityInfo implements IBizIdentityInfo {

        /**
         * Constructs a new BizIdentityInfo.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IBizIdentityInfo);

        /** BizIdentityInfo vlevel. */
        public vlevel: proto.BizIdentityInfo.VerifiedLevelValue;

        /** BizIdentityInfo vnameCert. */
        public vnameCert?: (proto.IVerifiedNameCertificate|null);

        /** BizIdentityInfo signed. */
        public signed: boolean;

        /** BizIdentityInfo revoked. */
        public revoked: boolean;

        /** BizIdentityInfo hostStorage. */
        public hostStorage: proto.BizIdentityInfo.HostStorageType;

        /** BizIdentityInfo actualActors. */
        public actualActors: proto.BizIdentityInfo.ActualActorsType;

        /** BizIdentityInfo privacyModeTs. */
        public privacyModeTs: (number|Long);

        /** BizIdentityInfo featureControls. */
        public featureControls: (number|Long);

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

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

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

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

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

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

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

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

    namespace BizIdentityInfo {

        /** ActualActorsType enum. */
        enum ActualActorsType {
            SELF = 0,
            BSP = 1
        }

        /** HostStorageType enum. */
        enum HostStorageType {
            ON_PREMISE = 0,
            FACEBOOK = 1
        }

        /** VerifiedLevelValue enum. */
        enum VerifiedLevelValue {
            UNKNOWN = 0,
            LOW = 1,
            HIGH = 2
        }
    }

    /** Properties of a BotAvatarMetadata. */
    interface IBotAvatarMetadata {

        /** BotAvatarMetadata sentiment */
        sentiment?: (number|null);

        /** BotAvatarMetadata behaviorGraph */
        behaviorGraph?: (string|null);

        /** BotAvatarMetadata action */
        action?: (number|null);

        /** BotAvatarMetadata intensity */
        intensity?: (number|null);

        /** BotAvatarMetadata wordCount */
        wordCount?: (number|null);
    }

    /** Represents a BotAvatarMetadata. */
    class BotAvatarMetadata implements IBotAvatarMetadata {

        /**
         * Constructs a new BotAvatarMetadata.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IBotAvatarMetadata);

        /** BotAvatarMetadata sentiment. */
        public sentiment: number;

        /** BotAvatarMetadata behaviorGraph. */
        public behaviorGraph: string;

        /** BotAvatarMetadata action. */
        public action: number;

        /** BotAvatarMetadata intensity. */
        public intensity: number;

        /** BotAvatarMetadata wordCount. */
        public wordCount: number;

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

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

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

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

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

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

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

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

    /** Properties of a BotMetadata. */
    interface IBotMetadata {

        /** BotMetadata avatarMetadata */
        avatarMetadata?: (proto.IBotAvatarMetadata|null);

        /** BotMetadata personaId */
        personaId?: (string|null);

        /** BotMetadata pluginMetadata */
        pluginMetadata?: (proto.IBotPluginMetadata|null);

        /** BotMetadata suggestedPromptMetadata */
        suggestedPromptMetadata?: (proto.IBotSuggestedPromptMetadata|null);

        /** BotMetadata invokerJid */
        invokerJid?: (string|null);
    }

    /** Represents a BotMetadata. */
    class BotMetadata implements IBotMetadata {

        /**
         * Constructs a new BotMetadata.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IBotMetadata);

        /** BotMetadata avatarMetadata. */
        public avatarMetadata?: (proto.IBotAvatarMetadata|null);

        /** BotMetadata personaId. */
        public personaId: string;

        /** BotMetadata pluginMetadata. */
        public pluginMetadata?: (proto.IBotPluginMetadata|null);

        /** BotMetadata suggestedPromptMetadata. */
        public suggestedPromptMetadata?: (proto.IBotSuggestedPromptMetadata|null);

        /** BotMetadata invokerJid. */
        public invokerJid: string;

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

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

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

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

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

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

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

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

    /** Properties of a BotPluginMetadata. */
    interface IBotPluginMetadata {

        /** BotPluginMetadata provider */
        provider?: (proto.BotPluginMetadata.SearchProvider|null);

        /** BotPluginMetadata pluginType */
        pluginType?: (proto.BotPluginMetadata.PluginType|null);

        /** BotPluginMetadata thumbnailCdnUrl */
        thumbnailCdnUrl?: (string|null);

        /** BotPluginMetadata profilePhotoCdnUrl */
        profilePhotoCdnUrl?: (string|null);

        /** BotPluginMetadata searchProviderUrl */
        searchProviderUrl?: (string|null);

        /** BotPluginMetadata referenceIndex */
        referenceIndex?: (number|null);

        /** BotPluginMetadata expectedLinksCount */
        expectedLinksCount?: (number|null);

        /** BotPluginMetadata pluginVersion */
        pluginVersion?: (number|null);
    }

    /** Represents a BotPluginMetadata. */
    class BotPluginMetadata implements IBotPluginMetadata {

        /**
         * Constructs a new BotPluginMetadata.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IBotPluginMetadata);

        /** BotPluginMetadata provider. */
        public provider: proto.BotPluginMetadata.SearchProvider;

        /** BotPluginMetadata pluginType. */
        public pluginType: proto.BotPluginMetadata.PluginType;

        /** BotPluginMetadata thumbnailCdnUrl. */
        public thumbnailCdnUrl: string;

        /** BotPluginMetadata profilePhotoCdnUrl. */
        public profilePhotoCdnUrl: string;

        /** BotPluginMetadata searchProviderUrl. */
        public searchProviderUrl: string;

        /** BotPluginMetadata referenceIndex. */
        public referenceIndex: number;

        /** BotPluginMetadata expectedLinksCount. */
        public expectedLinksCount: number;

        /** BotPluginMetadata pluginVersion. */
        public pluginVersion: number;

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

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

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

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

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

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

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

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

    namespace BotPluginMetadata {

        /** PluginType enum. */
        enum PluginType {
            REELS = 1,
            SEARCH = 2
        }

        /** SearchProvider enum. */
        enum SearchProvider {
            BING = 1,
            GOOGLE = 2
        }
    }

    /** Properties of a BotSuggestedPromptMetadata. */
    interface IBotSuggestedPromptMetadata {

        /** BotSuggestedPromptMetadata suggestedPrompts */
        suggestedPrompts?: (string[]|null);

        /** BotSuggestedPromptMetadata selectedPromptIndex */
        selectedPromptIndex?: (number|null);
    }

    /** Represents a BotSuggestedPromptMetadata. */
    class BotSuggestedPromptMetadata implements IBotSuggestedPromptMetadata {

        /**
         * Constructs a new BotSuggestedPromptMetadata.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IBotSuggestedPromptMetadata);

        /** BotSuggestedPromptMetadata suggestedPrompts. */
        public suggestedPrompts: string[];

        /** BotSuggestedPromptMetadata selectedPromptIndex. */
        public selectedPromptIndex: number;

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

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

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

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

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

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

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

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

    /** Properties of a CallLogRecord. */
    interface ICallLogRecord {

        /** CallLogRecord callResult */
        callResult?: (proto.CallLogRecord.CallResult|null);

        /** CallLogRecord isDndMode */
        isDndMode?: (boolean|null);

        /** CallLogRecord silenceReason */
        silenceReason?: (proto.CallLogRecord.SilenceReason|null);

        /** CallLogRecord duration */
        duration?: (number|Long|null);

        /** CallLogRecord startTime */
        startTime?: (number|Long|null);

        /** CallLogRecord isIncoming */
        isIncoming?: (boolean|null);

        /** CallLogRecord isVideo */
        isVideo?: (boolean|null);

        /** CallLogRecord isCallLink */
        isCallLink?: (boolean|null);

        /** CallLogRecord callLinkToken */
        callLinkToken?: (string|null);

        /** CallLogRecord scheduledCallId */
        scheduledCallId?: (string|null);

        /** CallLogRecord callId */
        callId?: (string|null);

        /** CallLogRecord callCreatorJid */
        callCreatorJid?: (string|null);

        /** CallLogRecord groupJid */
        groupJid?: (string|null);

        /** CallLogRecord participants */
        participants?: (proto.CallLogRecord.IParticipantInfo[]|null);

        /** CallLogRecord callType */
        callType?: (proto.CallLogRecord.CallType|null);
    }

    /** Represents a CallLogRecord. */
    class CallLogRecord implements ICallLogRecord {

        /**
         * Constructs a new CallLogRecord.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ICallLogRecord);

        /** CallLogRecord callResult. */
        public callResult: proto.CallLogRecord.CallResult;

        /** CallLogRecord isDndMode. */
        public isDndMode: boolean;

        /** CallLogRecord silenceReason. */
        public silenceReason: proto.CallLogRecord.SilenceReason;

        /** CallLogRecord duration. */
        public duration: (number|Long);

        /** CallLogRecord startTime. */
        public startTime: (number|Long);

        /** CallLogRecord isIncoming. */
        public isIncoming: boolean;

        /** CallLogRecord isVideo. */
        public isVideo: boolean;

        /** CallLogRecord isCallLink. */
        public isCallLink: boolean;

        /** CallLogRecord callLinkToken. */
        public callLinkToken: string;

        /** CallLogRecord scheduledCallId. */
        public scheduledCallId: string;

        /** CallLogRecord callId. */
        public callId: string;

        /** CallLogRecord callCreatorJid. */
        public callCreatorJid: string;

        /** CallLogRecord groupJid. */
        public groupJid: string;

        /** CallLogRecord participants. */
        public participants: proto.CallLogRecord.IParticipantInfo[];

        /** CallLogRecord callType. */
        public callType: proto.CallLogRecord.CallType;

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

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

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

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

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

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

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

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

    namespace CallLogRecord {

        /** CallResult enum. */
        enum CallResult {
            CONNECTED = 0,
            REJECTED = 1,
            CANCELLED = 2,
            ACCEPTEDELSEWHERE = 3,
            MISSED = 4,
            INVALID = 5,
            UNAVAILABLE = 6,
            UPCOMING = 7,
            FAILED = 8,
            ABANDONED = 9,
            ONGOING = 10
        }

        /** CallType enum. */
        enum CallType {
            REGULAR = 0,
            SCHEDULED_CALL = 1,
            VOICE_CHAT = 2
        }

        /** Properties of a ParticipantInfo. */
        interface IParticipantInfo {

            /** ParticipantInfo userJid */
            userJid?: (string|null);

            /** ParticipantInfo callResult */
            callResult?: (proto.CallLogRecord.CallResult|null);
        }

        /** Represents a ParticipantInfo. */
        class ParticipantInfo implements IParticipantInfo {

            /**
             * Constructs a new ParticipantInfo.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.CallLogRecord.IParticipantInfo);

            /** ParticipantInfo userJid. */
            public userJid: string;

            /** ParticipantInfo callResult. */
            public callResult: proto.CallLogRecord.CallResult;

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

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

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

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

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

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

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

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

        /** SilenceReason enum. */
        enum SilenceReason {
            NONE = 0,
            SCHEDULED = 1,
            PRIVACY = 2,
            LIGHTWEIGHT = 3
        }
    }

    /** Properties of a CertChain. */
    interface ICertChain {

        /** CertChain leaf */
        leaf?: (proto.CertChain.INoiseCertificate|null);

        /** CertChain intermediate */
        intermediate?: (proto.CertChain.INoiseCertificate|null);
    }

    /** Represents a CertChain. */
    class CertChain implements ICertChain {

        /**
         * Constructs a new CertChain.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ICertChain);

        /** CertChain leaf. */
        public leaf?: (proto.CertChain.INoiseCertificate|null);

        /** CertChain intermediate. */
        public intermediate?: (proto.CertChain.INoiseCertificate|null);

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

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

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

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

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

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

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

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

    namespace CertChain {

        /** Properties of a NoiseCertificate. */
        interface INoiseCertificate {

            /** NoiseCertificate details */
            details?: (Uint8Array|null);

            /** NoiseCertificate signature */
            signature?: (Uint8Array|null);
        }

        /** Represents a NoiseCertificate. */
        class NoiseCertificate implements INoiseCertificate {

            /**
             * Constructs a new NoiseCertificate.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.CertChain.INoiseCertificate);

            /** NoiseCertificate details. */
            public details: Uint8Array;

            /** NoiseCertificate signature. */
            public signature: Uint8Array;

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

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

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

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

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

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

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

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

        namespace NoiseCertificate {

            /** Properties of a Details. */
            interface IDetails {

                /** Details serial */
                serial?: (number|null);

                /** Details issuerSerial */
                issuerSerial?: (number|null);

                /** Details key */
                key?: (Uint8Array|null);

                /** Details notBefore */
                notBefore?: (number|Long|null);

                /** Details notAfter */
                notAfter?: (number|Long|null);
            }

            /** Represents a Details. */
            class Details implements IDetails {

                /**
                 * Constructs a new Details.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.CertChain.NoiseCertificate.IDetails);

                /** Details serial. */
                public serial: number;

                /** Details issuerSerial. */
                public issuerSerial: number;

                /** Details key. */
                public key: Uint8Array;

                /** Details notBefore. */
                public notBefore: (number|Long);

                /** Details notAfter. */
                public notAfter: (number|Long);

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

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

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

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

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

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

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

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

    /** Properties of a ChatRowOpaqueData. */
    interface IChatRowOpaqueData {

        /** ChatRowOpaqueData draftMessage */
        draftMessage?: (proto.ChatRowOpaqueData.IDraftMessage|null);
    }

    /** Represents a ChatRowOpaqueData. */
    class ChatRowOpaqueData implements IChatRowOpaqueData {

        /**
         * Constructs a new ChatRowOpaqueData.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IChatRowOpaqueData);

        /** ChatRowOpaqueData draftMessage. */
        public draftMessage?: (proto.ChatRowOpaqueData.IDraftMessage|null);

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

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

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

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

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

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

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

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

    namespace ChatRowOpaqueData {

        /** Properties of a DraftMessage. */
        interface IDraftMessage {

            /** DraftMessage text */
            text?: (string|null);

            /** DraftMessage omittedUrl */
            omittedUrl?: (string|null);

            /** DraftMessage ctwaContextLinkData */
            ctwaContextLinkData?: (proto.ChatRowOpaqueData.DraftMessage.ICtwaContextLinkData|null);

            /** DraftMessage ctwaContext */
            ctwaContext?: (proto.ChatRowOpaqueData.DraftMessage.ICtwaContextData|null);

            /** DraftMessage timestamp */
            timestamp?: (number|Long|null);
        }

        /** Represents a DraftMessage. */
        class DraftMessage implements IDraftMessage {

            /**
             * Constructs a new DraftMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.ChatRowOpaqueData.IDraftMessage);

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

            /** DraftMessage omittedUrl. */
            public omittedUrl: string;

            /** DraftMessage ctwaContextLinkData. */
            public ctwaContextLinkData?: (proto.ChatRowOpaqueData.DraftMessage.ICtwaContextLinkData|null);

            /** DraftMessage ctwaContext. */
            public ctwaContext?: (proto.ChatRowOpaqueData.DraftMessage.ICtwaContextData|null);

            /** DraftMessage timestamp. */
            public timestamp: (number|Long);

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

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

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

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

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

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

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

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

        namespace DraftMessage {

            /** Properties of a CtwaContextData. */
            interface ICtwaContextData {

                /** CtwaContextData conversionSource */
                conversionSource?: (string|null);

                /** CtwaContextData conversionData */
                conversionData?: (Uint8Array|null);

                /** CtwaContextData sourceUrl */
                sourceUrl?: (string|null);

                /** CtwaContextData sourceId */
                sourceId?: (string|null);

                /** CtwaContextData sourceType */
                sourceType?: (string|null);

                /** CtwaContextData title */
                title?: (string|null);

                /** CtwaContextData description */
                description?: (string|null);

                /** CtwaContextData thumbnail */
                thumbnail?: (string|null);

                /** CtwaContextData thumbnailUrl */
                thumbnailUrl?: (string|null);

                /** CtwaContextData mediaType */
                mediaType?: (proto.ChatRowOpaqueData.DraftMessage.CtwaContextData.ContextInfoExternalAdReplyInfoMediaType|null);

                /** CtwaContextData mediaUrl */
                mediaUrl?: (string|null);

                /** CtwaContextData isSuspiciousLink */
                isSuspiciousLink?: (boolean|null);
            }

            /** Represents a CtwaContextData. */
            class CtwaContextData implements ICtwaContextData {

                /**
                 * Constructs a new CtwaContextData.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.ChatRowOpaqueData.DraftMessage.ICtwaContextData);

                /** CtwaContextData conversionSource. */
                public conversionSource: string;

                /** CtwaContextData conversionData. */
                public conversionData: Uint8Array;

                /** CtwaContextData sourceUrl. */
                public sourceUrl: string;

                /** CtwaContextData sourceId. */
                public sourceId: string;

                /** CtwaContextData sourceType. */
                public sourceType: string;

                /** CtwaContextData title. */
                public title: string;

                /** CtwaContextData description. */
                public description: string;

                /** CtwaContextData thumbnail. */
                public thumbnail: string;

                /** CtwaContextData thumbnailUrl. */
                public thumbnailUrl: string;

                /** CtwaContextData mediaType. */
                public mediaType: proto.ChatRowOpaqueData.DraftMessage.CtwaContextData.ContextInfoExternalAdReplyInfoMediaType;

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

                /** CtwaContextData isSuspiciousLink. */
                public isSuspiciousLink: boolean;

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

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

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

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

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

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

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

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

            namespace CtwaContextData {

                /** ContextInfoExternalAdReplyInfoMediaType enum. */
                enum ContextInfoExternalAdReplyInfoMediaType {
                    NONE = 0,
                    IMAGE = 1,
                    VIDEO = 2
                }
            }

            /** Properties of a CtwaContextLinkData. */
            interface ICtwaContextLinkData {

                /** CtwaContextLinkData context */
                context?: (string|null);

                /** CtwaContextLinkData sourceUrl */
                sourceUrl?: (string|null);

                /** CtwaContextLinkData icebreaker */
                icebreaker?: (string|null);

                /** CtwaContextLinkData phone */
                phone?: (string|null);
            }

            /** Represents a CtwaContextLinkData. */
            class CtwaContextLinkData implements ICtwaContextLinkData {

                /**
                 * Constructs a new CtwaContextLinkData.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.ChatRowOpaqueData.DraftMessage.ICtwaContextLinkData);

                /** CtwaContextLinkData context. */
                public context: string;

                /** CtwaContextLinkData sourceUrl. */
                public sourceUrl: string;

                /** CtwaContextLinkData icebreaker. */
                public icebreaker: string;

                /** CtwaContextLinkData phone. */
                public phone: string;

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

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

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

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

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

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

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

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

    /** Properties of a ClientPayload. */
    interface IClientPayload {

        /** ClientPayload username */
        username?: (number|Long|null);

        /** ClientPayload passive */
        passive?: (boolean|null);

        /** ClientPayload userAgent */
        userAgent?: (proto.ClientPayload.IUserAgent|null);

        /** ClientPayload webInfo */
        webInfo?: (proto.ClientPayload.IWebInfo|null);

        /** ClientPayload pushName */
        pushName?: (string|null);

        /** ClientPayload sessionId */
        sessionId?: (number|null);

        /** ClientPayload shortConnect */
        shortConnect?: (boolean|null);

        /** ClientPayload connectType */
        connectType?: (proto.ClientPayload.ConnectType|null);

        /** ClientPayload connectReason */
        connectReason?: (proto.ClientPayload.ConnectReason|null);

        /** ClientPayload shards */
        shards?: (number[]|null);

        /** ClientPayload dnsSource */
        dnsSource?: (proto.ClientPayload.IDNSSource|null);

        /** ClientPayload connectAttemptCount */
        connectAttemptCount?: (number|null);

        /** ClientPayload device */
        device?: (number|null);

        /** ClientPayload devicePairingData */
        devicePairingData?: (proto.ClientPayload.IDevicePairingRegistrationData|null);

        /** ClientPayload product */
        product?: (proto.ClientPayload.Product|null);

        /** ClientPayload fbCat */
        fbCat?: (Uint8Array|null);

        /** ClientPayload fbUserAgent */
        fbUserAgent?: (Uint8Array|null);

        /** ClientPayload oc */
        oc?: (boolean|null);

        /** ClientPayload lc */
        lc?: (number|null);

        /** ClientPayload iosAppExtension */
        iosAppExtension?: (proto.ClientPayload.IOSAppExtension|null);

        /** ClientPayload fbAppId */
        fbAppId?: (number|Long|null);

        /** ClientPayload fbDeviceId */
        fbDeviceId?: (Uint8Array|null);

        /** ClientPayload pull */
        pull?: (boolean|null);

        /** ClientPayload paddingBytes */
        paddingBytes?: (Uint8Array|null);

        /** ClientPayload yearClass */
        yearClass?: (number|null);

        /** ClientPayload memClass */
        memClass?: (number|null);

        /** ClientPayload interopData */
        interopData?: (proto.ClientPayload.IInteropData|null);
    }

    /** Represents a ClientPayload. */
    class ClientPayload implements IClientPayload {

        /**
         * Constructs a new ClientPayload.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IClientPayload);

        /** ClientPayload username. */
        public username: (number|Long);

        /** ClientPayload passive. */
        public passive: boolean;

        /** ClientPayload userAgent. */
        public userAgent?: (proto.ClientPayload.IUserAgent|null);

        /** ClientPayload webInfo. */
        public webInfo?: (proto.ClientPayload.IWebInfo|null);

        /** ClientPayload pushName. */
        public pushName: string;

        /** ClientPayload sessionId. */
        public sessionId: number;

        /** ClientPayload shortConnect. */
        public shortConnect: boolean;

        /** ClientPayload connectType. */
        public connectType: proto.ClientPayload.ConnectType;

        /** ClientPayload connectReason. */
        public connectReason: proto.ClientPayload.ConnectReason;

        /** ClientPayload shards. */
        public shards: number[];

        /** ClientPayload dnsSource. */
        public dnsSource?: (proto.ClientPayload.IDNSSource|null);

        /** ClientPayload connectAttemptCount. */
        public connectAttemptCount: number;

        /** ClientPayload device. */
        public device: number;

        /** ClientPayload devicePairingData. */
        public devicePairingData?: (proto.ClientPayload.IDevicePairingRegistrationData|null);

        /** ClientPayload product. */
        public product: proto.ClientPayload.Product;

        /** ClientPayload fbCat. */
        public fbCat: Uint8Array;

        /** ClientPayload fbUserAgent. */
        public fbUserAgent: Uint8Array;

        /** ClientPayload oc. */
        public oc: boolean;

        /** ClientPayload lc. */
        public lc: number;

        /** ClientPayload iosAppExtension. */
        public iosAppExtension: proto.ClientPayload.IOSAppExtension;

        /** ClientPayload fbAppId. */
        public fbAppId: (number|Long);

        /** ClientPayload fbDeviceId. */
        public fbDeviceId: Uint8Array;

        /** ClientPayload pull. */
        public pull: boolean;

        /** ClientPayload paddingBytes. */
        public paddingBytes: Uint8Array;

        /** ClientPayload yearClass. */
        public yearClass: number;

        /** ClientPayload memClass. */
        public memClass: number;

        /** ClientPayload interopData. */
        public interopData?: (proto.ClientPayload.IInteropData|null);

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

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

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

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

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

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

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

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

    namespace ClientPayload {

        /** ConnectReason enum. */
        enum ConnectReason {
            PUSH = 0,
            USER_ACTIVATED = 1,
            SCHEDULED = 2,
            ERROR_RECONNECT = 3,
            NETWORK_SWITCH = 4,
            PING_RECONNECT = 5,
            UNKNOWN = 6
        }

        /** ConnectType enum. */
        enum ConnectType {
            CELLULAR_UNKNOWN = 0,
            WIFI_UNKNOWN = 1,
            CELLULAR_EDGE = 100,
            CELLULAR_IDEN = 101,
            CELLULAR_UMTS = 102,
            CELLULAR_EVDO = 103,
            CELLULAR_GPRS = 104,
            CELLULAR_HSDPA = 105,
            CELLULAR_HSUPA = 106,
            CELLULAR_HSPA = 107,
            CELLULAR_CDMA = 108,
            CELLULAR_1XRTT = 109,
            CELLULAR_EHRPD = 110,
            CELLULAR_LTE = 111,
            CELLULAR_HSPAP = 112
        }

        /** Properties of a DNSSource. */
        interface IDNSSource {

            /** DNSSource dnsMethod */
            dnsMethod?: (proto.ClientPayload.DNSSource.DNSResolutionMethod|null);

            /** DNSSource appCached */
            appCached?: (boolean|null);
        }

        /** Represents a DNSSource. */
        class DNSSource implements IDNSSource {

            /**
             * Constructs a new DNSSource.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.ClientPayload.IDNSSource);

            /** DNSSource dnsMethod. */
            public dnsMethod: proto.ClientPayload.DNSSource.DNSResolutionMethod;

            /** DNSSource appCached. */
            public appCached: boolean;

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

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

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

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

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

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

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

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

        namespace DNSSource {

            /** DNSResolutionMethod enum. */
            enum DNSResolutionMethod {
                SYSTEM = 0,
                GOOGLE = 1,
                HARDCODED = 2,
                OVERRIDE = 3,
                FALLBACK = 4
            }
        }

        /** Properties of a DevicePairingRegistrationData. */
        interface IDevicePairingRegistrationData {

            /** DevicePairingRegistrationData eRegid */
            eRegid?: (Uint8Array|null);

            /** DevicePairingRegistrationData eKeytype */
            eKeytype?: (Uint8Array|null);

            /** DevicePairingRegistrationData eIdent */
            eIdent?: (Uint8Array|null);

            /** DevicePairingRegistrationData eSkeyId */
            eSkeyId?: (Uint8Array|null);

            /** DevicePairingRegistrationData eSkeyVal */
            eSkeyVal?: (Uint8Array|null);

            /** DevicePairingRegistrationData eSkeySig */
            eSkeySig?: (Uint8Array|null);

            /** DevicePairingRegistrationData buildHash */
            buildHash?: (Uint8Array|null);

            /** DevicePairingRegistrationData deviceProps */
            deviceProps?: (Uint8Array|null);
        }

        /** Represents a DevicePairingRegistrationData. */
        class DevicePairingRegistrationData implements IDevicePairingRegistrationData {

            /**
             * Constructs a new DevicePairingRegistrationData.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.ClientPayload.IDevicePairingRegistrationData);

            /** DevicePairingRegistrationData eRegid. */
            public eRegid: Uint8Array;

            /** DevicePairingRegistrationData eKeytype. */
            public eKeytype: Uint8Array;

            /** DevicePairingRegistrationData eIdent. */
            public eIdent: Uint8Array;

            /** DevicePairingRegistrationData eSkeyId. */
            public eSkeyId: Uint8Array;

            /** DevicePairingRegistrationData eSkeyVal. */
            public eSkeyVal: Uint8Array;

            /** DevicePairingRegistrationData eSkeySig. */
            public eSkeySig: Uint8Array;

            /** DevicePairingRegistrationData buildHash. */
            public buildHash: Uint8Array;

            /** DevicePairingRegistrationData deviceProps. */
            public deviceProps: Uint8Array;

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

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

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

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

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

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

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

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

        /** IOSAppExtension enum. */
        enum IOSAppExtension {
            SHARE_EXTENSION = 0,
            SERVICE_EXTENSION = 1,
            INTENTS_EXTENSION = 2
        }

        /** Properties of an InteropData. */
        interface IInteropData {

            /** InteropData accountId */
            accountId?: (number|Long|null);

            /** InteropData token */
            token?: (Uint8Array|null);
        }

        /** Represents an InteropData. */
        class InteropData implements IInteropData {

            /**
             * Constructs a new InteropData.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.ClientPayload.IInteropData);

            /** InteropData accountId. */
            public accountId: (number|Long);

            /** InteropData token. */
            public token: Uint8Array;

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

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

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

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

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

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

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

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

        /** Product enum. */
        enum Product {
            WHATSAPP = 0,
            MESSENGER = 1,
            INTEROP = 2,
            INTEROP_MSGR = 3
        }

        /** Properties of a UserAgent. */
        interface IUserAgent {

            /** UserAgent platform */
            platform?: (proto.ClientPayload.UserAgent.Platform|null);

            /** UserAgent appVersion */
            appVersion?: (proto.ClientPayload.UserAgent.IAppVersion|null);

            /** UserAgent mcc */
            mcc?: (string|null);

            /** UserAgent mnc */
            mnc?: (string|null);

            /** UserAgent osVersion */
            osVersion?: (string|null);

            /** UserAgent manufacturer */
            manufacturer?: (string|null);

            /** UserAgent device */
            device?: (string|null);

            /** UserAgent osBuildNumber */
            osBuildNumber?: (string|null);

            /** UserAgent phoneId */
            phoneId?: (string|null);

            /** UserAgent releaseChannel */
            releaseChannel?: (proto.ClientPayload.UserAgent.ReleaseChannel|null);

            /** UserAgent localeLanguageIso6391 */
            localeLanguageIso6391?: (string|null);

            /** UserAgent localeCountryIso31661Alpha2 */
            localeCountryIso31661Alpha2?: (string|null);

            /** UserAgent deviceBoard */
            deviceBoard?: (string|null);

            /** UserAgent deviceExpId */
            deviceExpId?: (string|null);

            /** UserAgent deviceType */
            deviceType?: (proto.ClientPayload.UserAgent.DeviceType|null);
        }

        /** Represents a UserAgent. */
        class UserAgent implements IUserAgent {

            /**
             * Constructs a new UserAgent.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.ClientPayload.IUserAgent);

            /** UserAgent platform. */
            public platform: proto.ClientPayload.UserAgent.Platform;

            /** UserAgent appVersion. */
            public appVersion?: (proto.ClientPayload.UserAgent.IAppVersion|null);

            /** UserAgent mcc. */
            public mcc: string;

            /** UserAgent mnc. */
            public mnc: string;

            /** UserAgent osVersion. */
            public osVersion: string;

            /** UserAgent manufacturer. */
            public manufacturer: string;

            /** UserAgent device. */
            public device: string;

            /** UserAgent osBuildNumber. */
            public osBuildNumber: string;

            /** UserAgent phoneId. */
            public phoneId: string;

            /** UserAgent releaseChannel. */
            public releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel;

            /** UserAgent localeLanguageIso6391. */
            public localeLanguageIso6391: string;

            /** UserAgent localeCountryIso31661Alpha2. */
            public localeCountryIso31661Alpha2: string;

            /** UserAgent deviceBoard. */
            public deviceBoard: string;

            /** UserAgent deviceExpId. */
            public deviceExpId: string;

            /** UserAgent deviceType. */
            public deviceType: proto.ClientPayload.UserAgent.DeviceType;

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

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

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

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

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

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

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

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

        namespace UserAgent {

            /** Properties of an AppVersion. */
            interface IAppVersion {

                /** AppVersion primary */
                primary?: (number|null);

                /** AppVersion secondary */
                secondary?: (number|null);

                /** AppVersion tertiary */
                tertiary?: (number|null);

                /** AppVersion quaternary */
                quaternary?: (number|null);

                /** AppVersion quinary */
                quinary?: (number|null);
            }

            /** Represents an AppVersion. */
            class AppVersion implements IAppVersion {

                /**
                 * Constructs a new AppVersion.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.ClientPayload.UserAgent.IAppVersion);

                /** AppVersion primary. */
                public primary: number;

                /** AppVersion secondary. */
                public secondary: number;

                /** AppVersion tertiary. */
                public tertiary: number;

                /** AppVersion quaternary. */
                public quaternary: number;

                /** AppVersion quinary. */
                public quinary: number;

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

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

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

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

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

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

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

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

            /** DeviceType enum. */
            enum DeviceType {
                PHONE = 0,
                TABLET = 1,
                DESKTOP = 2,
                WEARABLE = 3,
                VR = 4
            }

            /** Platform enum. */
            enum Platform {
                ANDROID = 0,
                IOS = 1,
                WINDOWS_PHONE = 2,
                BLACKBERRY = 3,
                BLACKBERRYX = 4,
                S40 = 5,
                S60 = 6,
                PYTHON_CLIENT = 7,
                TIZEN = 8,
                ENTERPRISE = 9,
                SMB_ANDROID = 10,
                KAIOS = 11,
                SMB_IOS = 12,
                WINDOWS = 13,
                WEB = 14,
                PORTAL = 15,
                GREEN_ANDROID = 16,
                GREEN_IPHONE = 17,
                BLUE_ANDROID = 18,
                BLUE_IPHONE = 19,
                FBLITE_ANDROID = 20,
                MLITE_ANDROID = 21,
                IGLITE_ANDROID = 22,
                PAGE = 23,
                MACOS = 24,
                OCULUS_MSG = 25,
                OCULUS_CALL = 26,
                MILAN = 27,
                CAPI = 28,
                WEAROS = 29,
                ARDEVICE = 30,
                VRDEVICE = 31,
                BLUE_WEB = 32,
                IPAD = 33,
                TEST = 34,
                SMART_GLASSES = 35
            }

            /** ReleaseChannel enum. */
            enum ReleaseChannel {
                RELEASE = 0,
                BETA = 1,
                ALPHA = 2,
                DEBUG = 3
            }
        }

        /** Properties of a WebInfo. */
        interface IWebInfo {

            /** WebInfo refToken */
            refToken?: (string|null);

            /** WebInfo version */
            version?: (string|null);

            /** WebInfo webdPayload */
            webdPayload?: (proto.ClientPayload.WebInfo.IWebdPayload|null);

            /** WebInfo webSubPlatform */
            webSubPlatform?: (proto.ClientPayload.WebInfo.WebSubPlatform|null);
        }

        /** Represents a WebInfo. */
        class WebInfo implements IWebInfo {

            /**
             * Constructs a new WebInfo.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.ClientPayload.IWebInfo);

            /** WebInfo refToken. */
            public refToken: string;

            /** WebInfo version. */
            public version: string;

            /** WebInfo webdPayload. */
            public webdPayload?: (proto.ClientPayload.WebInfo.IWebdPayload|null);

            /** WebInfo webSubPlatform. */
            public webSubPlatform: proto.ClientPayload.WebInfo.WebSubPlatform;

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

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

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

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

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

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

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

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

        namespace WebInfo {

            /** WebSubPlatform enum. */
            enum WebSubPlatform {
                WEB_BROWSER = 0,
                APP_STORE = 1,
                WIN_STORE = 2,
                DARWIN = 3,
                WIN32 = 4
            }

            /** Properties of a WebdPayload. */
            interface IWebdPayload {

                /** WebdPayload usesParticipantInKey */
                usesParticipantInKey?: (boolean|null);

                /** WebdPayload supportsStarredMessages */
                supportsStarredMessages?: (boolean|null);

                /** WebdPayload supportsDocumentMessages */
                supportsDocumentMessages?: (boolean|null);

                /** WebdPayload supportsUrlMessages */
                supportsUrlMessages?: (boolean|null);

                /** WebdPayload supportsMediaRetry */
                supportsMediaRetry?: (boolean|null);

                /** WebdPayload supportsE2EImage */
                supportsE2EImage?: (boolean|null);

                /** WebdPayload supportsE2EVideo */
                supportsE2EVideo?: (boolean|null);

                /** WebdPayload supportsE2EAudio */
                supportsE2EAudio?: (boolean|null);

                /** WebdPayload supportsE2EDocument */
                supportsE2EDocument?: (boolean|null);

                /** WebdPayload documentTypes */
                documentTypes?: (string|null);

                /** WebdPayload features */
                features?: (Uint8Array|null);
            }

            /** Represents a WebdPayload. */
            class WebdPayload implements IWebdPayload {

                /**
                 * Constructs a new WebdPayload.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.ClientPayload.WebInfo.IWebdPayload);

                /** WebdPayload usesParticipantInKey. */
                public usesParticipantInKey: boolean;

                /** WebdPayload supportsStarredMessages. */
                public supportsStarredMessages: boolean;

                /** WebdPayload supportsDocumentMessages. */
                public supportsDocumentMessages: boolean;

                /** WebdPayload supportsUrlMessages. */
                public supportsUrlMessages: boolean;

                /** WebdPayload supportsMediaRetry. */
                public supportsMediaRetry: boolean;

                /** WebdPayload supportsE2EImage. */
                public supportsE2EImage: boolean;

                /** WebdPayload supportsE2EVideo. */
                public supportsE2EVideo: boolean;

                /** WebdPayload supportsE2EAudio. */
                public supportsE2EAudio: boolean;

                /** WebdPayload supportsE2EDocument. */
                public supportsE2EDocument: boolean;

                /** WebdPayload documentTypes. */
                public documentTypes: string;

                /** WebdPayload features. */
                public features: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of a CommentMetadata. */
    interface ICommentMetadata {

        /** CommentMetadata commentParentKey */
        commentParentKey?: (proto.IMessageKey|null);

        /** CommentMetadata replyCount */
        replyCount?: (number|null);
    }

    /** Represents a CommentMetadata. */
    class CommentMetadata implements ICommentMetadata {

        /**
         * Constructs a new CommentMetadata.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ICommentMetadata);

        /** CommentMetadata commentParentKey. */
        public commentParentKey?: (proto.IMessageKey|null);

        /** CommentMetadata replyCount. */
        public replyCount: number;

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

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

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

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

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

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

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

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

    /** Properties of a ContextInfo. */
    interface IContextInfo {

        /** ContextInfo stanzaId */
        stanzaId?: (string|null);

        /** ContextInfo participant */
        participant?: (string|null);

        /** ContextInfo quotedMessage */
        quotedMessage?: (proto.IMessage|null);

        /** ContextInfo remoteJid */
        remoteJid?: (string|null);

        /** ContextInfo mentionedJid */
        mentionedJid?: (string[]|null);

        /** ContextInfo conversionSource */
        conversionSource?: (string|null);

        /** ContextInfo conversionData */
        conversionData?: (Uint8Array|null);

        /** ContextInfo conversionDelaySeconds */
        conversionDelaySeconds?: (number|null);

        /** ContextInfo forwardingScore */
        forwardingScore?: (number|null);

        /** ContextInfo isForwarded */
        isForwarded?: (boolean|null);

        /** ContextInfo quotedAd */
        quotedAd?: (proto.ContextInfo.IAdReplyInfo|null);

        /** ContextInfo placeholderKey */
        placeholderKey?: (proto.IMessageKey|null);

        /** ContextInfo expiration */
        expiration?: (number|null);

        /** ContextInfo ephemeralSettingTimestamp */
        ephemeralSettingTimestamp?: (number|Long|null);

        /** ContextInfo ephemeralSharedSecret */
        ephemeralSharedSecret?: (Uint8Array|null);

        /** ContextInfo externalAdReply */
        externalAdReply?: (proto.ContextInfo.IExternalAdReplyInfo|null);

        /** ContextInfo entryPointConversionSource */
        entryPointConversionSource?: (string|null);

        /** ContextInfo entryPointConversionApp */
        entryPointConversionApp?: (string|null);

        /** ContextInfo entryPointConversionDelaySeconds */
        entryPointConversionDelaySeconds?: (number|null);

        /** ContextInfo disappearingMode */
        disappearingMode?: (proto.IDisappearingMode|null);

        /** ContextInfo actionLink */
        actionLink?: (proto.IActionLink|null);

        /** ContextInfo groupSubject */
        groupSubject?: (string|null);

        /** ContextInfo parentGroupJid */
        parentGroupJid?: (string|null);

        /** ContextInfo trustBannerType */
        trustBannerType?: (string|null);

        /** ContextInfo trustBannerAction */
        trustBannerAction?: (number|null);

        /** ContextInfo isSampled */
        isSampled?: (boolean|null);

        /** ContextInfo groupMentions */
        groupMentions?: (proto.IGroupMention[]|null);

        /** ContextInfo utm */
        utm?: (proto.ContextInfo.IUTMInfo|null);

        /** ContextInfo forwardedNewsletterMessageInfo */
        forwardedNewsletterMessageInfo?: (proto.ContextInfo.IForwardedNewsletterMessageInfo|null);

        /** ContextInfo businessMessageForwardInfo */
        businessMessageForwardInfo?: (proto.ContextInfo.IBusinessMessageForwardInfo|null);

        /** ContextInfo smbClientCampaignId */
        smbClientCampaignId?: (string|null);

        /** ContextInfo smbServerCampaignId */
        smbServerCampaignId?: (string|null);

        /** ContextInfo dataSharingContext */
        dataSharingContext?: (proto.ContextInfo.IDataSharingContext|null);
    }

    /** Represents a ContextInfo. */
    class ContextInfo implements IContextInfo {

        /**
         * Constructs a new ContextInfo.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IContextInfo);

        /** ContextInfo stanzaId. */
        public stanzaId: string;

        /** ContextInfo participant. */
        public participant: string;

        /** ContextInfo quotedMessage. */
        public quotedMessage?: (proto.IMessage|null);

        /** ContextInfo remoteJid. */
        public remoteJid: string;

        /** ContextInfo mentionedJid. */
        public mentionedJid: string[];

        /** ContextInfo conversionSource. */
        public conversionSource: string;

        /** ContextInfo conversionData. */
        public conversionData: Uint8Array;

        /** ContextInfo conversionDelaySeconds. */
        public conversionDelaySeconds: number;

        /** ContextInfo forwardingScore. */
        public forwardingScore: number;

        /** ContextInfo isForwarded. */
        public isForwarded: boolean;

        /** ContextInfo quotedAd. */
        public quotedAd?: (proto.ContextInfo.IAdReplyInfo|null);

        /** ContextInfo placeholderKey. */
        public placeholderKey?: (proto.IMessageKey|null);

        /** ContextInfo expiration. */
        public expiration: number;

        /** ContextInfo ephemeralSettingTimestamp. */
        public ephemeralSettingTimestamp: (number|Long);

        /** ContextInfo ephemeralSharedSecret. */
        public ephemeralSharedSecret: Uint8Array;

        /** ContextInfo externalAdReply. */
        public externalAdReply?: (proto.ContextInfo.IExternalAdReplyInfo|null);

        /** ContextInfo entryPointConversionSource. */
        public entryPointConversionSource: string;

        /** ContextInfo entryPointConversionApp. */
        public entryPointConversionApp: string;

        /** ContextInfo entryPointConversionDelaySeconds. */
        public entryPointConversionDelaySeconds: number;

        /** ContextInfo disappearingMode. */
        public disappearingMode?: (proto.IDisappearingMode|null);

        /** ContextInfo actionLink. */
        public actionLink?: (proto.IActionLink|null);

        /** ContextInfo groupSubject. */
        public groupSubject: string;

        /** ContextInfo parentGroupJid. */
        public parentGroupJid: string;

        /** ContextInfo trustBannerType. */
        public trustBannerType: string;

        /** ContextInfo trustBannerAction. */
        public trustBannerAction: number;

        /** ContextInfo isSampled. */
        public isSampled: boolean;

        /** ContextInfo groupMentions. */
        public groupMentions: proto.IGroupMention[];

        /** ContextInfo utm. */
        public utm?: (proto.ContextInfo.IUTMInfo|null);

        /** ContextInfo forwardedNewsletterMessageInfo. */
        public forwardedNewsletterMessageInfo?: (proto.ContextInfo.IForwardedNewsletterMessageInfo|null);

        /** ContextInfo businessMessageForwardInfo. */
        public businessMessageForwardInfo?: (proto.ContextInfo.IBusinessMessageForwardInfo|null);

        /** ContextInfo smbClientCampaignId. */
        public smbClientCampaignId: string;

        /** ContextInfo smbServerCampaignId. */
        public smbServerCampaignId: string;

        /** ContextInfo dataSharingContext. */
        public dataSharingContext?: (proto.ContextInfo.IDataSharingContext|null);

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

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

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

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

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

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

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

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

    namespace ContextInfo {

        /** Properties of an AdReplyInfo. */
        interface IAdReplyInfo {

            /** AdReplyInfo advertiserName */
            advertiserName?: (string|null);

            /** AdReplyInfo mediaType */
            mediaType?: (proto.ContextInfo.AdReplyInfo.MediaType|null);

            /** AdReplyInfo jpegThumbnail */
            jpegThumbnail?: (Uint8Array|null);

            /** AdReplyInfo caption */
            caption?: (string|null);
        }

        /** Represents an AdReplyInfo. */
        class AdReplyInfo implements IAdReplyInfo {

            /**
             * Constructs a new AdReplyInfo.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.ContextInfo.IAdReplyInfo);

            /** AdReplyInfo advertiserName. */
            public advertiserName: string;

            /** AdReplyInfo mediaType. */
            public mediaType: proto.ContextInfo.AdReplyInfo.MediaType;

            /** AdReplyInfo jpegThumbnail. */
            public jpegThumbnail: Uint8Array;

            /** AdReplyInfo caption. */
            public caption: string;

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

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

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

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

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

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

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

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

        namespace AdReplyInfo {

            /** MediaType enum. */
            enum MediaType {
                NONE = 0,
                IMAGE = 1,
                VIDEO = 2
            }
        }

        /** Properties of a BusinessMessageForwardInfo. */
        interface IBusinessMessageForwardInfo {

            /** BusinessMessageForwardInfo businessOwnerJid */
            businessOwnerJid?: (string|null);
        }

        /** Represents a BusinessMessageForwardInfo. */
        class BusinessMessageForwardInfo implements IBusinessMessageForwardInfo {

            /**
             * Constructs a new BusinessMessageForwardInfo.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.ContextInfo.IBusinessMessageForwardInfo);

            /** BusinessMessageForwardInfo businessOwnerJid. */
            public businessOwnerJid: string;

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

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

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

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

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

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

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

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

        /** Properties of a DataSharingContext. */
        interface IDataSharingContext {

            /** DataSharingContext showMmDisclosure */
            showMmDisclosure?: (boolean|null);
        }

        /** Represents a DataSharingContext. */
        class DataSharingContext implements IDataSharingContext {

            /**
             * Constructs a new DataSharingContext.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.ContextInfo.IDataSharingContext);

            /** DataSharingContext showMmDisclosure. */
            public showMmDisclosure: boolean;

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

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

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

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

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

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

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

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

        /** Properties of an ExternalAdReplyInfo. */
        interface IExternalAdReplyInfo {

            /** ExternalAdReplyInfo title */
            title?: (string|null);

            /** ExternalAdReplyInfo body */
            body?: (string|null);

            /** ExternalAdReplyInfo mediaType */
            mediaType?: (proto.ContextInfo.ExternalAdReplyInfo.MediaType|null);

            /** ExternalAdReplyInfo thumbnailUrl */
            thumbnailUrl?: (string|null);

            /** ExternalAdReplyInfo mediaUrl */
            mediaUrl?: (string|null);

            /** ExternalAdReplyInfo thumbnail */
            thumbnail?: (Uint8Array|null);

            /** ExternalAdReplyInfo sourceType */
            sourceType?: (string|null);

            /** ExternalAdReplyInfo sourceId */
            sourceId?: (string|null);

            /** ExternalAdReplyInfo sourceUrl */
            sourceUrl?: (string|null);

            /** ExternalAdReplyInfo containsAutoReply */
            containsAutoReply?: (boolean|null);

            /** ExternalAdReplyInfo renderLargerThumbnail */
            renderLargerThumbnail?: (boolean|null);

            /** ExternalAdReplyInfo showAdAttribution */
            showAdAttribution?: (boolean|null);

            /** ExternalAdReplyInfo ctwaClid */
            ctwaClid?: (string|null);

            /** ExternalAdReplyInfo ref */
            ref?: (string|null);
        }

        /** Represents an ExternalAdReplyInfo. */
        class ExternalAdReplyInfo implements IExternalAdReplyInfo {

            /**
             * Constructs a new ExternalAdReplyInfo.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.ContextInfo.IExternalAdReplyInfo);

            /** ExternalAdReplyInfo title. */
            public title: string;

            /** ExternalAdReplyInfo body. */
            public body: string;

            /** ExternalAdReplyInfo mediaType. */
            public mediaType: proto.ContextInfo.ExternalAdReplyInfo.MediaType;

            /** ExternalAdReplyInfo thumbnailUrl. */
            public thumbnailUrl: string;

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

            /** ExternalAdReplyInfo thumbnail. */
            public thumbnail: Uint8Array;

            /** ExternalAdReplyInfo sourceType. */
            public sourceType: string;

            /** ExternalAdReplyInfo sourceId. */
            public sourceId: string;

            /** ExternalAdReplyInfo sourceUrl. */
            public sourceUrl: string;

            /** ExternalAdReplyInfo containsAutoReply. */
            public containsAutoReply: boolean;

            /** ExternalAdReplyInfo renderLargerThumbnail. */
            public renderLargerThumbnail: boolean;

            /** ExternalAdReplyInfo showAdAttribution. */
            public showAdAttribution: boolean;

            /** ExternalAdReplyInfo ctwaClid. */
            public ctwaClid: string;

            /** ExternalAdReplyInfo ref. */
            public ref: string;

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

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

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

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

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

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

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

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

        namespace ExternalAdReplyInfo {

            /** MediaType enum. */
            enum MediaType {
                NONE = 0,
                IMAGE = 1,
                VIDEO = 2
            }
        }

        /** Properties of a ForwardedNewsletterMessageInfo. */
        interface IForwardedNewsletterMessageInfo {

            /** ForwardedNewsletterMessageInfo newsletterJid */
            newsletterJid?: (string|null);

            /** ForwardedNewsletterMessageInfo serverMessageId */
            serverMessageId?: (number|null);

            /** ForwardedNewsletterMessageInfo newsletterName */
            newsletterName?: (string|null);

            /** ForwardedNewsletterMessageInfo contentType */
            contentType?: (proto.ContextInfo.ForwardedNewsletterMessageInfo.ContentType|null);

            /** ForwardedNewsletterMessageInfo accessibilityText */
            accessibilityText?: (string|null);
        }

        /** Represents a ForwardedNewsletterMessageInfo. */
        class ForwardedNewsletterMessageInfo implements IForwardedNewsletterMessageInfo {

            /**
             * Constructs a new ForwardedNewsletterMessageInfo.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.ContextInfo.IForwardedNewsletterMessageInfo);

            /** ForwardedNewsletterMessageInfo newsletterJid. */
            public newsletterJid: string;

            /** ForwardedNewsletterMessageInfo serverMessageId. */
            public serverMessageId: number;

            /** ForwardedNewsletterMessageInfo newsletterName. */
            public newsletterName: string;

            /** ForwardedNewsletterMessageInfo contentType. */
            public contentType: proto.ContextInfo.ForwardedNewsletterMessageInfo.ContentType;

            /** ForwardedNewsletterMessageInfo accessibilityText. */
            public accessibilityText: string;

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

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

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

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

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

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

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

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

        namespace ForwardedNewsletterMessageInfo {

            /** ContentType enum. */
            enum ContentType {
                UPDATE = 1,
                UPDATE_CARD = 2,
                LINK_CARD = 3
            }
        }

        /** Properties of a UTMInfo. */
        interface IUTMInfo {

            /** UTMInfo utmSource */
            utmSource?: (string|null);

            /** UTMInfo utmCampaign */
            utmCampaign?: (string|null);
        }

        /** Represents a UTMInfo. */
        class UTMInfo implements IUTMInfo {

            /**
             * Constructs a new UTMInfo.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.ContextInfo.IUTMInfo);

            /** UTMInfo utmSource. */
            public utmSource: string;

            /** UTMInfo utmCampaign. */
            public utmCampaign: string;

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

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

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

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

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

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

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

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

    /** Properties of a Conversation. */
    interface IConversation {

        /** Conversation id */
        id: string;

        /** Conversation messages */
        messages?: (proto.IHistorySyncMsg[]|null);

        /** Conversation newJid */
        newJid?: (string|null);

        /** Conversation oldJid */
        oldJid?: (string|null);

        /** Conversation lastMsgTimestamp */
        lastMsgTimestamp?: (number|Long|null);

        /** Conversation unreadCount */
        unreadCount?: (number|null);

        /** Conversation readOnly */
        readOnly?: (boolean|null);

        /** Conversation endOfHistoryTransfer */
        endOfHistoryTransfer?: (boolean|null);

        /** Conversation ephemeralExpiration */
        ephemeralExpiration?: (number|null);

        /** Conversation ephemeralSettingTimestamp */
        ephemeralSettingTimestamp?: (number|Long|null);

        /** Conversation endOfHistoryTransferType */
        endOfHistoryTransferType?: (proto.Conversation.EndOfHistoryTransferType|null);

        /** Conversation conversationTimestamp */
        conversationTimestamp?: (number|Long|null);

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

        /** Conversation pHash */
        pHash?: (string|null);

        /** Conversation notSpam */
        notSpam?: (boolean|null);

        /** Conversation archived */
        archived?: (boolean|null);

        /** Conversation disappearingMode */
        disappearingMode?: (proto.IDisappearingMode|null);

        /** Conversation unreadMentionCount */
        unreadMentionCount?: (number|null);

        /** Conversation markedAsUnread */
        markedAsUnread?: (boolean|null);

        /** Conversation participant */
        participant?: (proto.IGroupParticipant[]|null);

        /** Conversation tcToken */
        tcToken?: (Uint8Array|null);

        /** Conversation tcTokenTimestamp */
        tcTokenTimestamp?: (number|Long|null);

        /** Conversation contactPrimaryIdentityKey */
        contactPrimaryIdentityKey?: (Uint8Array|null);

        /** Conversation pinned */
        pinned?: (number|null);

        /** Conversation muteEndTime */
        muteEndTime?: (number|Long|null);

        /** Conversation wallpaper */
        wallpaper?: (proto.IWallpaperSettings|null);

        /** Conversation mediaVisibility */
        mediaVisibility?: (proto.MediaVisibility|null);

        /** Conversation tcTokenSenderTimestamp */
        tcTokenSenderTimestamp?: (number|Long|null);

        /** Conversation suspended */
        suspended?: (boolean|null);

        /** Conversation terminated */
        terminated?: (boolean|null);

        /** Conversation createdAt */
        createdAt?: (number|Long|null);

        /** Conversation createdBy */
        createdBy?: (string|null);

        /** Conversation description */
        description?: (string|null);

        /** Conversation support */
        support?: (boolean|null);

        /** Conversation isParentGroup */
        isParentGroup?: (boolean|null);

        /** Conversation parentGroupId */
        parentGroupId?: (string|null);

        /** Conversation isDefaultSubgroup */
        isDefaultSubgroup?: (boolean|null);

        /** Conversation displayName */
        displayName?: (string|null);

        /** Conversation pnJid */
        pnJid?: (string|null);

        /** Conversation shareOwnPn */
        shareOwnPn?: (boolean|null);

        /** Conversation pnhDuplicateLidThread */
        pnhDuplicateLidThread?: (boolean|null);

        /** Conversation lidJid */
        lidJid?: (string|null);

        /** Conversation username */
        username?: (string|null);

        /** Conversation lidOriginType */
        lidOriginType?: (string|null);

        /** Conversation commentsCount */
        commentsCount?: (number|null);
    }

    /** Represents a Conversation. */
    class Conversation implements IConversation {

        /**
         * Constructs a new Conversation.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IConversation);

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

        /** Conversation messages. */
        public messages: proto.IHistorySyncMsg[];

        /** Conversation newJid. */
        public newJid: string;

        /** Conversation oldJid. */
        public oldJid: string;

        /** Conversation lastMsgTimestamp. */
        public lastMsgTimestamp: (number|Long);

        /** Conversation unreadCount. */
        public unreadCount: number;

        /** Conversation readOnly. */
        public readOnly: boolean;

        /** Conversation endOfHistoryTransfer. */
        public endOfHistoryTransfer: boolean;

        /** Conversation ephemeralExpiration. */
        public ephemeralExpiration: number;

        /** Conversation ephemeralSettingTimestamp. */
        public ephemeralSettingTimestamp: (number|Long);

        /** Conversation endOfHistoryTransferType. */
        public endOfHistoryTransferType: proto.Conversation.EndOfHistoryTransferType;

        /** Conversation conversationTimestamp. */
        public conversationTimestamp: (number|Long);

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

        /** Conversation pHash. */
        public pHash: string;

        /** Conversation notSpam. */
        public notSpam: boolean;

        /** Conversation archived. */
        public archived: boolean;

        /** Conversation disappearingMode. */
        public disappearingMode?: (proto.IDisappearingMode|null);

        /** Conversation unreadMentionCount. */
        public unreadMentionCount: number;

        /** Conversation markedAsUnread. */
        public markedAsUnread: boolean;

        /** Conversation participant. */
        public participant: proto.IGroupParticipant[];

        /** Conversation tcToken. */
        public tcToken: Uint8Array;

        /** Conversation tcTokenTimestamp. */
        public tcTokenTimestamp: (number|Long);

        /** Conversation contactPrimaryIdentityKey. */
        public contactPrimaryIdentityKey: Uint8Array;

        /** Conversation pinned. */
        public pinned: number;

        /** Conversation muteEndTime. */
        public muteEndTime: (number|Long);

        /** Conversation wallpaper. */
        public wallpaper?: (proto.IWallpaperSettings|null);

        /** Conversation mediaVisibility. */
        public mediaVisibility: proto.MediaVisibility;

        /** Conversation tcTokenSenderTimestamp. */
        public tcTokenSenderTimestamp: (number|Long);

        /** Conversation suspended. */
        public suspended: boolean;

        /** Conversation terminated. */
        public terminated: boolean;

        /** Conversation createdAt. */
        public createdAt: (number|Long);

        /** Conversation createdBy. */
        public createdBy: string;

        /** Conversation description. */
        public description: string;

        /** Conversation support. */
        public support: boolean;

        /** Conversation isParentGroup. */
        public isParentGroup: boolean;

        /** Conversation parentGroupId. */
        public parentGroupId: string;

        /** Conversation isDefaultSubgroup. */
        public isDefaultSubgroup: boolean;

        /** Conversation displayName. */
        public displayName: string;

        /** Conversation pnJid. */
        public pnJid: string;

        /** Conversation shareOwnPn. */
        public shareOwnPn: boolean;

        /** Conversation pnhDuplicateLidThread. */
        public pnhDuplicateLidThread: boolean;

        /** Conversation lidJid. */
        public lidJid: string;

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

        /** Conversation lidOriginType. */
        public lidOriginType: string;

        /** Conversation commentsCount. */
        public commentsCount: number;

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

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

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

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

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

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

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

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

    namespace Conversation {

        /** EndOfHistoryTransferType enum. */
        enum EndOfHistoryTransferType {
            COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY = 0,
            COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY = 1,
            COMPLETE_ON_DEMAND_SYNC_BUT_MORE_MSG_REMAIN_ON_PRIMARY = 2
        }
    }

    /** Properties of a DeviceConsistencyCodeMessage. */
    interface IDeviceConsistencyCodeMessage {

        /** DeviceConsistencyCodeMessage generation */
        generation?: (number|null);

        /** DeviceConsistencyCodeMessage signature */
        signature?: (Uint8Array|null);
    }

    /** Represents a DeviceConsistencyCodeMessage. */
    class DeviceConsistencyCodeMessage implements IDeviceConsistencyCodeMessage {

        /**
         * Constructs a new DeviceConsistencyCodeMessage.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IDeviceConsistencyCodeMessage);

        /** DeviceConsistencyCodeMessage generation. */
        public generation: number;

        /** DeviceConsistencyCodeMessage signature. */
        public signature: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of a DeviceListMetadata. */
    interface IDeviceListMetadata {

        /** DeviceListMetadata senderKeyHash */
        senderKeyHash?: (Uint8Array|null);

        /** DeviceListMetadata senderTimestamp */
        senderTimestamp?: (number|Long|null);

        /** DeviceListMetadata senderKeyIndexes */
        senderKeyIndexes?: (number[]|null);

        /** DeviceListMetadata senderAccountType */
        senderAccountType?: (proto.ADVEncryptionType|null);

        /** DeviceListMetadata receiverAccountType */
        receiverAccountType?: (proto.ADVEncryptionType|null);

        /** DeviceListMetadata recipientKeyHash */
        recipientKeyHash?: (Uint8Array|null);

        /** DeviceListMetadata recipientTimestamp */
        recipientTimestamp?: (number|Long|null);

        /** DeviceListMetadata recipientKeyIndexes */
        recipientKeyIndexes?: (number[]|null);
    }

    /** Represents a DeviceListMetadata. */
    class DeviceListMetadata implements IDeviceListMetadata {

        /**
         * Constructs a new DeviceListMetadata.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IDeviceListMetadata);

        /** DeviceListMetadata senderKeyHash. */
        public senderKeyHash: Uint8Array;

        /** DeviceListMetadata senderTimestamp. */
        public senderTimestamp: (number|Long);

        /** DeviceListMetadata senderKeyIndexes. */
        public senderKeyIndexes: number[];

        /** DeviceListMetadata senderAccountType. */
        public senderAccountType: proto.ADVEncryptionType;

        /** DeviceListMetadata receiverAccountType. */
        public receiverAccountType: proto.ADVEncryptionType;

        /** DeviceListMetadata recipientKeyHash. */
        public recipientKeyHash: Uint8Array;

        /** DeviceListMetadata recipientTimestamp. */
        public recipientTimestamp: (number|Long);

        /** DeviceListMetadata recipientKeyIndexes. */
        public recipientKeyIndexes: number[];

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

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

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

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

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

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

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

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

    /** Properties of a DeviceProps. */
    interface IDeviceProps {

        /** DeviceProps os */
        os?: (string|null);

        /** DeviceProps version */
        version?: (proto.DeviceProps.IAppVersion|null);

        /** DeviceProps platformType */
        platformType?: (proto.DeviceProps.PlatformType|null);

        /** DeviceProps requireFullSync */
        requireFullSync?: (boolean|null);

        /** DeviceProps historySyncConfig */
        historySyncConfig?: (proto.DeviceProps.IHistorySyncConfig|null);
    }

    /** Represents a DeviceProps. */
    class DeviceProps implements IDeviceProps {

        /**
         * Constructs a new DeviceProps.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IDeviceProps);

        /** DeviceProps os. */
        public os: string;

        /** DeviceProps version. */
        public version?: (proto.DeviceProps.IAppVersion|null);

        /** DeviceProps platformType. */
        public platformType: proto.DeviceProps.PlatformType;

        /** DeviceProps requireFullSync. */
        public requireFullSync: boolean;

        /** DeviceProps historySyncConfig. */
        public historySyncConfig?: (proto.DeviceProps.IHistorySyncConfig|null);

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

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

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

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

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

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

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

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

    namespace DeviceProps {

        /** Properties of an AppVersion. */
        interface IAppVersion {

            /** AppVersion primary */
            primary?: (number|null);

            /** AppVersion secondary */
            secondary?: (number|null);

            /** AppVersion tertiary */
            tertiary?: (number|null);

            /** AppVersion quaternary */
            quaternary?: (number|null);

            /** AppVersion quinary */
            quinary?: (number|null);
        }

        /** Represents an AppVersion. */
        class AppVersion implements IAppVersion {

            /**
             * Constructs a new AppVersion.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.DeviceProps.IAppVersion);

            /** AppVersion primary. */
            public primary: number;

            /** AppVersion secondary. */
            public secondary: number;

            /** AppVersion tertiary. */
            public tertiary: number;

            /** AppVersion quaternary. */
            public quaternary: number;

            /** AppVersion quinary. */
            public quinary: number;

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

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

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

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

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

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

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

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

        /** Properties of a HistorySyncConfig. */
        interface IHistorySyncConfig {

            /** HistorySyncConfig fullSyncDaysLimit */
            fullSyncDaysLimit?: (number|null);

            /** HistorySyncConfig fullSyncSizeMbLimit */
            fullSyncSizeMbLimit?: (number|null);

            /** HistorySyncConfig storageQuotaMb */
            storageQuotaMb?: (number|null);

            /** HistorySyncConfig inlineInitialPayloadInE2EeMsg */
            inlineInitialPayloadInE2EeMsg?: (boolean|null);

            /** HistorySyncConfig recentSyncDaysLimit */
            recentSyncDaysLimit?: (number|null);

            /** HistorySyncConfig supportCallLogHistory */
            supportCallLogHistory?: (boolean|null);

            /** HistorySyncConfig supportBotUserAgentChatHistory */
            supportBotUserAgentChatHistory?: (boolean|null);

            /** HistorySyncConfig supportCagReactionsAndPolls */
            supportCagReactionsAndPolls?: (boolean|null);
        }

        /** Represents a HistorySyncConfig. */
        class HistorySyncConfig implements IHistorySyncConfig {

            /**
             * Constructs a new HistorySyncConfig.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.DeviceProps.IHistorySyncConfig);

            /** HistorySyncConfig fullSyncDaysLimit. */
            public fullSyncDaysLimit: number;

            /** HistorySyncConfig fullSyncSizeMbLimit. */
            public fullSyncSizeMbLimit: number;

            /** HistorySyncConfig storageQuotaMb. */
            public storageQuotaMb: number;

            /** HistorySyncConfig inlineInitialPayloadInE2EeMsg. */
            public inlineInitialPayloadInE2EeMsg: boolean;

            /** HistorySyncConfig recentSyncDaysLimit. */
            public recentSyncDaysLimit: number;

            /** HistorySyncConfig supportCallLogHistory. */
            public supportCallLogHistory: boolean;

            /** HistorySyncConfig supportBotUserAgentChatHistory. */
            public supportBotUserAgentChatHistory: boolean;

            /** HistorySyncConfig supportCagReactionsAndPolls. */
            public supportCagReactionsAndPolls: boolean;

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

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

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

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

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

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

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

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

        /** PlatformType enum. */
        enum PlatformType {
            UNKNOWN = 0,
            CHROME = 1,
            FIREFOX = 2,
            IE = 3,
            OPERA = 4,
            SAFARI = 5,
            EDGE = 6,
            DESKTOP = 7,
            IPAD = 8,
            ANDROID_TABLET = 9,
            OHANA = 10,
            ALOHA = 11,
            CATALINA = 12,
            TCL_TV = 13,
            IOS_PHONE = 14,
            IOS_CATALYST = 15,
            ANDROID_PHONE = 16,
            ANDROID_AMBIGUOUS = 17,
            WEAR_OS = 18,
            AR_WRIST = 19,
            AR_DEVICE = 20,
            UWP = 21,
            VR = 22
        }
    }

    /** Properties of a DisappearingMode. */
    interface IDisappearingMode {

        /** DisappearingMode initiator */
        initiator?: (proto.DisappearingMode.Initiator|null);

        /** DisappearingMode trigger */
        trigger?: (proto.DisappearingMode.Trigger|null);

        /** DisappearingMode initiatorDeviceJid */
        initiatorDeviceJid?: (string|null);

        /** DisappearingMode initiatedByMe */
        initiatedByMe?: (boolean|null);
    }

    /** Represents a DisappearingMode. */
    class DisappearingMode implements IDisappearingMode {

        /**
         * Constructs a new DisappearingMode.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IDisappearingMode);

        /** DisappearingMode initiator. */
        public initiator: proto.DisappearingMode.Initiator;

        /** DisappearingMode trigger. */
        public trigger: proto.DisappearingMode.Trigger;

        /** DisappearingMode initiatorDeviceJid. */
        public initiatorDeviceJid: string;

        /** DisappearingMode initiatedByMe. */
        public initiatedByMe: boolean;

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

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

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

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

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

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

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

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

    namespace DisappearingMode {

        /** Initiator enum. */
        enum Initiator {
            CHANGED_IN_CHAT = 0,
            INITIATED_BY_ME = 1,
            INITIATED_BY_OTHER = 2,
            BIZ_UPGRADE_FB_HOSTING = 3
        }

        /** Trigger enum. */
        enum Trigger {
            UNKNOWN = 0,
            CHAT_SETTING = 1,
            ACCOUNT_SETTING = 2,
            BULK_CHANGE = 3,
            BIZ_SUPPORTS_FB_HOSTING = 4
        }
    }

    /** Properties of an EphemeralSetting. */
    interface IEphemeralSetting {

        /** EphemeralSetting duration */
        duration?: (number|null);

        /** EphemeralSetting timestamp */
        timestamp?: (number|Long|null);
    }

    /** Represents an EphemeralSetting. */
    class EphemeralSetting implements IEphemeralSetting {

        /**
         * Constructs a new EphemeralSetting.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IEphemeralSetting);

        /** EphemeralSetting duration. */
        public duration: number;

        /** EphemeralSetting timestamp. */
        public timestamp: (number|Long);

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

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

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

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

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

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

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

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

    /** Properties of an EventResponse. */
    interface IEventResponse {

        /** EventResponse eventResponseMessageKey */
        eventResponseMessageKey?: (proto.IMessageKey|null);

        /** EventResponse timestampMs */
        timestampMs?: (number|Long|null);

        /** EventResponse eventResponseMessage */
        eventResponseMessage?: (proto.Message.IEventResponseMessage|null);

        /** EventResponse unread */
        unread?: (boolean|null);
    }

    /** Represents an EventResponse. */
    class EventResponse implements IEventResponse {

        /**
         * Constructs a new EventResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IEventResponse);

        /** EventResponse eventResponseMessageKey. */
        public eventResponseMessageKey?: (proto.IMessageKey|null);

        /** EventResponse timestampMs. */
        public timestampMs: (number|Long);

        /** EventResponse eventResponseMessage. */
        public eventResponseMessage?: (proto.Message.IEventResponseMessage|null);

        /** EventResponse unread. */
        public unread: boolean;

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

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

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

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

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

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

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

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

    /** Properties of an ExitCode. */
    interface IExitCode {

        /** ExitCode code */
        code?: (number|Long|null);

        /** ExitCode text */
        text?: (string|null);
    }

    /** Represents an ExitCode. */
    class ExitCode implements IExitCode {

        /**
         * Constructs a new ExitCode.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IExitCode);

        /** ExitCode code. */
        public code: (number|Long);

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

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

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

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

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

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

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

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

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

    /** Properties of an ExternalBlobReference. */
    interface IExternalBlobReference {

        /** ExternalBlobReference mediaKey */
        mediaKey?: (Uint8Array|null);

        /** ExternalBlobReference directPath */
        directPath?: (string|null);

        /** ExternalBlobReference handle */
        handle?: (string|null);

        /** ExternalBlobReference fileSizeBytes */
        fileSizeBytes?: (number|Long|null);

        /** ExternalBlobReference fileSha256 */
        fileSha256?: (Uint8Array|null);

        /** ExternalBlobReference fileEncSha256 */
        fileEncSha256?: (Uint8Array|null);
    }

    /** Represents an ExternalBlobReference. */
    class ExternalBlobReference implements IExternalBlobReference {

        /**
         * Constructs a new ExternalBlobReference.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IExternalBlobReference);

        /** ExternalBlobReference mediaKey. */
        public mediaKey: Uint8Array;

        /** ExternalBlobReference directPath. */
        public directPath: string;

        /** ExternalBlobReference handle. */
        public handle: string;

        /** ExternalBlobReference fileSizeBytes. */
        public fileSizeBytes: (number|Long);

        /** ExternalBlobReference fileSha256. */
        public fileSha256: Uint8Array;

        /** ExternalBlobReference fileEncSha256. */
        public fileEncSha256: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of a GlobalSettings. */
    interface IGlobalSettings {

        /** GlobalSettings lightThemeWallpaper */
        lightThemeWallpaper?: (proto.IWallpaperSettings|null);

        /** GlobalSettings mediaVisibility */
        mediaVisibility?: (proto.MediaVisibility|null);

        /** GlobalSettings darkThemeWallpaper */
        darkThemeWallpaper?: (proto.IWallpaperSettings|null);

        /** GlobalSettings autoDownloadWiFi */
        autoDownloadWiFi?: (proto.IAutoDownloadSettings|null);

        /** GlobalSettings autoDownloadCellular */
        autoDownloadCellular?: (proto.IAutoDownloadSettings|null);

        /** GlobalSettings autoDownloadRoaming */
        autoDownloadRoaming?: (proto.IAutoDownloadSettings|null);

        /** GlobalSettings showIndividualNotificationsPreview */
        showIndividualNotificationsPreview?: (boolean|null);

        /** GlobalSettings showGroupNotificationsPreview */
        showGroupNotificationsPreview?: (boolean|null);

        /** GlobalSettings disappearingModeDuration */
        disappearingModeDuration?: (number|null);

        /** GlobalSettings disappearingModeTimestamp */
        disappearingModeTimestamp?: (number|Long|null);

        /** GlobalSettings avatarUserSettings */
        avatarUserSettings?: (proto.IAvatarUserSettings|null);

        /** GlobalSettings fontSize */
        fontSize?: (number|null);

        /** GlobalSettings securityNotifications */
        securityNotifications?: (boolean|null);

        /** GlobalSettings autoUnarchiveChats */
        autoUnarchiveChats?: (boolean|null);

        /** GlobalSettings videoQualityMode */
        videoQualityMode?: (number|null);

        /** GlobalSettings photoQualityMode */
        photoQualityMode?: (number|null);

        /** GlobalSettings individualNotificationSettings */
        individualNotificationSettings?: (proto.INotificationSettings|null);

        /** GlobalSettings groupNotificationSettings */
        groupNotificationSettings?: (proto.INotificationSettings|null);
    }

    /** Represents a GlobalSettings. */
    class GlobalSettings implements IGlobalSettings {

        /**
         * Constructs a new GlobalSettings.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IGlobalSettings);

        /** GlobalSettings lightThemeWallpaper. */
        public lightThemeWallpaper?: (proto.IWallpaperSettings|null);

        /** GlobalSettings mediaVisibility. */
        public mediaVisibility: proto.MediaVisibility;

        /** GlobalSettings darkThemeWallpaper. */
        public darkThemeWallpaper?: (proto.IWallpaperSettings|null);

        /** GlobalSettings autoDownloadWiFi. */
        public autoDownloadWiFi?: (proto.IAutoDownloadSettings|null);

        /** GlobalSettings autoDownloadCellular. */
        public autoDownloadCellular?: (proto.IAutoDownloadSettings|null);

        /** GlobalSettings autoDownloadRoaming. */
        public autoDownloadRoaming?: (proto.IAutoDownloadSettings|null);

        /** GlobalSettings showIndividualNotificationsPreview. */
        public showIndividualNotificationsPreview: boolean;

        /** GlobalSettings showGroupNotificationsPreview. */
        public showGroupNotificationsPreview: boolean;

        /** GlobalSettings disappearingModeDuration. */
        public disappearingModeDuration: number;

        /** GlobalSettings disappearingModeTimestamp. */
        public disappearingModeTimestamp: (number|Long);

        /** GlobalSettings avatarUserSettings. */
        public avatarUserSettings?: (proto.IAvatarUserSettings|null);

        /** GlobalSettings fontSize. */
        public fontSize: number;

        /** GlobalSettings securityNotifications. */
        public securityNotifications: boolean;

        /** GlobalSettings autoUnarchiveChats. */
        public autoUnarchiveChats: boolean;

        /** GlobalSettings videoQualityMode. */
        public videoQualityMode: number;

        /** GlobalSettings photoQualityMode. */
        public photoQualityMode: number;

        /** GlobalSettings individualNotificationSettings. */
        public individualNotificationSettings?: (proto.INotificationSettings|null);

        /** GlobalSettings groupNotificationSettings. */
        public groupNotificationSettings?: (proto.INotificationSettings|null);

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

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

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

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

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

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

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

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

    /** Properties of a GroupMention. */
    interface IGroupMention {

        /** GroupMention groupJid */
        groupJid?: (string|null);

        /** GroupMention groupSubject */
        groupSubject?: (string|null);
    }

    /** Represents a GroupMention. */
    class GroupMention implements IGroupMention {

        /**
         * Constructs a new GroupMention.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IGroupMention);

        /** GroupMention groupJid. */
        public groupJid: string;

        /** GroupMention groupSubject. */
        public groupSubject: string;

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

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

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

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

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

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

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

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

    /** Properties of a GroupParticipant. */
    interface IGroupParticipant {

        /** GroupParticipant userJid */
        userJid: string;

        /** GroupParticipant rank */
        rank?: (proto.GroupParticipant.Rank|null);
    }

    /** Represents a GroupParticipant. */
    class GroupParticipant implements IGroupParticipant {

        /**
         * Constructs a new GroupParticipant.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IGroupParticipant);

        /** GroupParticipant userJid. */
        public userJid: string;

        /** GroupParticipant rank. */
        public rank: proto.GroupParticipant.Rank;

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

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

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

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

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

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

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

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

    namespace GroupParticipant {

        /** Rank enum. */
        enum Rank {
            REGULAR = 0,
            ADMIN = 1,
            SUPERADMIN = 2
        }
    }

    /** Properties of a HandshakeMessage. */
    interface IHandshakeMessage {

        /** HandshakeMessage clientHello */
        clientHello?: (proto.HandshakeMessage.IClientHello|null);

        /** HandshakeMessage serverHello */
        serverHello?: (proto.HandshakeMessage.IServerHello|null);

        /** HandshakeMessage clientFinish */
        clientFinish?: (proto.HandshakeMessage.IClientFinish|null);
    }

    /** Represents a HandshakeMessage. */
    class HandshakeMessage implements IHandshakeMessage {

        /**
         * Constructs a new HandshakeMessage.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IHandshakeMessage);

        /** HandshakeMessage clientHello. */
        public clientHello?: (proto.HandshakeMessage.IClientHello|null);

        /** HandshakeMessage serverHello. */
        public serverHello?: (proto.HandshakeMessage.IServerHello|null);

        /** HandshakeMessage clientFinish. */
        public clientFinish?: (proto.HandshakeMessage.IClientFinish|null);

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

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

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

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

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

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

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

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

    namespace HandshakeMessage {

        /** Properties of a ClientFinish. */
        interface IClientFinish {

            /** ClientFinish static */
            "static"?: (Uint8Array|null);

            /** ClientFinish payload */
            payload?: (Uint8Array|null);
        }

        /** Represents a ClientFinish. */
        class ClientFinish implements IClientFinish {

            /**
             * Constructs a new ClientFinish.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.HandshakeMessage.IClientFinish);

            /** ClientFinish static. */
            public static: Uint8Array;

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

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

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

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

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

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

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

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

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

        /** Properties of a ClientHello. */
        interface IClientHello {

            /** ClientHello ephemeral */
            ephemeral?: (Uint8Array|null);

            /** ClientHello static */
            "static"?: (Uint8Array|null);

            /** ClientHello payload */
            payload?: (Uint8Array|null);
        }

        /** Represents a ClientHello. */
        class ClientHello implements IClientHello {

            /**
             * Constructs a new ClientHello.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.HandshakeMessage.IClientHello);

            /** ClientHello ephemeral. */
            public ephemeral: Uint8Array;

            /** ClientHello static. */
            public static: Uint8Array;

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

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

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

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

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

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

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

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

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

        /** Properties of a ServerHello. */
        interface IServerHello {

            /** ServerHello ephemeral */
            ephemeral?: (Uint8Array|null);

            /** ServerHello static */
            "static"?: (Uint8Array|null);

            /** ServerHello payload */
            payload?: (Uint8Array|null);
        }

        /** Represents a ServerHello. */
        class ServerHello implements IServerHello {

            /**
             * Constructs a new ServerHello.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.HandshakeMessage.IServerHello);

            /** ServerHello ephemeral. */
            public ephemeral: Uint8Array;

            /** ServerHello static. */
            public static: Uint8Array;

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

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

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

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

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

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

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

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

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

    /** Properties of a HistorySync. */
    interface IHistorySync {

        /** HistorySync syncType */
        syncType: proto.HistorySync.HistorySyncType;

        /** HistorySync conversations */
        conversations?: (proto.IConversation[]|null);

        /** HistorySync statusV3Messages */
        statusV3Messages?: (proto.IWebMessageInfo[]|null);

        /** HistorySync chunkOrder */
        chunkOrder?: (number|null);

        /** HistorySync progress */
        progress?: (number|null);

        /** HistorySync pushnames */
        pushnames?: (proto.IPushname[]|null);

        /** HistorySync globalSettings */
        globalSettings?: (proto.IGlobalSettings|null);

        /** HistorySync threadIdUserSecret */
        threadIdUserSecret?: (Uint8Array|null);

        /** HistorySync threadDsTimeframeOffset */
        threadDsTimeframeOffset?: (number|null);

        /** HistorySync recentStickers */
        recentStickers?: (proto.IStickerMetadata[]|null);

        /** HistorySync pastParticipants */
        pastParticipants?: (proto.IPastParticipants[]|null);

        /** HistorySync callLogRecords */
        callLogRecords?: (proto.ICallLogRecord[]|null);

        /** HistorySync aiWaitListState */
        aiWaitListState?: (proto.HistorySync.BotAIWaitListState|null);

        /** HistorySync phoneNumberToLidMappings */
        phoneNumberToLidMappings?: (proto.IPhoneNumberToLIDMapping[]|null);
    }

    /** Represents a HistorySync. */
    class HistorySync implements IHistorySync {

        /**
         * Constructs a new HistorySync.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IHistorySync);

        /** HistorySync syncType. */
        public syncType: proto.HistorySync.HistorySyncType;

        /** HistorySync conversations. */
        public conversations: proto.IConversation[];

        /** HistorySync statusV3Messages. */
        public statusV3Messages: proto.IWebMessageInfo[];

        /** HistorySync chunkOrder. */
        public chunkOrder: number;

        /** HistorySync progress. */
        public progress: number;

        /** HistorySync pushnames. */
        public pushnames: proto.IPushname[];

        /** HistorySync globalSettings. */
        public globalSettings?: (proto.IGlobalSettings|null);

        /** HistorySync threadIdUserSecret. */
        public threadIdUserSecret: Uint8Array;

        /** HistorySync threadDsTimeframeOffset. */
        public threadDsTimeframeOffset: number;

        /** HistorySync recentStickers. */
        public recentStickers: proto.IStickerMetadata[];

        /** HistorySync pastParticipants. */
        public pastParticipants: proto.IPastParticipants[];

        /** HistorySync callLogRecords. */
        public callLogRecords: proto.ICallLogRecord[];

        /** HistorySync aiWaitListState. */
        public aiWaitListState: proto.HistorySync.BotAIWaitListState;

        /** HistorySync phoneNumberToLidMappings. */
        public phoneNumberToLidMappings: proto.IPhoneNumberToLIDMapping[];

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

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

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

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

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

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

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

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

    namespace HistorySync {

        /** BotAIWaitListState enum. */
        enum BotAIWaitListState {
            IN_WAITLIST = 0,
            AI_AVAILABLE = 1
        }

        /** HistorySyncType enum. */
        enum HistorySyncType {
            INITIAL_BOOTSTRAP = 0,
            INITIAL_STATUS_V3 = 1,
            FULL = 2,
            RECENT = 3,
            PUSH_NAME = 4,
            NON_BLOCKING_DATA = 5,
            ON_DEMAND = 6
        }
    }

    /** Properties of a HistorySyncMsg. */
    interface IHistorySyncMsg {

        /** HistorySyncMsg message */
        message?: (proto.IWebMessageInfo|null);

        /** HistorySyncMsg msgOrderId */
        msgOrderId?: (number|Long|null);
    }

    /** Represents a HistorySyncMsg. */
    class HistorySyncMsg implements IHistorySyncMsg {

        /**
         * Constructs a new HistorySyncMsg.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IHistorySyncMsg);

        /** HistorySyncMsg message. */
        public message?: (proto.IWebMessageInfo|null);

        /** HistorySyncMsg msgOrderId. */
        public msgOrderId: (number|Long);

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

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

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

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

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

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

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

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

    /** Properties of a HydratedTemplateButton. */
    interface IHydratedTemplateButton {

        /** HydratedTemplateButton index */
        index?: (number|null);

        /** HydratedTemplateButton quickReplyButton */
        quickReplyButton?: (proto.HydratedTemplateButton.IHydratedQuickReplyButton|null);

        /** HydratedTemplateButton urlButton */
        urlButton?: (proto.HydratedTemplateButton.IHydratedURLButton|null);

        /** HydratedTemplateButton callButton */
        callButton?: (proto.HydratedTemplateButton.IHydratedCallButton|null);
    }

    /** Represents a HydratedTemplateButton. */
    class HydratedTemplateButton implements IHydratedTemplateButton {

        /**
         * Constructs a new HydratedTemplateButton.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IHydratedTemplateButton);

        /** HydratedTemplateButton index. */
        public index: number;

        /** HydratedTemplateButton quickReplyButton. */
        public quickReplyButton?: (proto.HydratedTemplateButton.IHydratedQuickReplyButton|null);

        /** HydratedTemplateButton urlButton. */
        public urlButton?: (proto.HydratedTemplateButton.IHydratedURLButton|null);

        /** HydratedTemplateButton callButton. */
        public callButton?: (proto.HydratedTemplateButton.IHydratedCallButton|null);

        /** HydratedTemplateButton hydratedButton. */
        public hydratedButton?: ("quickReplyButton"|"urlButton"|"callButton");

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

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

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

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

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

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

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

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

    namespace HydratedTemplateButton {

        /** Properties of a HydratedCallButton. */
        interface IHydratedCallButton {

            /** HydratedCallButton displayText */
            displayText?: (string|null);

            /** HydratedCallButton phoneNumber */
            phoneNumber?: (string|null);
        }

        /** Represents a HydratedCallButton. */
        class HydratedCallButton implements IHydratedCallButton {

            /**
             * Constructs a new HydratedCallButton.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.HydratedTemplateButton.IHydratedCallButton);

            /** HydratedCallButton displayText. */
            public displayText: string;

            /** HydratedCallButton phoneNumber. */
            public phoneNumber: string;

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

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

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

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

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

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

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

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

        /** Properties of a HydratedQuickReplyButton. */
        interface IHydratedQuickReplyButton {

            /** HydratedQuickReplyButton displayText */
            displayText?: (string|null);

            /** HydratedQuickReplyButton id */
            id?: (string|null);
        }

        /** Represents a HydratedQuickReplyButton. */
        class HydratedQuickReplyButton implements IHydratedQuickReplyButton {

            /**
             * Constructs a new HydratedQuickReplyButton.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.HydratedTemplateButton.IHydratedQuickReplyButton);

            /** HydratedQuickReplyButton displayText. */
            public displayText: string;

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

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

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

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

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

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

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

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

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

        /** Properties of a HydratedURLButton. */
        interface IHydratedURLButton {

            /** HydratedURLButton displayText */
            displayText?: (string|null);

            /** HydratedURLButton url */
            url?: (string|null);

            /** HydratedURLButton consentedUsersUrl */
            consentedUsersUrl?: (string|null);

            /** HydratedURLButton webviewPresentation */
            webviewPresentation?: (proto.HydratedTemplateButton.HydratedURLButton.WebviewPresentationType|null);
        }

        /** Represents a HydratedURLButton. */
        class HydratedURLButton implements IHydratedURLButton {

            /**
             * Constructs a new HydratedURLButton.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.HydratedTemplateButton.IHydratedURLButton);

            /** HydratedURLButton displayText. */
            public displayText: string;

            /** HydratedURLButton url. */
            public url: string;

            /** HydratedURLButton consentedUsersUrl. */
            public consentedUsersUrl: string;

            /** HydratedURLButton webviewPresentation. */
            public webviewPresentation: proto.HydratedTemplateButton.HydratedURLButton.WebviewPresentationType;

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

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

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

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

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

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

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

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

        namespace HydratedURLButton {

            /** WebviewPresentationType enum. */
            enum WebviewPresentationType {
                FULL = 1,
                TALL = 2,
                COMPACT = 3
            }
        }
    }

    /** Properties of an IdentityKeyPairStructure. */
    interface IIdentityKeyPairStructure {

        /** IdentityKeyPairStructure publicKey */
        publicKey?: (Uint8Array|null);

        /** IdentityKeyPairStructure privateKey */
        privateKey?: (Uint8Array|null);
    }

    /** Represents an IdentityKeyPairStructure. */
    class IdentityKeyPairStructure implements IIdentityKeyPairStructure {

        /**
         * Constructs a new IdentityKeyPairStructure.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IIdentityKeyPairStructure);

        /** IdentityKeyPairStructure publicKey. */
        public publicKey: Uint8Array;

        /** IdentityKeyPairStructure privateKey. */
        public privateKey: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of an InteractiveAnnotation. */
    interface IInteractiveAnnotation {

        /** InteractiveAnnotation polygonVertices */
        polygonVertices?: (proto.IPoint[]|null);

        /** InteractiveAnnotation shouldSkipConfirmation */
        shouldSkipConfirmation?: (boolean|null);

        /** InteractiveAnnotation location */
        location?: (proto.ILocation|null);

        /** InteractiveAnnotation newsletter */
        newsletter?: (proto.ContextInfo.IForwardedNewsletterMessageInfo|null);
    }

    /** Represents an InteractiveAnnotation. */
    class InteractiveAnnotation implements IInteractiveAnnotation {

        /**
         * Constructs a new InteractiveAnnotation.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IInteractiveAnnotation);

        /** InteractiveAnnotation polygonVertices. */
        public polygonVertices: proto.IPoint[];

        /** InteractiveAnnotation shouldSkipConfirmation. */
        public shouldSkipConfirmation: boolean;

        /** InteractiveAnnotation location. */
        public location?: (proto.ILocation|null);

        /** InteractiveAnnotation newsletter. */
        public newsletter?: (proto.ContextInfo.IForwardedNewsletterMessageInfo|null);

        /** InteractiveAnnotation action. */
        public action?: ("location"|"newsletter");

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

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

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

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

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

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

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

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

    /** Properties of a KeepInChat. */
    interface IKeepInChat {

        /** KeepInChat keepType */
        keepType?: (proto.KeepType|null);

        /** KeepInChat serverTimestamp */
        serverTimestamp?: (number|Long|null);

        /** KeepInChat key */
        key?: (proto.IMessageKey|null);

        /** KeepInChat deviceJid */
        deviceJid?: (string|null);

        /** KeepInChat clientTimestampMs */
        clientTimestampMs?: (number|Long|null);

        /** KeepInChat serverTimestampMs */
        serverTimestampMs?: (number|Long|null);
    }

    /** Represents a KeepInChat. */
    class KeepInChat implements IKeepInChat {

        /**
         * Constructs a new KeepInChat.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IKeepInChat);

        /** KeepInChat keepType. */
        public keepType: proto.KeepType;

        /** KeepInChat serverTimestamp. */
        public serverTimestamp: (number|Long);

        /** KeepInChat key. */
        public key?: (proto.IMessageKey|null);

        /** KeepInChat deviceJid. */
        public deviceJid: string;

        /** KeepInChat clientTimestampMs. */
        public clientTimestampMs: (number|Long);

        /** KeepInChat serverTimestampMs. */
        public serverTimestampMs: (number|Long);

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

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

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

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

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

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

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

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

    /** KeepType enum. */
    enum KeepType {
        UNKNOWN = 0,
        KEEP_FOR_ALL = 1,
        UNDO_KEEP_FOR_ALL = 2
    }

    /** Properties of a KeyExchangeMessage. */
    interface IKeyExchangeMessage {

        /** KeyExchangeMessage id */
        id?: (number|null);

        /** KeyExchangeMessage baseKey */
        baseKey?: (Uint8Array|null);

        /** KeyExchangeMessage ratchetKey */
        ratchetKey?: (Uint8Array|null);

        /** KeyExchangeMessage identityKey */
        identityKey?: (Uint8Array|null);

        /** KeyExchangeMessage baseKeySignature */
        baseKeySignature?: (Uint8Array|null);
    }

    /** Represents a KeyExchangeMessage. */
    class KeyExchangeMessage implements IKeyExchangeMessage {

        /**
         * Constructs a new KeyExchangeMessage.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IKeyExchangeMessage);

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

        /** KeyExchangeMessage baseKey. */
        public baseKey: Uint8Array;

        /** KeyExchangeMessage ratchetKey. */
        public ratchetKey: Uint8Array;

        /** KeyExchangeMessage identityKey. */
        public identityKey: Uint8Array;

        /** KeyExchangeMessage baseKeySignature. */
        public baseKeySignature: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of a KeyId. */
    interface IKeyId {

        /** KeyId id */
        id?: (Uint8Array|null);
    }

    /** Represents a KeyId. */
    class KeyId implements IKeyId {

        /**
         * Constructs a new KeyId.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IKeyId);

        /** KeyId id. */
        public id: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of a LocalizedName. */
    interface ILocalizedName {

        /** LocalizedName lg */
        lg?: (string|null);

        /** LocalizedName lc */
        lc?: (string|null);

        /** LocalizedName verifiedName */
        verifiedName?: (string|null);
    }

    /** Represents a LocalizedName. */
    class LocalizedName implements ILocalizedName {

        /**
         * Constructs a new LocalizedName.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ILocalizedName);

        /** LocalizedName lg. */
        public lg: string;

        /** LocalizedName lc. */
        public lc: string;

        /** LocalizedName verifiedName. */
        public verifiedName: string;

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

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

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

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

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

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

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

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

    /** Properties of a Location. */
    interface ILocation {

        /** Location degreesLatitude */
        degreesLatitude?: (number|null);

        /** Location degreesLongitude */
        degreesLongitude?: (number|null);

        /** Location name */
        name?: (string|null);
    }

    /** Represents a Location. */
    class Location implements ILocation {

        /**
         * Constructs a new Location.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ILocation);

        /** Location degreesLatitude. */
        public degreesLatitude: number;

        /** Location degreesLongitude. */
        public degreesLongitude: number;

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

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

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

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

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

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

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

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

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

    /** Properties of a MediaData. */
    interface IMediaData {

        /** MediaData localPath */
        localPath?: (string|null);
    }

    /** Represents a MediaData. */
    class MediaData implements IMediaData {

        /**
         * Constructs a new MediaData.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IMediaData);

        /** MediaData localPath. */
        public localPath: string;

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

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

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

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

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

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

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

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

    /** Properties of a MediaEntry. */
    interface IMediaEntry {

        /** MediaEntry fileSha256 */
        fileSha256?: (Uint8Array|null);

        /** MediaEntry mediaKey */
        mediaKey?: (Uint8Array|null);

        /** MediaEntry fileEncSha256 */
        fileEncSha256?: (Uint8Array|null);

        /** MediaEntry directPath */
        directPath?: (string|null);

        /** MediaEntry mediaKeyTimestamp */
        mediaKeyTimestamp?: (number|Long|null);

        /** MediaEntry serverMediaType */
        serverMediaType?: (string|null);

        /** MediaEntry uploadToken */
        uploadToken?: (Uint8Array|null);

        /** MediaEntry validatedTimestamp */
        validatedTimestamp?: (Uint8Array|null);

        /** MediaEntry sidecar */
        sidecar?: (Uint8Array|null);

        /** MediaEntry objectId */
        objectId?: (string|null);

        /** MediaEntry fbid */
        fbid?: (string|null);

        /** MediaEntry downloadableThumbnail */
        downloadableThumbnail?: (proto.MediaEntry.IDownloadableThumbnail|null);

        /** MediaEntry handle */
        handle?: (string|null);

        /** MediaEntry filename */
        filename?: (string|null);

        /** MediaEntry progressiveJpegDetails */
        progressiveJpegDetails?: (proto.MediaEntry.IProgressiveJpegDetails|null);
    }

    /** Represents a MediaEntry. */
    class MediaEntry implements IMediaEntry {

        /**
         * Constructs a new MediaEntry.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IMediaEntry);

        /** MediaEntry fileSha256. */
        public fileSha256: Uint8Array;

        /** MediaEntry mediaKey. */
        public mediaKey: Uint8Array;

        /** MediaEntry fileEncSha256. */
        public fileEncSha256: Uint8Array;

        /** MediaEntry directPath. */
        public directPath: string;

        /** MediaEntry mediaKeyTimestamp. */
        public mediaKeyTimestamp: (number|Long);

        /** MediaEntry serverMediaType. */
        public serverMediaType: string;

        /** MediaEntry uploadToken. */
        public uploadToken: Uint8Array;

        /** MediaEntry validatedTimestamp. */
        public validatedTimestamp: Uint8Array;

        /** MediaEntry sidecar. */
        public sidecar: Uint8Array;

        /** MediaEntry objectId. */
        public objectId: string;

        /** MediaEntry fbid. */
        public fbid: string;

        /** MediaEntry downloadableThumbnail. */
        public downloadableThumbnail?: (proto.MediaEntry.IDownloadableThumbnail|null);

        /** MediaEntry handle. */
        public handle: string;

        /** MediaEntry filename. */
        public filename: string;

        /** MediaEntry progressiveJpegDetails. */
        public progressiveJpegDetails?: (proto.MediaEntry.IProgressiveJpegDetails|null);

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

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

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

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

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

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

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

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

    namespace MediaEntry {

        /** Properties of a DownloadableThumbnail. */
        interface IDownloadableThumbnail {

            /** DownloadableThumbnail fileSha256 */
            fileSha256?: (Uint8Array|null);

            /** DownloadableThumbnail fileEncSha256 */
            fileEncSha256?: (Uint8Array|null);

            /** DownloadableThumbnail directPath */
            directPath?: (string|null);

            /** DownloadableThumbnail mediaKey */
            mediaKey?: (Uint8Array|null);

            /** DownloadableThumbnail mediaKeyTimestamp */
            mediaKeyTimestamp?: (number|Long|null);

            /** DownloadableThumbnail objectId */
            objectId?: (string|null);
        }

        /** Represents a DownloadableThumbnail. */
        class DownloadableThumbnail implements IDownloadableThumbnail {

            /**
             * Constructs a new DownloadableThumbnail.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.MediaEntry.IDownloadableThumbnail);

            /** DownloadableThumbnail fileSha256. */
            public fileSha256: Uint8Array;

            /** DownloadableThumbnail fileEncSha256. */
            public fileEncSha256: Uint8Array;

            /** DownloadableThumbnail directPath. */
            public directPath: string;

            /** DownloadableThumbnail mediaKey. */
            public mediaKey: Uint8Array;

            /** DownloadableThumbnail mediaKeyTimestamp. */
            public mediaKeyTimestamp: (number|Long);

            /** DownloadableThumbnail objectId. */
            public objectId: string;

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

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

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

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

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

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

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

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

        /** Properties of a ProgressiveJpegDetails. */
        interface IProgressiveJpegDetails {

            /** ProgressiveJpegDetails scanLengths */
            scanLengths?: ((number|Long)[]|null);

            /** ProgressiveJpegDetails sidecar */
            sidecar?: (Uint8Array|null);
        }

        /** Represents a ProgressiveJpegDetails. */
        class ProgressiveJpegDetails implements IProgressiveJpegDetails {

            /**
             * Constructs a new ProgressiveJpegDetails.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.MediaEntry.IProgressiveJpegDetails);

            /** ProgressiveJpegDetails scanLengths. */
            public scanLengths: (number|Long)[];

            /** ProgressiveJpegDetails sidecar. */
            public sidecar: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of a MediaNotifyMessage. */
    interface IMediaNotifyMessage {

        /** MediaNotifyMessage expressPathUrl */
        expressPathUrl?: (string|null);

        /** MediaNotifyMessage fileEncSha256 */
        fileEncSha256?: (Uint8Array|null);

        /** MediaNotifyMessage fileLength */
        fileLength?: (number|Long|null);
    }

    /** Represents a MediaNotifyMessage. */
    class MediaNotifyMessage implements IMediaNotifyMessage {

        /**
         * Constructs a new MediaNotifyMessage.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IMediaNotifyMessage);

        /** MediaNotifyMessage expressPathUrl. */
        public expressPathUrl: string;

        /** MediaNotifyMessage fileEncSha256. */
        public fileEncSha256: Uint8Array;

        /** MediaNotifyMessage fileLength. */
        public fileLength: (number|Long);

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

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

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

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

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

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

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

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

    /** Properties of a MediaRetryNotification. */
    interface IMediaRetryNotification {

        /** MediaRetryNotification stanzaId */
        stanzaId?: (string|null);

        /** MediaRetryNotification directPath */
        directPath?: (string|null);

        /** MediaRetryNotification result */
        result?: (proto.MediaRetryNotification.ResultType|null);
    }

    /** Represents a MediaRetryNotification. */
    class MediaRetryNotification implements IMediaRetryNotification {

        /**
         * Constructs a new MediaRetryNotification.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IMediaRetryNotification);

        /** MediaRetryNotification stanzaId. */
        public stanzaId: string;

        /** MediaRetryNotification directPath. */
        public directPath: string;

        /** MediaRetryNotification result. */
        public result: proto.MediaRetryNotification.ResultType;

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

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

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

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

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

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

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

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

    namespace MediaRetryNotification {

        /** ResultType enum. */
        enum ResultType {
            GENERAL_ERROR = 0,
            SUCCESS = 1,
            NOT_FOUND = 2,
            DECRYPTION_ERROR = 3
        }
    }

    /** MediaVisibility enum. */
    enum MediaVisibility {
        DEFAULT = 0,
        OFF = 1,
        ON = 2
    }

    /** Properties of a Message. */
    interface IMessage {

        /** Message conversation */
        conversation?: (string|null);

        /** Message senderKeyDistributionMessage */
        senderKeyDistributionMessage?: (proto.Message.ISenderKeyDistributionMessage|null);

        /** Message imageMessage */
        imageMessage?: (proto.Message.IImageMessage|null);

        /** Message contactMessage */
        contactMessage?: (proto.Message.IContactMessage|null);

        /** Message locationMessage */
        locationMessage?: (proto.Message.ILocationMessage|null);

        /** Message extendedTextMessage */
        extendedTextMessage?: (proto.Message.IExtendedTextMessage|null);

        /** Message documentMessage */
        documentMessage?: (proto.Message.IDocumentMessage|null);

        /** Message audioMessage */
        audioMessage?: (proto.Message.IAudioMessage|null);

        /** Message videoMessage */
        videoMessage?: (proto.Message.IVideoMessage|null);

        /** Message call */
        call?: (proto.Message.ICall|null);

        /** Message chat */
        chat?: (proto.Message.IChat|null);

        /** Message protocolMessage */
        protocolMessage?: (proto.Message.IProtocolMessage|null);

        /** Message contactsArrayMessage */
        contactsArrayMessage?: (proto.Message.IContactsArrayMessage|null);

        /** Message highlyStructuredMessage */
        highlyStructuredMessage?: (proto.Message.IHighlyStructuredMessage|null);

        /** Message fastRatchetKeySenderKeyDistributionMessage */
        fastRatchetKeySenderKeyDistributionMessage?: (proto.Message.ISenderKeyDistributionMessage|null);

        /** Message sendPaymentMessage */
        sendPaymentMessage?: (proto.Message.ISendPaymentMessage|null);

        /** Message liveLocationMessage */
        liveLocationMessage?: (proto.Message.ILiveLocationMessage|null);

        /** Message requestPaymentMessage */
        requestPaymentMessage?: (proto.Message.IRequestPaymentMessage|null);

        /** Message declinePaymentRequestMessage */
        declinePaymentRequestMessage?: (proto.Message.IDeclinePaymentRequestMessage|null);

        /** Message cancelPaymentRequestMessage */
        cancelPaymentRequestMessage?: (proto.Message.ICancelPaymentRequestMessage|null);

        /** Message templateMessage */
        templateMessage?: (proto.Message.ITemplateMessage|null);

        /** Message stickerMessage */
        stickerMessage?: (proto.Message.IStickerMessage|null);

        /** Message groupInviteMessage */
        groupInviteMessage?: (proto.Message.IGroupInviteMessage|null);

        /** Message templateButtonReplyMessage */
        templateButtonReplyMessage?: (proto.Message.ITemplateButtonReplyMessage|null);

        /** Message productMessage */
        productMessage?: (proto.Message.IProductMessage|null);

        /** Message deviceSentMessage */
        deviceSentMessage?: (proto.Message.IDeviceSentMessage|null);

        /** Message messageContextInfo */
        messageContextInfo?: (proto.IMessageContextInfo|null);

        /** Message listMessage */
        listMessage?: (proto.Message.IListMessage|null);

        /** Message viewOnceMessage */
        viewOnceMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message orderMessage */
        orderMessage?: (proto.Message.IOrderMessage|null);

        /** Message listResponseMessage */
        listResponseMessage?: (proto.Message.IListResponseMessage|null);

        /** Message ephemeralMessage */
        ephemeralMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message invoiceMessage */
        invoiceMessage?: (proto.Message.IInvoiceMessage|null);

        /** Message buttonsMessage */
        buttonsMessage?: (proto.Message.IButtonsMessage|null);

        /** Message buttonsResponseMessage */
        buttonsResponseMessage?: (proto.Message.IButtonsResponseMessage|null);

        /** Message paymentInviteMessage */
        paymentInviteMessage?: (proto.Message.IPaymentInviteMessage|null);

        /** Message interactiveMessage */
        interactiveMessage?: (proto.Message.IInteractiveMessage|null);

        /** Message reactionMessage */
        reactionMessage?: (proto.Message.IReactionMessage|null);

        /** Message stickerSyncRmrMessage */
        stickerSyncRmrMessage?: (proto.Message.IStickerSyncRMRMessage|null);

        /** Message interactiveResponseMessage */
        interactiveResponseMessage?: (proto.Message.IInteractiveResponseMessage|null);

        /** Message pollCreationMessage */
        pollCreationMessage?: (proto.Message.IPollCreationMessage|null);

        /** Message pollUpdateMessage */
        pollUpdateMessage?: (proto.Message.IPollUpdateMessage|null);

        /** Message keepInChatMessage */
        keepInChatMessage?: (proto.Message.IKeepInChatMessage|null);

        /** Message documentWithCaptionMessage */
        documentWithCaptionMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message requestPhoneNumberMessage */
        requestPhoneNumberMessage?: (proto.Message.IRequestPhoneNumberMessage|null);

        /** Message viewOnceMessageV2 */
        viewOnceMessageV2?: (proto.Message.IFutureProofMessage|null);

        /** Message encReactionMessage */
        encReactionMessage?: (proto.Message.IEncReactionMessage|null);

        /** Message editedMessage */
        editedMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message viewOnceMessageV2Extension */
        viewOnceMessageV2Extension?: (proto.Message.IFutureProofMessage|null);

        /** Message pollCreationMessageV2 */
        pollCreationMessageV2?: (proto.Message.IPollCreationMessage|null);

        /** Message scheduledCallCreationMessage */
        scheduledCallCreationMessage?: (proto.Message.IScheduledCallCreationMessage|null);

        /** Message groupMentionedMessage */
        groupMentionedMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message pinInChatMessage */
        pinInChatMessage?: (proto.Message.IPinInChatMessage|null);

        /** Message pollCreationMessageV3 */
        pollCreationMessageV3?: (proto.Message.IPollCreationMessage|null);

        /** Message scheduledCallEditMessage */
        scheduledCallEditMessage?: (proto.Message.IScheduledCallEditMessage|null);

        /** Message ptvMessage */
        ptvMessage?: (proto.Message.IVideoMessage|null);

        /** Message botInvokeMessage */
        botInvokeMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message callLogMesssage */
        callLogMesssage?: (proto.Message.ICallLogMessage|null);

        /** Message messageHistoryBundle */
        messageHistoryBundle?: (proto.Message.IMessageHistoryBundle|null);

        /** Message encCommentMessage */
        encCommentMessage?: (proto.Message.IEncCommentMessage|null);

        /** Message bcallMessage */
        bcallMessage?: (proto.Message.IBCallMessage|null);

        /** Message lottieStickerMessage */
        lottieStickerMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message eventMessage */
        eventMessage?: (proto.Message.IEventMessage|null);

        /** Message commentMessage */
        commentMessage?: (proto.Message.ICommentMessage|null);

        /** Message newsletterAdminInviteMessage */
        newsletterAdminInviteMessage?: (proto.Message.INewsletterAdminInviteMessage|null);

        /** Message extendedTextMessageWithParentKey */
        extendedTextMessageWithParentKey?: (proto.Message.IExtendedTextMessageWithParentKey|null);

        /** Message placeholderMessage */
        placeholderMessage?: (proto.Message.IPlaceholderMessage|null);

        /** Message encEventUpdateMessage */
        encEventUpdateMessage?: (proto.Message.IEncEventUpdateMessage|null);
    }

    /** Represents a Message. */
    class Message implements IMessage {

        /**
         * Constructs a new Message.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IMessage);

        /** Message conversation. */
        public conversation: string;

        /** Message senderKeyDistributionMessage. */
        public senderKeyDistributionMessage?: (proto.Message.ISenderKeyDistributionMessage|null);

        /** Message imageMessage. */
        public imageMessage?: (proto.Message.IImageMessage|null);

        /** Message contactMessage. */
        public contactMessage?: (proto.Message.IContactMessage|null);

        /** Message locationMessage. */
        public locationMessage?: (proto.Message.ILocationMessage|null);

        /** Message extendedTextMessage. */
        public extendedTextMessage?: (proto.Message.IExtendedTextMessage|null);

        /** Message documentMessage. */
        public documentMessage?: (proto.Message.IDocumentMessage|null);

        /** Message audioMessage. */
        public audioMessage?: (proto.Message.IAudioMessage|null);

        /** Message videoMessage. */
        public videoMessage?: (proto.Message.IVideoMessage|null);

        /** Message call. */
        public call?: (proto.Message.ICall|null);

        /** Message chat. */
        public chat?: (proto.Message.IChat|null);

        /** Message protocolMessage. */
        public protocolMessage?: (proto.Message.IProtocolMessage|null);

        /** Message contactsArrayMessage. */
        public contactsArrayMessage?: (proto.Message.IContactsArrayMessage|null);

        /** Message highlyStructuredMessage. */
        public highlyStructuredMessage?: (proto.Message.IHighlyStructuredMessage|null);

        /** Message fastRatchetKeySenderKeyDistributionMessage. */
        public fastRatchetKeySenderKeyDistributionMessage?: (proto.Message.ISenderKeyDistributionMessage|null);

        /** Message sendPaymentMessage. */
        public sendPaymentMessage?: (proto.Message.ISendPaymentMessage|null);

        /** Message liveLocationMessage. */
        public liveLocationMessage?: (proto.Message.ILiveLocationMessage|null);

        /** Message requestPaymentMessage. */
        public requestPaymentMessage?: (proto.Message.IRequestPaymentMessage|null);

        /** Message declinePaymentRequestMessage. */
        public declinePaymentRequestMessage?: (proto.Message.IDeclinePaymentRequestMessage|null);

        /** Message cancelPaymentRequestMessage. */
        public cancelPaymentRequestMessage?: (proto.Message.ICancelPaymentRequestMessage|null);

        /** Message templateMessage. */
        public templateMessage?: (proto.Message.ITemplateMessage|null);

        /** Message stickerMessage. */
        public stickerMessage?: (proto.Message.IStickerMessage|null);

        /** Message groupInviteMessage. */
        public groupInviteMessage?: (proto.Message.IGroupInviteMessage|null);

        /** Message templateButtonReplyMessage. */
        public templateButtonReplyMessage?: (proto.Message.ITemplateButtonReplyMessage|null);

        /** Message productMessage. */
        public productMessage?: (proto.Message.IProductMessage|null);

        /** Message deviceSentMessage. */
        public deviceSentMessage?: (proto.Message.IDeviceSentMessage|null);

        /** Message messageContextInfo. */
        public messageContextInfo?: (proto.IMessageContextInfo|null);

        /** Message listMessage. */
        public listMessage?: (proto.Message.IListMessage|null);

        /** Message viewOnceMessage. */
        public viewOnceMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message orderMessage. */
        public orderMessage?: (proto.Message.IOrderMessage|null);

        /** Message listResponseMessage. */
        public listResponseMessage?: (proto.Message.IListResponseMessage|null);

        /** Message ephemeralMessage. */
        public ephemeralMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message invoiceMessage. */
        public invoiceMessage?: (proto.Message.IInvoiceMessage|null);

        /** Message buttonsMessage. */
        public buttonsMessage?: (proto.Message.IButtonsMessage|null);

        /** Message buttonsResponseMessage. */
        public buttonsResponseMessage?: (proto.Message.IButtonsResponseMessage|null);

        /** Message paymentInviteMessage. */
        public paymentInviteMessage?: (proto.Message.IPaymentInviteMessage|null);

        /** Message interactiveMessage. */
        public interactiveMessage?: (proto.Message.IInteractiveMessage|null);

        /** Message reactionMessage. */
        public reactionMessage?: (proto.Message.IReactionMessage|null);

        /** Message stickerSyncRmrMessage. */
        public stickerSyncRmrMessage?: (proto.Message.IStickerSyncRMRMessage|null);

        /** Message interactiveResponseMessage. */
        public interactiveResponseMessage?: (proto.Message.IInteractiveResponseMessage|null);

        /** Message pollCreationMessage. */
        public pollCreationMessage?: (proto.Message.IPollCreationMessage|null);

        /** Message pollUpdateMessage. */
        public pollUpdateMessage?: (proto.Message.IPollUpdateMessage|null);

        /** Message keepInChatMessage. */
        public keepInChatMessage?: (proto.Message.IKeepInChatMessage|null);

        /** Message documentWithCaptionMessage. */
        public documentWithCaptionMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message requestPhoneNumberMessage. */
        public requestPhoneNumberMessage?: (proto.Message.IRequestPhoneNumberMessage|null);

        /** Message viewOnceMessageV2. */
        public viewOnceMessageV2?: (proto.Message.IFutureProofMessage|null);

        /** Message encReactionMessage. */
        public encReactionMessage?: (proto.Message.IEncReactionMessage|null);

        /** Message editedMessage. */
        public editedMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message viewOnceMessageV2Extension. */
        public viewOnceMessageV2Extension?: (proto.Message.IFutureProofMessage|null);

        /** Message pollCreationMessageV2. */
        public pollCreationMessageV2?: (proto.Message.IPollCreationMessage|null);

        /** Message scheduledCallCreationMessage. */
        public scheduledCallCreationMessage?: (proto.Message.IScheduledCallCreationMessage|null);

        /** Message groupMentionedMessage. */
        public groupMentionedMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message pinInChatMessage. */
        public pinInChatMessage?: (proto.Message.IPinInChatMessage|null);

        /** Message pollCreationMessageV3. */
        public pollCreationMessageV3?: (proto.Message.IPollCreationMessage|null);

        /** Message scheduledCallEditMessage. */
        public scheduledCallEditMessage?: (proto.Message.IScheduledCallEditMessage|null);

        /** Message ptvMessage. */
        public ptvMessage?: (proto.Message.IVideoMessage|null);

        /** Message botInvokeMessage. */
        public botInvokeMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message callLogMesssage. */
        public callLogMesssage?: (proto.Message.ICallLogMessage|null);

        /** Message messageHistoryBundle. */
        public messageHistoryBundle?: (proto.Message.IMessageHistoryBundle|null);

        /** Message encCommentMessage. */
        public encCommentMessage?: (proto.Message.IEncCommentMessage|null);

        /** Message bcallMessage. */
        public bcallMessage?: (proto.Message.IBCallMessage|null);

        /** Message lottieStickerMessage. */
        public lottieStickerMessage?: (proto.Message.IFutureProofMessage|null);

        /** Message eventMessage. */
        public eventMessage?: (proto.Message.IEventMessage|null);

        /** Message commentMessage. */
        public commentMessage?: (proto.Message.ICommentMessage|null);

        /** Message newsletterAdminInviteMessage. */
        public newsletterAdminInviteMessage?: (proto.Message.INewsletterAdminInviteMessage|null);

        /** Message extendedTextMessageWithParentKey. */
        public extendedTextMessageWithParentKey?: (proto.Message.IExtendedTextMessageWithParentKey|null);

        /** Message placeholderMessage. */
        public placeholderMessage?: (proto.Message.IPlaceholderMessage|null);

        /** Message encEventUpdateMessage. */
        public encEventUpdateMessage?: (proto.Message.IEncEventUpdateMessage|null);

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

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

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

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

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

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

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

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

    namespace Message {

        /** Properties of an AppStateFatalExceptionNotification. */
        interface IAppStateFatalExceptionNotification {

            /** AppStateFatalExceptionNotification collectionNames */
            collectionNames?: (string[]|null);

            /** AppStateFatalExceptionNotification timestamp */
            timestamp?: (number|Long|null);
        }

        /** Represents an AppStateFatalExceptionNotification. */
        class AppStateFatalExceptionNotification implements IAppStateFatalExceptionNotification {

            /**
             * Constructs a new AppStateFatalExceptionNotification.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IAppStateFatalExceptionNotification);

            /** AppStateFatalExceptionNotification collectionNames. */
            public collectionNames: string[];

            /** AppStateFatalExceptionNotification timestamp. */
            public timestamp: (number|Long);

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

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

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

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

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

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

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

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

        /** Properties of an AppStateSyncKey. */
        interface IAppStateSyncKey {

            /** AppStateSyncKey keyId */
            keyId?: (proto.Message.IAppStateSyncKeyId|null);

            /** AppStateSyncKey keyData */
            keyData?: (proto.Message.IAppStateSyncKeyData|null);
        }

        /** Represents an AppStateSyncKey. */
        class AppStateSyncKey implements IAppStateSyncKey {

            /**
             * Constructs a new AppStateSyncKey.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IAppStateSyncKey);

            /** AppStateSyncKey keyId. */
            public keyId?: (proto.Message.IAppStateSyncKeyId|null);

            /** AppStateSyncKey keyData. */
            public keyData?: (proto.Message.IAppStateSyncKeyData|null);

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

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

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

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

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

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

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

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

        /** Properties of an AppStateSyncKeyData. */
        interface IAppStateSyncKeyData {

            /** AppStateSyncKeyData keyData */
            keyData?: (Uint8Array|null);

            /** AppStateSyncKeyData fingerprint */
            fingerprint?: (proto.Message.IAppStateSyncKeyFingerprint|null);

            /** AppStateSyncKeyData timestamp */
            timestamp?: (number|Long|null);
        }

        /** Represents an AppStateSyncKeyData. */
        class AppStateSyncKeyData implements IAppStateSyncKeyData {

            /**
             * Constructs a new AppStateSyncKeyData.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IAppStateSyncKeyData);

            /** AppStateSyncKeyData keyData. */
            public keyData: Uint8Array;

            /** AppStateSyncKeyData fingerprint. */
            public fingerprint?: (proto.Message.IAppStateSyncKeyFingerprint|null);

            /** AppStateSyncKeyData timestamp. */
            public timestamp: (number|Long);

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

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

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

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

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

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

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

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

        /** Properties of an AppStateSyncKeyFingerprint. */
        interface IAppStateSyncKeyFingerprint {

            /** AppStateSyncKeyFingerprint rawId */
            rawId?: (number|null);

            /** AppStateSyncKeyFingerprint currentIndex */
            currentIndex?: (number|null);

            /** AppStateSyncKeyFingerprint deviceIndexes */
            deviceIndexes?: (number[]|null);
        }

        /** Represents an AppStateSyncKeyFingerprint. */
        class AppStateSyncKeyFingerprint implements IAppStateSyncKeyFingerprint {

            /**
             * Constructs a new AppStateSyncKeyFingerprint.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IAppStateSyncKeyFingerprint);

            /** AppStateSyncKeyFingerprint rawId. */
            public rawId: number;

            /** AppStateSyncKeyFingerprint currentIndex. */
            public currentIndex: number;

            /** AppStateSyncKeyFingerprint deviceIndexes. */
            public deviceIndexes: number[];

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

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

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

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

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

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

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

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

        /** Properties of an AppStateSyncKeyId. */
        interface IAppStateSyncKeyId {

            /** AppStateSyncKeyId keyId */
            keyId?: (Uint8Array|null);
        }

        /** Represents an AppStateSyncKeyId. */
        class AppStateSyncKeyId implements IAppStateSyncKeyId {

            /**
             * Constructs a new AppStateSyncKeyId.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IAppStateSyncKeyId);

            /** AppStateSyncKeyId keyId. */
            public keyId: Uint8Array;

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

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

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

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

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

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

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

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

        /** Properties of an AppStateSyncKeyRequest. */
        interface IAppStateSyncKeyRequest {

            /** AppStateSyncKeyRequest keyIds */
            keyIds?: (proto.Message.IAppStateSyncKeyId[]|null);
        }

        /** Represents an AppStateSyncKeyRequest. */
        class AppStateSyncKeyRequest implements IAppStateSyncKeyRequest {

            /**
             * Constructs a new AppStateSyncKeyRequest.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IAppStateSyncKeyRequest);

            /** AppStateSyncKeyRequest keyIds. */
            public keyIds: proto.Message.IAppStateSyncKeyId[];

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

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

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

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

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

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

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

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

        /** Properties of an AppStateSyncKeyShare. */
        interface IAppStateSyncKeyShare {

            /** AppStateSyncKeyShare keys */
            keys?: (proto.Message.IAppStateSyncKey[]|null);
        }

        /** Represents an AppStateSyncKeyShare. */
        class AppStateSyncKeyShare implements IAppStateSyncKeyShare {

            /**
             * Constructs a new AppStateSyncKeyShare.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IAppStateSyncKeyShare);

            /** AppStateSyncKeyShare keys. */
            public keys: proto.Message.IAppStateSyncKey[];

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

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

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

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

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

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

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

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

        /** Properties of an AudioMessage. */
        interface IAudioMessage {

            /** AudioMessage url */
            url?: (string|null);

            /** AudioMessage mimetype */
            mimetype?: (string|null);

            /** AudioMessage fileSha256 */
            fileSha256?: (Uint8Array|null);

            /** AudioMessage fileLength */
            fileLength?: (number|Long|null);

            /** AudioMessage seconds */
            seconds?: (number|null);

            /** AudioMessage ptt */
            ptt?: (boolean|null);

            /** AudioMessage mediaKey */
            mediaKey?: (Uint8Array|null);

            /** AudioMessage fileEncSha256 */
            fileEncSha256?: (Uint8Array|null);

            /** AudioMessage directPath */
            directPath?: (string|null);

            /** AudioMessage mediaKeyTimestamp */
            mediaKeyTimestamp?: (number|Long|null);

            /** AudioMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** AudioMessage streamingSidecar */
            streamingSidecar?: (Uint8Array|null);

            /** AudioMessage waveform */
            waveform?: (Uint8Array|null);

            /** AudioMessage backgroundArgb */
            backgroundArgb?: (number|null);

            /** AudioMessage viewOnce */
            viewOnce?: (boolean|null);
        }

        /** Represents an AudioMessage. */
        class AudioMessage implements IAudioMessage {

            /**
             * Constructs a new AudioMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IAudioMessage);

            /** AudioMessage url. */
            public url: string;

            /** AudioMessage mimetype. */
            public mimetype: string;

            /** AudioMessage fileSha256. */
            public fileSha256: Uint8Array;

            /** AudioMessage fileLength. */
            public fileLength: (number|Long);

            /** AudioMessage seconds. */
            public seconds: number;

            /** AudioMessage ptt. */
            public ptt: boolean;

            /** AudioMessage mediaKey. */
            public mediaKey: Uint8Array;

            /** AudioMessage fileEncSha256. */
            public fileEncSha256: Uint8Array;

            /** AudioMessage directPath. */
            public directPath: string;

            /** AudioMessage mediaKeyTimestamp. */
            public mediaKeyTimestamp: (number|Long);

            /** AudioMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** AudioMessage streamingSidecar. */
            public streamingSidecar: Uint8Array;

            /** AudioMessage waveform. */
            public waveform: Uint8Array;

            /** AudioMessage backgroundArgb. */
            public backgroundArgb: number;

            /** AudioMessage viewOnce. */
            public viewOnce: boolean;

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

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

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

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

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

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

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

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

        /** Properties of a BCallMessage. */
        interface IBCallMessage {

            /** BCallMessage sessionId */
            sessionId?: (string|null);

            /** BCallMessage mediaType */
            mediaType?: (proto.Message.BCallMessage.MediaType|null);

            /** BCallMessage masterKey */
            masterKey?: (Uint8Array|null);

            /** BCallMessage caption */
            caption?: (string|null);
        }

        /** Represents a BCallMessage. */
        class BCallMessage implements IBCallMessage {

            /**
             * Constructs a new BCallMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IBCallMessage);

            /** BCallMessage sessionId. */
            public sessionId: string;

            /** BCallMessage mediaType. */
            public mediaType: proto.Message.BCallMessage.MediaType;

            /** BCallMessage masterKey. */
            public masterKey: Uint8Array;

            /** BCallMessage caption. */
            public caption: string;

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

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

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

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

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

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

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

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

        namespace BCallMessage {

            /** MediaType enum. */
            enum MediaType {
                UNKNOWN = 0,
                AUDIO = 1,
                VIDEO = 2
            }
        }

        /** Properties of a BotFeedbackMessage. */
        interface IBotFeedbackMessage {

            /** BotFeedbackMessage messageKey */
            messageKey?: (proto.IMessageKey|null);

            /** BotFeedbackMessage kind */
            kind?: (proto.Message.BotFeedbackMessage.BotFeedbackKind|null);

            /** BotFeedbackMessage text */
            text?: (string|null);

            /** BotFeedbackMessage kindNegative */
            kindNegative?: (number|Long|null);

            /** BotFeedbackMessage kindPositive */
            kindPositive?: (number|Long|null);
        }

        /** Represents a BotFeedbackMessage. */
        class BotFeedbackMessage implements IBotFeedbackMessage {

            /**
             * Constructs a new BotFeedbackMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IBotFeedbackMessage);

            /** BotFeedbackMessage messageKey. */
            public messageKey?: (proto.IMessageKey|null);

            /** BotFeedbackMessage kind. */
            public kind: proto.Message.BotFeedbackMessage.BotFeedbackKind;

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

            /** BotFeedbackMessage kindNegative. */
            public kindNegative: (number|Long);

            /** BotFeedbackMessage kindPositive. */
            public kindPositive: (number|Long);

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

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

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

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

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

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

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

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

        namespace BotFeedbackMessage {

            /** BotFeedbackKind enum. */
            enum BotFeedbackKind {
                BOT_FEEDBACK_POSITIVE = 0,
                BOT_FEEDBACK_NEGATIVE_GENERIC = 1,
                BOT_FEEDBACK_NEGATIVE_HELPFUL = 2,
                BOT_FEEDBACK_NEGATIVE_INTERESTING = 3,
                BOT_FEEDBACK_NEGATIVE_ACCURATE = 4,
                BOT_FEEDBACK_NEGATIVE_SAFE = 5,
                BOT_FEEDBACK_NEGATIVE_OTHER = 6,
                BOT_FEEDBACK_NEGATIVE_REFUSED = 7,
                BOT_FEEDBACK_NEGATIVE_NOT_VISUALLY_APPEALING = 8,
                BOT_FEEDBACK_NEGATIVE_NOT_RELEVANT_TO_TEXT = 9
            }

            /** BotFeedbackKindMultipleNegative enum. */
            enum BotFeedbackKindMultipleNegative {
                BOT_FEEDBACK_MULTIPLE_NEGATIVE_GENERIC = 1,
                BOT_FEEDBACK_MULTIPLE_NEGATIVE_HELPFUL = 2,
                BOT_FEEDBACK_MULTIPLE_NEGATIVE_INTERESTING = 4,
                BOT_FEEDBACK_MULTIPLE_NEGATIVE_ACCURATE = 8,
                BOT_FEEDBACK_MULTIPLE_NEGATIVE_SAFE = 16,
                BOT_FEEDBACK_MULTIPLE_NEGATIVE_OTHER = 32,
                BOT_FEEDBACK_MULTIPLE_NEGATIVE_REFUSED = 64,
                BOT_FEEDBACK_MULTIPLE_NEGATIVE_NOT_VISUALLY_APPEALING = 128,
                BOT_FEEDBACK_MULTIPLE_NEGATIVE_NOT_RELEVANT_TO_TEXT = 256
            }

            /** BotFeedbackKindMultiplePositive enum. */
            enum BotFeedbackKindMultiplePositive {
                BOT_FEEDBACK_MULTIPLE_POSITIVE_GENERIC = 1
            }
        }

        /** Properties of a ButtonsMessage. */
        interface IButtonsMessage {

            /** ButtonsMessage contentText */
            contentText?: (string|null);

            /** ButtonsMessage footerText */
            footerText?: (string|null);

            /** ButtonsMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** ButtonsMessage buttons */
            buttons?: (proto.Message.ButtonsMessage.IButton[]|null);

            /** ButtonsMessage headerType */
            headerType?: (proto.Message.ButtonsMessage.HeaderType|null);

            /** ButtonsMessage text */
            text?: (string|null);

            /** ButtonsMessage documentMessage */
            documentMessage?: (proto.Message.IDocumentMessage|null);

            /** ButtonsMessage imageMessage */
            imageMessage?: (proto.Message.IImageMessage|null);

            /** ButtonsMessage videoMessage */
            videoMessage?: (proto.Message.IVideoMessage|null);

            /** ButtonsMessage locationMessage */
            locationMessage?: (proto.Message.ILocationMessage|null);
        }

        /** Represents a ButtonsMessage. */
        class ButtonsMessage implements IButtonsMessage {

            /**
             * Constructs a new ButtonsMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IButtonsMessage);

            /** ButtonsMessage contentText. */
            public contentText: string;

            /** ButtonsMessage footerText. */
            public footerText: string;

            /** ButtonsMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** ButtonsMessage buttons. */
            public buttons: proto.Message.ButtonsMessage.IButton[];

            /** ButtonsMessage headerType. */
            public headerType: proto.Message.ButtonsMessage.HeaderType;

            /** ButtonsMessage text. */
            public text?: (string|null);

            /** ButtonsMessage documentMessage. */
            public documentMessage?: (proto.Message.IDocumentMessage|null);

            /** ButtonsMessage imageMessage. */
            public imageMessage?: (proto.Message.IImageMessage|null);

            /** ButtonsMessage videoMessage. */
            public videoMessage?: (proto.Message.IVideoMessage|null);

            /** ButtonsMessage locationMessage. */
            public locationMessage?: (proto.Message.ILocationMessage|null);

            /** ButtonsMessage header. */
            public header?: ("text"|"documentMessage"|"imageMessage"|"videoMessage"|"locationMessage");

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

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

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

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

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

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

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

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

        namespace ButtonsMessage {

            /** Properties of a Button. */
            interface IButton {

                /** Button buttonId */
                buttonId?: (string|null);

                /** Button buttonText */
                buttonText?: (proto.Message.ButtonsMessage.Button.IButtonText|null);

                /** Button type */
                type?: (proto.Message.ButtonsMessage.Button.Type|null);

                /** Button nativeFlowInfo */
                nativeFlowInfo?: (proto.Message.ButtonsMessage.Button.INativeFlowInfo|null);
            }

            /** Represents a Button. */
            class Button implements IButton {

                /**
                 * Constructs a new Button.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.ButtonsMessage.IButton);

                /** Button buttonId. */
                public buttonId: string;

                /** Button buttonText. */
                public buttonText?: (proto.Message.ButtonsMessage.Button.IButtonText|null);

                /** Button type. */
                public type: proto.Message.ButtonsMessage.Button.Type;

                /** Button nativeFlowInfo. */
                public nativeFlowInfo?: (proto.Message.ButtonsMessage.Button.INativeFlowInfo|null);

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

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

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

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

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

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

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

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

            namespace Button {

                /** Properties of a ButtonText. */
                interface IButtonText {

                    /** ButtonText displayText */
                    displayText?: (string|null);
                }

                /** Represents a ButtonText. */
                class ButtonText implements IButtonText {

                    /**
                     * Constructs a new ButtonText.
                     * @param [properties] Properties to set
                     */
                    constructor(properties?: proto.Message.ButtonsMessage.Button.IButtonText);

                    /** ButtonText displayText. */
                    public displayText: string;

                    /**
                     * Creates a new ButtonText instance using the specified properties.
                     * @param [properties] Properties to set
                     * @returns ButtonText instance
                     */
                    public static create(properties?: proto.Message.ButtonsMessage.Button.IButtonText): proto.Message.ButtonsMessage.Button.ButtonText;

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

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

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

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

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

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

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

                /** Properties of a NativeFlowInfo. */
                interface INativeFlowInfo {

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

                    /** NativeFlowInfo paramsJson */
                    paramsJson?: (string|null);
                }

                /** Represents a NativeFlowInfo. */
                class NativeFlowInfo implements INativeFlowInfo {

                    /**
                     * Constructs a new NativeFlowInfo.
                     * @param [properties] Properties to set
                     */
                    constructor(properties?: proto.Message.ButtonsMessage.Button.INativeFlowInfo);

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

                    /** NativeFlowInfo paramsJson. */
                    public paramsJson: string;

                    /**
                     * Creates a new NativeFlowInfo instance using the specified properties.
                     * @param [properties] Properties to set
                     * @returns NativeFlowInfo instance
                     */
                    public static create(properties?: proto.Message.ButtonsMessage.Button.INativeFlowInfo): proto.Message.ButtonsMessage.Button.NativeFlowInfo;

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

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

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

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

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

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

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

                /** Type enum. */
                enum Type {
                    UNKNOWN = 0,
                    RESPONSE = 1,
                    NATIVE_FLOW = 2
                }
            }

            /** HeaderType enum. */
            enum HeaderType {
                UNKNOWN = 0,
                EMPTY = 1,
                TEXT = 2,
                DOCUMENT = 3,
                IMAGE = 4,
                VIDEO = 5,
                LOCATION = 6
            }
        }

        /** Properties of a ButtonsResponseMessage. */
        interface IButtonsResponseMessage {

            /** ButtonsResponseMessage selectedButtonId */
            selectedButtonId?: (string|null);

            /** ButtonsResponseMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** ButtonsResponseMessage type */
            type?: (proto.Message.ButtonsResponseMessage.Type|null);

            /** ButtonsResponseMessage selectedDisplayText */
            selectedDisplayText?: (string|null);
        }

        /** Represents a ButtonsResponseMessage. */
        class ButtonsResponseMessage implements IButtonsResponseMessage {

            /**
             * Constructs a new ButtonsResponseMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IButtonsResponseMessage);

            /** ButtonsResponseMessage selectedButtonId. */
            public selectedButtonId: string;

            /** ButtonsResponseMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** ButtonsResponseMessage type. */
            public type: proto.Message.ButtonsResponseMessage.Type;

            /** ButtonsResponseMessage selectedDisplayText. */
            public selectedDisplayText?: (string|null);

            /** ButtonsResponseMessage response. */
            public response?: "selectedDisplayText";

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

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

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

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

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

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

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

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

        namespace ButtonsResponseMessage {

            /** Type enum. */
            enum Type {
                UNKNOWN = 0,
                DISPLAY_TEXT = 1
            }
        }

        /** Properties of a Call. */
        interface ICall {

            /** Call callKey */
            callKey?: (Uint8Array|null);

            /** Call conversionSource */
            conversionSource?: (string|null);

            /** Call conversionData */
            conversionData?: (Uint8Array|null);

            /** Call conversionDelaySeconds */
            conversionDelaySeconds?: (number|null);
        }

        /** Represents a Call. */
        class Call implements ICall {

            /**
             * Constructs a new Call.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.ICall);

            /** Call callKey. */
            public callKey: Uint8Array;

            /** Call conversionSource. */
            public conversionSource: string;

            /** Call conversionData. */
            public conversionData: Uint8Array;

            /** Call conversionDelaySeconds. */
            public conversionDelaySeconds: number;

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

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

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

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

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

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

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

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

        /** Properties of a CallLogMessage. */
        interface ICallLogMessage {

            /** CallLogMessage isVideo */
            isVideo?: (boolean|null);

            /** CallLogMessage callOutcome */
            callOutcome?: (proto.Message.CallLogMessage.CallOutcome|null);

            /** CallLogMessage durationSecs */
            durationSecs?: (number|Long|null);

            /** CallLogMessage callType */
            callType?: (proto.Message.CallLogMessage.CallType|null);

            /** CallLogMessage participants */
            participants?: (proto.Message.CallLogMessage.ICallParticipant[]|null);
        }

        /** Represents a CallLogMessage. */
        class CallLogMessage implements ICallLogMessage {

            /**
             * Constructs a new CallLogMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.ICallLogMessage);

            /** CallLogMessage isVideo. */
            public isVideo: boolean;

            /** CallLogMessage callOutcome. */
            public callOutcome: proto.Message.CallLogMessage.CallOutcome;

            /** CallLogMessage durationSecs. */
            public durationSecs: (number|Long);

            /** CallLogMessage callType. */
            public callType: proto.Message.CallLogMessage.CallType;

            /** CallLogMessage participants. */
            public participants: proto.Message.CallLogMessage.ICallParticipant[];

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

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

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

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

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

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

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

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

        namespace CallLogMessage {

            /** CallOutcome enum. */
            enum CallOutcome {
                CONNECTED = 0,
                MISSED = 1,
                FAILED = 2,
                REJECTED = 3,
                ACCEPTED_ELSEWHERE = 4,
                ONGOING = 5,
                SILENCED_BY_DND = 6,
                SILENCED_UNKNOWN_CALLER = 7
            }

            /** Properties of a CallParticipant. */
            interface ICallParticipant {

                /** CallParticipant jid */
                jid?: (string|null);

                /** CallParticipant callOutcome */
                callOutcome?: (proto.Message.CallLogMessage.CallOutcome|null);
            }

            /** Represents a CallParticipant. */
            class CallParticipant implements ICallParticipant {

                /**
                 * Constructs a new CallParticipant.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.CallLogMessage.ICallParticipant);

                /** CallParticipant jid. */
                public jid: string;

                /** CallParticipant callOutcome. */
                public callOutcome: proto.Message.CallLogMessage.CallOutcome;

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

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

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

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

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

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

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

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

            /** CallType enum. */
            enum CallType {
                REGULAR = 0,
                SCHEDULED_CALL = 1,
                VOICE_CHAT = 2
            }
        }

        /** Properties of a CancelPaymentRequestMessage. */
        interface ICancelPaymentRequestMessage {

            /** CancelPaymentRequestMessage key */
            key?: (proto.IMessageKey|null);
        }

        /** Represents a CancelPaymentRequestMessage. */
        class CancelPaymentRequestMessage implements ICancelPaymentRequestMessage {

            /**
             * Constructs a new CancelPaymentRequestMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.ICancelPaymentRequestMessage);

            /** CancelPaymentRequestMessage key. */
            public key?: (proto.IMessageKey|null);

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

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

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

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

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

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

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

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

        /** Properties of a Chat. */
        interface IChat {

            /** Chat displayName */
            displayName?: (string|null);

            /** Chat id */
            id?: (string|null);
        }

        /** Represents a Chat. */
        class Chat implements IChat {

            /**
             * Constructs a new Chat.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IChat);

            /** Chat displayName. */
            public displayName: string;

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

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

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

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

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

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

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

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

            /**
             * Converts this Chat to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a CommentMessage. */
        interface ICommentMessage {

            /** CommentMessage message */
            message?: (proto.IMessage|null);

            /** CommentMessage targetMessageKey */
            targetMessageKey?: (proto.IMessageKey|null);
        }

        /** Represents a CommentMessage. */
        class CommentMessage implements ICommentMessage {

            /**
             * Constructs a new CommentMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.ICommentMessage);

            /** CommentMessage message. */
            public message?: (proto.IMessage|null);

            /** CommentMessage targetMessageKey. */
            public targetMessageKey?: (proto.IMessageKey|null);

            /**
             * Creates a new CommentMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns CommentMessage instance
             */
            public static create(properties?: proto.Message.ICommentMessage): proto.Message.CommentMessage;

            /**
             * Encodes the specified CommentMessage message. Does not implicitly {@link proto.Message.CommentMessage.verify|verify} messages.
             * @param message CommentMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.ICommentMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified CommentMessage message, length delimited. Does not implicitly {@link proto.Message.CommentMessage.verify|verify} messages.
             * @param message CommentMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.ICommentMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a CommentMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns CommentMessage
             * @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): proto.Message.CommentMessage;

            /**
             * Decodes a CommentMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns CommentMessage
             * @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)): proto.Message.CommentMessage;

            /**
             * Verifies a CommentMessage 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 CommentMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns CommentMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.CommentMessage;

            /**
             * Creates a plain object from a CommentMessage message. Also converts values to other types if specified.
             * @param message CommentMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.CommentMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this CommentMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a ContactMessage. */
        interface IContactMessage {

            /** ContactMessage displayName */
            displayName?: (string|null);

            /** ContactMessage vcard */
            vcard?: (string|null);

            /** ContactMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);
        }

        /** Represents a ContactMessage. */
        class ContactMessage implements IContactMessage {

            /**
             * Constructs a new ContactMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IContactMessage);

            /** ContactMessage displayName. */
            public displayName: string;

            /** ContactMessage vcard. */
            public vcard: string;

            /** ContactMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /**
             * Creates a new ContactMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ContactMessage instance
             */
            public static create(properties?: proto.Message.IContactMessage): proto.Message.ContactMessage;

            /**
             * Encodes the specified ContactMessage message. Does not implicitly {@link proto.Message.ContactMessage.verify|verify} messages.
             * @param message ContactMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IContactMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ContactMessage message, length delimited. Does not implicitly {@link proto.Message.ContactMessage.verify|verify} messages.
             * @param message ContactMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IContactMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ContactMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ContactMessage
             * @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): proto.Message.ContactMessage;

            /**
             * Decodes a ContactMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ContactMessage
             * @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)): proto.Message.ContactMessage;

            /**
             * Verifies a ContactMessage 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 ContactMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ContactMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.ContactMessage;

            /**
             * Creates a plain object from a ContactMessage message. Also converts values to other types if specified.
             * @param message ContactMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.ContactMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ContactMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a ContactsArrayMessage. */
        interface IContactsArrayMessage {

            /** ContactsArrayMessage displayName */
            displayName?: (string|null);

            /** ContactsArrayMessage contacts */
            contacts?: (proto.Message.IContactMessage[]|null);

            /** ContactsArrayMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);
        }

        /** Represents a ContactsArrayMessage. */
        class ContactsArrayMessage implements IContactsArrayMessage {

            /**
             * Constructs a new ContactsArrayMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IContactsArrayMessage);

            /** ContactsArrayMessage displayName. */
            public displayName: string;

            /** ContactsArrayMessage contacts. */
            public contacts: proto.Message.IContactMessage[];

            /** ContactsArrayMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /**
             * Creates a new ContactsArrayMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ContactsArrayMessage instance
             */
            public static create(properties?: proto.Message.IContactsArrayMessage): proto.Message.ContactsArrayMessage;

            /**
             * Encodes the specified ContactsArrayMessage message. Does not implicitly {@link proto.Message.ContactsArrayMessage.verify|verify} messages.
             * @param message ContactsArrayMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IContactsArrayMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ContactsArrayMessage message, length delimited. Does not implicitly {@link proto.Message.ContactsArrayMessage.verify|verify} messages.
             * @param message ContactsArrayMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IContactsArrayMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ContactsArrayMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ContactsArrayMessage
             * @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): proto.Message.ContactsArrayMessage;

            /**
             * Decodes a ContactsArrayMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ContactsArrayMessage
             * @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)): proto.Message.ContactsArrayMessage;

            /**
             * Verifies a ContactsArrayMessage 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 ContactsArrayMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ContactsArrayMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.ContactsArrayMessage;

            /**
             * Creates a plain object from a ContactsArrayMessage message. Also converts values to other types if specified.
             * @param message ContactsArrayMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.ContactsArrayMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ContactsArrayMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a DeclinePaymentRequestMessage. */
        interface IDeclinePaymentRequestMessage {

            /** DeclinePaymentRequestMessage key */
            key?: (proto.IMessageKey|null);
        }

        /** Represents a DeclinePaymentRequestMessage. */
        class DeclinePaymentRequestMessage implements IDeclinePaymentRequestMessage {

            /**
             * Constructs a new DeclinePaymentRequestMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IDeclinePaymentRequestMessage);

            /** DeclinePaymentRequestMessage key. */
            public key?: (proto.IMessageKey|null);

            /**
             * Creates a new DeclinePaymentRequestMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns DeclinePaymentRequestMessage instance
             */
            public static create(properties?: proto.Message.IDeclinePaymentRequestMessage): proto.Message.DeclinePaymentRequestMessage;

            /**
             * Encodes the specified DeclinePaymentRequestMessage message. Does not implicitly {@link proto.Message.DeclinePaymentRequestMessage.verify|verify} messages.
             * @param message DeclinePaymentRequestMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IDeclinePaymentRequestMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified DeclinePaymentRequestMessage message, length delimited. Does not implicitly {@link proto.Message.DeclinePaymentRequestMessage.verify|verify} messages.
             * @param message DeclinePaymentRequestMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IDeclinePaymentRequestMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a DeclinePaymentRequestMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns DeclinePaymentRequestMessage
             * @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): proto.Message.DeclinePaymentRequestMessage;

            /**
             * Decodes a DeclinePaymentRequestMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns DeclinePaymentRequestMessage
             * @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)): proto.Message.DeclinePaymentRequestMessage;

            /**
             * Verifies a DeclinePaymentRequestMessage 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 DeclinePaymentRequestMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns DeclinePaymentRequestMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.DeclinePaymentRequestMessage;

            /**
             * Creates a plain object from a DeclinePaymentRequestMessage message. Also converts values to other types if specified.
             * @param message DeclinePaymentRequestMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.DeclinePaymentRequestMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this DeclinePaymentRequestMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a DeviceSentMessage. */
        interface IDeviceSentMessage {

            /** DeviceSentMessage destinationJid */
            destinationJid?: (string|null);

            /** DeviceSentMessage message */
            message?: (proto.IMessage|null);

            /** DeviceSentMessage phash */
            phash?: (string|null);
        }

        /** Represents a DeviceSentMessage. */
        class DeviceSentMessage implements IDeviceSentMessage {

            /**
             * Constructs a new DeviceSentMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IDeviceSentMessage);

            /** DeviceSentMessage destinationJid. */
            public destinationJid: string;

            /** DeviceSentMessage message. */
            public message?: (proto.IMessage|null);

            /** DeviceSentMessage phash. */
            public phash: string;

            /**
             * Creates a new DeviceSentMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns DeviceSentMessage instance
             */
            public static create(properties?: proto.Message.IDeviceSentMessage): proto.Message.DeviceSentMessage;

            /**
             * Encodes the specified DeviceSentMessage message. Does not implicitly {@link proto.Message.DeviceSentMessage.verify|verify} messages.
             * @param message DeviceSentMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IDeviceSentMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified DeviceSentMessage message, length delimited. Does not implicitly {@link proto.Message.DeviceSentMessage.verify|verify} messages.
             * @param message DeviceSentMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IDeviceSentMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a DeviceSentMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns DeviceSentMessage
             * @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): proto.Message.DeviceSentMessage;

            /**
             * Decodes a DeviceSentMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns DeviceSentMessage
             * @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)): proto.Message.DeviceSentMessage;

            /**
             * Verifies a DeviceSentMessage 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 DeviceSentMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns DeviceSentMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.DeviceSentMessage;

            /**
             * Creates a plain object from a DeviceSentMessage message. Also converts values to other types if specified.
             * @param message DeviceSentMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.DeviceSentMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this DeviceSentMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a DocumentMessage. */
        interface IDocumentMessage {

            /** DocumentMessage url */
            url?: (string|null);

            /** DocumentMessage mimetype */
            mimetype?: (string|null);

            /** DocumentMessage title */
            title?: (string|null);

            /** DocumentMessage fileSha256 */
            fileSha256?: (Uint8Array|null);

            /** DocumentMessage fileLength */
            fileLength?: (number|Long|null);

            /** DocumentMessage pageCount */
            pageCount?: (number|null);

            /** DocumentMessage mediaKey */
            mediaKey?: (Uint8Array|null);

            /** DocumentMessage fileName */
            fileName?: (string|null);

            /** DocumentMessage fileEncSha256 */
            fileEncSha256?: (Uint8Array|null);

            /** DocumentMessage directPath */
            directPath?: (string|null);

            /** DocumentMessage mediaKeyTimestamp */
            mediaKeyTimestamp?: (number|Long|null);

            /** DocumentMessage contactVcard */
            contactVcard?: (boolean|null);

            /** DocumentMessage thumbnailDirectPath */
            thumbnailDirectPath?: (string|null);

            /** DocumentMessage thumbnailSha256 */
            thumbnailSha256?: (Uint8Array|null);

            /** DocumentMessage thumbnailEncSha256 */
            thumbnailEncSha256?: (Uint8Array|null);

            /** DocumentMessage jpegThumbnail */
            jpegThumbnail?: (Uint8Array|null);

            /** DocumentMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** DocumentMessage thumbnailHeight */
            thumbnailHeight?: (number|null);

            /** DocumentMessage thumbnailWidth */
            thumbnailWidth?: (number|null);

            /** DocumentMessage caption */
            caption?: (string|null);
        }

        /** Represents a DocumentMessage. */
        class DocumentMessage implements IDocumentMessage {

            /**
             * Constructs a new DocumentMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IDocumentMessage);

            /** DocumentMessage url. */
            public url: string;

            /** DocumentMessage mimetype. */
            public mimetype: string;

            /** DocumentMessage title. */
            public title: string;

            /** DocumentMessage fileSha256. */
            public fileSha256: Uint8Array;

            /** DocumentMessage fileLength. */
            public fileLength: (number|Long);

            /** DocumentMessage pageCount. */
            public pageCount: number;

            /** DocumentMessage mediaKey. */
            public mediaKey: Uint8Array;

            /** DocumentMessage fileName. */
            public fileName: string;

            /** DocumentMessage fileEncSha256. */
            public fileEncSha256: Uint8Array;

            /** DocumentMessage directPath. */
            public directPath: string;

            /** DocumentMessage mediaKeyTimestamp. */
            public mediaKeyTimestamp: (number|Long);

            /** DocumentMessage contactVcard. */
            public contactVcard: boolean;

            /** DocumentMessage thumbnailDirectPath. */
            public thumbnailDirectPath: string;

            /** DocumentMessage thumbnailSha256. */
            public thumbnailSha256: Uint8Array;

            /** DocumentMessage thumbnailEncSha256. */
            public thumbnailEncSha256: Uint8Array;

            /** DocumentMessage jpegThumbnail. */
            public jpegThumbnail: Uint8Array;

            /** DocumentMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** DocumentMessage thumbnailHeight. */
            public thumbnailHeight: number;

            /** DocumentMessage thumbnailWidth. */
            public thumbnailWidth: number;

            /** DocumentMessage caption. */
            public caption: string;

            /**
             * Creates a new DocumentMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns DocumentMessage instance
             */
            public static create(properties?: proto.Message.IDocumentMessage): proto.Message.DocumentMessage;

            /**
             * Encodes the specified DocumentMessage message. Does not implicitly {@link proto.Message.DocumentMessage.verify|verify} messages.
             * @param message DocumentMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IDocumentMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified DocumentMessage message, length delimited. Does not implicitly {@link proto.Message.DocumentMessage.verify|verify} messages.
             * @param message DocumentMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IDocumentMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a DocumentMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns DocumentMessage
             * @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): proto.Message.DocumentMessage;

            /**
             * Decodes a DocumentMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns DocumentMessage
             * @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)): proto.Message.DocumentMessage;

            /**
             * Verifies a DocumentMessage 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 DocumentMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns DocumentMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.DocumentMessage;

            /**
             * Creates a plain object from a DocumentMessage message. Also converts values to other types if specified.
             * @param message DocumentMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.DocumentMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this DocumentMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an EncCommentMessage. */
        interface IEncCommentMessage {

            /** EncCommentMessage targetMessageKey */
            targetMessageKey?: (proto.IMessageKey|null);

            /** EncCommentMessage encPayload */
            encPayload?: (Uint8Array|null);

            /** EncCommentMessage encIv */
            encIv?: (Uint8Array|null);
        }

        /** Represents an EncCommentMessage. */
        class EncCommentMessage implements IEncCommentMessage {

            /**
             * Constructs a new EncCommentMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IEncCommentMessage);

            /** EncCommentMessage targetMessageKey. */
            public targetMessageKey?: (proto.IMessageKey|null);

            /** EncCommentMessage encPayload. */
            public encPayload: Uint8Array;

            /** EncCommentMessage encIv. */
            public encIv: Uint8Array;

            /**
             * Creates a new EncCommentMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns EncCommentMessage instance
             */
            public static create(properties?: proto.Message.IEncCommentMessage): proto.Message.EncCommentMessage;

            /**
             * Encodes the specified EncCommentMessage message. Does not implicitly {@link proto.Message.EncCommentMessage.verify|verify} messages.
             * @param message EncCommentMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IEncCommentMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified EncCommentMessage message, length delimited. Does not implicitly {@link proto.Message.EncCommentMessage.verify|verify} messages.
             * @param message EncCommentMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IEncCommentMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an EncCommentMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns EncCommentMessage
             * @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): proto.Message.EncCommentMessage;

            /**
             * Decodes an EncCommentMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns EncCommentMessage
             * @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)): proto.Message.EncCommentMessage;

            /**
             * Verifies an EncCommentMessage 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 EncCommentMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns EncCommentMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.EncCommentMessage;

            /**
             * Creates a plain object from an EncCommentMessage message. Also converts values to other types if specified.
             * @param message EncCommentMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.EncCommentMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this EncCommentMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an EncEventUpdateMessage. */
        interface IEncEventUpdateMessage {

            /** EncEventUpdateMessage eventCreationMessageKey */
            eventCreationMessageKey?: (proto.IMessageKey|null);

            /** EncEventUpdateMessage encPayload */
            encPayload?: (Uint8Array|null);

            /** EncEventUpdateMessage encIv */
            encIv?: (Uint8Array|null);
        }

        /** Represents an EncEventUpdateMessage. */
        class EncEventUpdateMessage implements IEncEventUpdateMessage {

            /**
             * Constructs a new EncEventUpdateMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IEncEventUpdateMessage);

            /** EncEventUpdateMessage eventCreationMessageKey. */
            public eventCreationMessageKey?: (proto.IMessageKey|null);

            /** EncEventUpdateMessage encPayload. */
            public encPayload: Uint8Array;

            /** EncEventUpdateMessage encIv. */
            public encIv: Uint8Array;

            /**
             * Creates a new EncEventUpdateMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns EncEventUpdateMessage instance
             */
            public static create(properties?: proto.Message.IEncEventUpdateMessage): proto.Message.EncEventUpdateMessage;

            /**
             * Encodes the specified EncEventUpdateMessage message. Does not implicitly {@link proto.Message.EncEventUpdateMessage.verify|verify} messages.
             * @param message EncEventUpdateMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IEncEventUpdateMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified EncEventUpdateMessage message, length delimited. Does not implicitly {@link proto.Message.EncEventUpdateMessage.verify|verify} messages.
             * @param message EncEventUpdateMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IEncEventUpdateMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an EncEventUpdateMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns EncEventUpdateMessage
             * @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): proto.Message.EncEventUpdateMessage;

            /**
             * Decodes an EncEventUpdateMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns EncEventUpdateMessage
             * @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)): proto.Message.EncEventUpdateMessage;

            /**
             * Verifies an EncEventUpdateMessage 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 EncEventUpdateMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns EncEventUpdateMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.EncEventUpdateMessage;

            /**
             * Creates a plain object from an EncEventUpdateMessage message. Also converts values to other types if specified.
             * @param message EncEventUpdateMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.EncEventUpdateMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this EncEventUpdateMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an EncReactionMessage. */
        interface IEncReactionMessage {

            /** EncReactionMessage targetMessageKey */
            targetMessageKey?: (proto.IMessageKey|null);

            /** EncReactionMessage encPayload */
            encPayload?: (Uint8Array|null);

            /** EncReactionMessage encIv */
            encIv?: (Uint8Array|null);
        }

        /** Represents an EncReactionMessage. */
        class EncReactionMessage implements IEncReactionMessage {

            /**
             * Constructs a new EncReactionMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IEncReactionMessage);

            /** EncReactionMessage targetMessageKey. */
            public targetMessageKey?: (proto.IMessageKey|null);

            /** EncReactionMessage encPayload. */
            public encPayload: Uint8Array;

            /** EncReactionMessage encIv. */
            public encIv: Uint8Array;

            /**
             * Creates a new EncReactionMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns EncReactionMessage instance
             */
            public static create(properties?: proto.Message.IEncReactionMessage): proto.Message.EncReactionMessage;

            /**
             * Encodes the specified EncReactionMessage message. Does not implicitly {@link proto.Message.EncReactionMessage.verify|verify} messages.
             * @param message EncReactionMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IEncReactionMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified EncReactionMessage message, length delimited. Does not implicitly {@link proto.Message.EncReactionMessage.verify|verify} messages.
             * @param message EncReactionMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IEncReactionMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an EncReactionMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns EncReactionMessage
             * @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): proto.Message.EncReactionMessage;

            /**
             * Decodes an EncReactionMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns EncReactionMessage
             * @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)): proto.Message.EncReactionMessage;

            /**
             * Verifies an EncReactionMessage 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 EncReactionMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns EncReactionMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.EncReactionMessage;

            /**
             * Creates a plain object from an EncReactionMessage message. Also converts values to other types if specified.
             * @param message EncReactionMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.EncReactionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this EncReactionMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an EventEditMessage. */
        interface IEventEditMessage {

            /** EventEditMessage eventEditMessage */
            eventEditMessage?: (proto.Message.IEventMessage|null);

            /** EventEditMessage editTimestampMs */
            editTimestampMs?: (number|Long|null);
        }

        /** Represents an EventEditMessage. */
        class EventEditMessage implements IEventEditMessage {

            /**
             * Constructs a new EventEditMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IEventEditMessage);

            /** EventEditMessage eventEditMessage. */
            public eventEditMessage?: (proto.Message.IEventMessage|null);

            /** EventEditMessage editTimestampMs. */
            public editTimestampMs: (number|Long);

            /**
             * Creates a new EventEditMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns EventEditMessage instance
             */
            public static create(properties?: proto.Message.IEventEditMessage): proto.Message.EventEditMessage;

            /**
             * Encodes the specified EventEditMessage message. Does not implicitly {@link proto.Message.EventEditMessage.verify|verify} messages.
             * @param message EventEditMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IEventEditMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified EventEditMessage message, length delimited. Does not implicitly {@link proto.Message.EventEditMessage.verify|verify} messages.
             * @param message EventEditMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IEventEditMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an EventEditMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns EventEditMessage
             * @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): proto.Message.EventEditMessage;

            /**
             * Decodes an EventEditMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns EventEditMessage
             * @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)): proto.Message.EventEditMessage;

            /**
             * Verifies an EventEditMessage 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 EventEditMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns EventEditMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.EventEditMessage;

            /**
             * Creates a plain object from an EventEditMessage message. Also converts values to other types if specified.
             * @param message EventEditMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.EventEditMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this EventEditMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an EventMessage. */
        interface IEventMessage {

            /** EventMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** EventMessage isCanceled */
            isCanceled?: (boolean|null);

            /** EventMessage name */
            name?: (string|null);

            /** EventMessage description */
            description?: (string|null);

            /** EventMessage location */
            location?: (proto.Message.ILocationMessage|null);

            /** EventMessage joinLink */
            joinLink?: (string|null);

            /** EventMessage startTime */
            startTime?: (number|Long|null);
        }

        /** Represents an EventMessage. */
        class EventMessage implements IEventMessage {

            /**
             * Constructs a new EventMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IEventMessage);

            /** EventMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** EventMessage isCanceled. */
            public isCanceled: boolean;

            /** EventMessage name. */
            public name: string;

            /** EventMessage description. */
            public description: string;

            /** EventMessage location. */
            public location?: (proto.Message.ILocationMessage|null);

            /** EventMessage joinLink. */
            public joinLink: string;

            /** EventMessage startTime. */
            public startTime: (number|Long);

            /**
             * Creates a new EventMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns EventMessage instance
             */
            public static create(properties?: proto.Message.IEventMessage): proto.Message.EventMessage;

            /**
             * Encodes the specified EventMessage message. Does not implicitly {@link proto.Message.EventMessage.verify|verify} messages.
             * @param message EventMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IEventMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified EventMessage message, length delimited. Does not implicitly {@link proto.Message.EventMessage.verify|verify} messages.
             * @param message EventMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IEventMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an EventMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns EventMessage
             * @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): proto.Message.EventMessage;

            /**
             * Decodes an EventMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns EventMessage
             * @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)): proto.Message.EventMessage;

            /**
             * Verifies an EventMessage 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 EventMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns EventMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.EventMessage;

            /**
             * Creates a plain object from an EventMessage message. Also converts values to other types if specified.
             * @param message EventMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.EventMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this EventMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an EventResponseMessage. */
        interface IEventResponseMessage {

            /** EventResponseMessage response */
            response?: (proto.Message.EventResponseMessage.EventResponseType|null);

            /** EventResponseMessage timestampMs */
            timestampMs?: (number|Long|null);
        }

        /** Represents an EventResponseMessage. */
        class EventResponseMessage implements IEventResponseMessage {

            /**
             * Constructs a new EventResponseMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IEventResponseMessage);

            /** EventResponseMessage response. */
            public response: proto.Message.EventResponseMessage.EventResponseType;

            /** EventResponseMessage timestampMs. */
            public timestampMs: (number|Long);

            /**
             * Creates a new EventResponseMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns EventResponseMessage instance
             */
            public static create(properties?: proto.Message.IEventResponseMessage): proto.Message.EventResponseMessage;

            /**
             * Encodes the specified EventResponseMessage message. Does not implicitly {@link proto.Message.EventResponseMessage.verify|verify} messages.
             * @param message EventResponseMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IEventResponseMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified EventResponseMessage message, length delimited. Does not implicitly {@link proto.Message.EventResponseMessage.verify|verify} messages.
             * @param message EventResponseMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IEventResponseMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an EventResponseMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns EventResponseMessage
             * @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): proto.Message.EventResponseMessage;

            /**
             * Decodes an EventResponseMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns EventResponseMessage
             * @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)): proto.Message.EventResponseMessage;

            /**
             * Verifies an EventResponseMessage 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 EventResponseMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns EventResponseMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.EventResponseMessage;

            /**
             * Creates a plain object from an EventResponseMessage message. Also converts values to other types if specified.
             * @param message EventResponseMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.EventResponseMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this EventResponseMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace EventResponseMessage {

            /** EventResponseType enum. */
            enum EventResponseType {
                UNKNOWN = 0,
                GOING = 1,
                NOT_GOING = 2
            }
        }

        /** Properties of an EventUpdateMessage. */
        interface IEventUpdateMessage {

            /** EventUpdateMessage response */
            response?: (proto.Message.IEventResponseMessage|null);

            /** EventUpdateMessage edit */
            edit?: (proto.Message.IEventEditMessage|null);
        }

        /** Represents an EventUpdateMessage. */
        class EventUpdateMessage implements IEventUpdateMessage {

            /**
             * Constructs a new EventUpdateMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IEventUpdateMessage);

            /** EventUpdateMessage response. */
            public response?: (proto.Message.IEventResponseMessage|null);

            /** EventUpdateMessage edit. */
            public edit?: (proto.Message.IEventEditMessage|null);

            /**
             * Creates a new EventUpdateMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns EventUpdateMessage instance
             */
            public static create(properties?: proto.Message.IEventUpdateMessage): proto.Message.EventUpdateMessage;

            /**
             * Encodes the specified EventUpdateMessage message. Does not implicitly {@link proto.Message.EventUpdateMessage.verify|verify} messages.
             * @param message EventUpdateMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IEventUpdateMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified EventUpdateMessage message, length delimited. Does not implicitly {@link proto.Message.EventUpdateMessage.verify|verify} messages.
             * @param message EventUpdateMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IEventUpdateMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an EventUpdateMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns EventUpdateMessage
             * @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): proto.Message.EventUpdateMessage;

            /**
             * Decodes an EventUpdateMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns EventUpdateMessage
             * @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)): proto.Message.EventUpdateMessage;

            /**
             * Verifies an EventUpdateMessage 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 EventUpdateMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns EventUpdateMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.EventUpdateMessage;

            /**
             * Creates a plain object from an EventUpdateMessage message. Also converts values to other types if specified.
             * @param message EventUpdateMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.EventUpdateMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this EventUpdateMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an ExtendedTextMessage. */
        interface IExtendedTextMessage {

            /** ExtendedTextMessage text */
            text?: (string|null);

            /** ExtendedTextMessage matchedText */
            matchedText?: (string|null);

            /** ExtendedTextMessage canonicalUrl */
            canonicalUrl?: (string|null);

            /** ExtendedTextMessage description */
            description?: (string|null);

            /** ExtendedTextMessage title */
            title?: (string|null);

            /** ExtendedTextMessage textArgb */
            textArgb?: (number|null);

            /** ExtendedTextMessage backgroundArgb */
            backgroundArgb?: (number|null);

            /** ExtendedTextMessage font */
            font?: (proto.Message.ExtendedTextMessage.FontType|null);

            /** ExtendedTextMessage previewType */
            previewType?: (proto.Message.ExtendedTextMessage.PreviewType|null);

            /** ExtendedTextMessage jpegThumbnail */
            jpegThumbnail?: (Uint8Array|null);

            /** ExtendedTextMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** ExtendedTextMessage doNotPlayInline */
            doNotPlayInline?: (boolean|null);

            /** ExtendedTextMessage thumbnailDirectPath */
            thumbnailDirectPath?: (string|null);

            /** ExtendedTextMessage thumbnailSha256 */
            thumbnailSha256?: (Uint8Array|null);

            /** ExtendedTextMessage thumbnailEncSha256 */
            thumbnailEncSha256?: (Uint8Array|null);

            /** ExtendedTextMessage mediaKey */
            mediaKey?: (Uint8Array|null);

            /** ExtendedTextMessage mediaKeyTimestamp */
            mediaKeyTimestamp?: (number|Long|null);

            /** ExtendedTextMessage thumbnailHeight */
            thumbnailHeight?: (number|null);

            /** ExtendedTextMessage thumbnailWidth */
            thumbnailWidth?: (number|null);

            /** ExtendedTextMessage inviteLinkGroupType */
            inviteLinkGroupType?: (proto.Message.ExtendedTextMessage.InviteLinkGroupType|null);

            /** ExtendedTextMessage inviteLinkParentGroupSubjectV2 */
            inviteLinkParentGroupSubjectV2?: (string|null);

            /** ExtendedTextMessage inviteLinkParentGroupThumbnailV2 */
            inviteLinkParentGroupThumbnailV2?: (Uint8Array|null);

            /** ExtendedTextMessage inviteLinkGroupTypeV2 */
            inviteLinkGroupTypeV2?: (proto.Message.ExtendedTextMessage.InviteLinkGroupType|null);

            /** ExtendedTextMessage viewOnce */
            viewOnce?: (boolean|null);
        }

        /** Represents an ExtendedTextMessage. */
        class ExtendedTextMessage implements IExtendedTextMessage {

            /**
             * Constructs a new ExtendedTextMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IExtendedTextMessage);

            /** ExtendedTextMessage text. */
            public text: string;

            /** ExtendedTextMessage matchedText. */
            public matchedText: string;

            /** ExtendedTextMessage canonicalUrl. */
            public canonicalUrl: string;

            /** ExtendedTextMessage description. */
            public description: string;

            /** ExtendedTextMessage title. */
            public title: string;

            /** ExtendedTextMessage textArgb. */
            public textArgb: number;

            /** ExtendedTextMessage backgroundArgb. */
            public backgroundArgb: number;

            /** ExtendedTextMessage font. */
            public font: proto.Message.ExtendedTextMessage.FontType;

            /** ExtendedTextMessage previewType. */
            public previewType: proto.Message.ExtendedTextMessage.PreviewType;

            /** ExtendedTextMessage jpegThumbnail. */
            public jpegThumbnail: Uint8Array;

            /** ExtendedTextMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** ExtendedTextMessage doNotPlayInline. */
            public doNotPlayInline: boolean;

            /** ExtendedTextMessage thumbnailDirectPath. */
            public thumbnailDirectPath: string;

            /** ExtendedTextMessage thumbnailSha256. */
            public thumbnailSha256: Uint8Array;

            /** ExtendedTextMessage thumbnailEncSha256. */
            public thumbnailEncSha256: Uint8Array;

            /** ExtendedTextMessage mediaKey. */
            public mediaKey: Uint8Array;

            /** ExtendedTextMessage mediaKeyTimestamp. */
            public mediaKeyTimestamp: (number|Long);

            /** ExtendedTextMessage thumbnailHeight. */
            public thumbnailHeight: number;

            /** ExtendedTextMessage thumbnailWidth. */
            public thumbnailWidth: number;

            /** ExtendedTextMessage inviteLinkGroupType. */
            public inviteLinkGroupType: proto.Message.ExtendedTextMessage.InviteLinkGroupType;

            /** ExtendedTextMessage inviteLinkParentGroupSubjectV2. */
            public inviteLinkParentGroupSubjectV2: string;

            /** ExtendedTextMessage inviteLinkParentGroupThumbnailV2. */
            public inviteLinkParentGroupThumbnailV2: Uint8Array;

            /** ExtendedTextMessage inviteLinkGroupTypeV2. */
            public inviteLinkGroupTypeV2: proto.Message.ExtendedTextMessage.InviteLinkGroupType;

            /** ExtendedTextMessage viewOnce. */
            public viewOnce: boolean;

            /**
             * Creates a new ExtendedTextMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ExtendedTextMessage instance
             */
            public static create(properties?: proto.Message.IExtendedTextMessage): proto.Message.ExtendedTextMessage;

            /**
             * Encodes the specified ExtendedTextMessage message. Does not implicitly {@link proto.Message.ExtendedTextMessage.verify|verify} messages.
             * @param message ExtendedTextMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IExtendedTextMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ExtendedTextMessage message, length delimited. Does not implicitly {@link proto.Message.ExtendedTextMessage.verify|verify} messages.
             * @param message ExtendedTextMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IExtendedTextMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an ExtendedTextMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ExtendedTextMessage
             * @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): proto.Message.ExtendedTextMessage;

            /**
             * Decodes an ExtendedTextMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ExtendedTextMessage
             * @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)): proto.Message.ExtendedTextMessage;

            /**
             * Verifies an ExtendedTextMessage 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 ExtendedTextMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ExtendedTextMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.ExtendedTextMessage;

            /**
             * Creates a plain object from an ExtendedTextMessage message. Also converts values to other types if specified.
             * @param message ExtendedTextMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.ExtendedTextMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ExtendedTextMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace ExtendedTextMessage {

            /** FontType enum. */
            enum FontType {
                SYSTEM = 0,
                SYSTEM_TEXT = 1,
                FB_SCRIPT = 2,
                SYSTEM_BOLD = 6,
                MORNINGBREEZE_REGULAR = 7,
                CALISTOGA_REGULAR = 8,
                EXO2_EXTRABOLD = 9,
                COURIERPRIME_BOLD = 10
            }

            /** InviteLinkGroupType enum. */
            enum InviteLinkGroupType {
                DEFAULT = 0,
                PARENT = 1,
                SUB = 2,
                DEFAULT_SUB = 3
            }

            /** PreviewType enum. */
            enum PreviewType {
                NONE = 0,
                VIDEO = 1,
                PLACEHOLDER = 4,
                IMAGE = 5
            }
        }

        /** Properties of an ExtendedTextMessageWithParentKey. */
        interface IExtendedTextMessageWithParentKey {

            /** ExtendedTextMessageWithParentKey key */
            key?: (proto.IMessageKey|null);

            /** ExtendedTextMessageWithParentKey extendedTextMessage */
            extendedTextMessage?: (proto.Message.IExtendedTextMessage|null);
        }

        /** Represents an ExtendedTextMessageWithParentKey. */
        class ExtendedTextMessageWithParentKey implements IExtendedTextMessageWithParentKey {

            /**
             * Constructs a new ExtendedTextMessageWithParentKey.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IExtendedTextMessageWithParentKey);

            /** ExtendedTextMessageWithParentKey key. */
            public key?: (proto.IMessageKey|null);

            /** ExtendedTextMessageWithParentKey extendedTextMessage. */
            public extendedTextMessage?: (proto.Message.IExtendedTextMessage|null);

            /**
             * Creates a new ExtendedTextMessageWithParentKey instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ExtendedTextMessageWithParentKey instance
             */
            public static create(properties?: proto.Message.IExtendedTextMessageWithParentKey): proto.Message.ExtendedTextMessageWithParentKey;

            /**
             * Encodes the specified ExtendedTextMessageWithParentKey message. Does not implicitly {@link proto.Message.ExtendedTextMessageWithParentKey.verify|verify} messages.
             * @param message ExtendedTextMessageWithParentKey message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IExtendedTextMessageWithParentKey, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ExtendedTextMessageWithParentKey message, length delimited. Does not implicitly {@link proto.Message.ExtendedTextMessageWithParentKey.verify|verify} messages.
             * @param message ExtendedTextMessageWithParentKey message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IExtendedTextMessageWithParentKey, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an ExtendedTextMessageWithParentKey message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ExtendedTextMessageWithParentKey
             * @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): proto.Message.ExtendedTextMessageWithParentKey;

            /**
             * Decodes an ExtendedTextMessageWithParentKey message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ExtendedTextMessageWithParentKey
             * @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)): proto.Message.ExtendedTextMessageWithParentKey;

            /**
             * Verifies an ExtendedTextMessageWithParentKey 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 ExtendedTextMessageWithParentKey message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ExtendedTextMessageWithParentKey
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.ExtendedTextMessageWithParentKey;

            /**
             * Creates a plain object from an ExtendedTextMessageWithParentKey message. Also converts values to other types if specified.
             * @param message ExtendedTextMessageWithParentKey
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.ExtendedTextMessageWithParentKey, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ExtendedTextMessageWithParentKey to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a FutureProofMessage. */
        interface IFutureProofMessage {

            /** FutureProofMessage message */
            message?: (proto.IMessage|null);
        }

        /** Represents a FutureProofMessage. */
        class FutureProofMessage implements IFutureProofMessage {

            /**
             * Constructs a new FutureProofMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IFutureProofMessage);

            /** FutureProofMessage message. */
            public message?: (proto.IMessage|null);

            /**
             * Creates a new FutureProofMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns FutureProofMessage instance
             */
            public static create(properties?: proto.Message.IFutureProofMessage): proto.Message.FutureProofMessage;

            /**
             * Encodes the specified FutureProofMessage message. Does not implicitly {@link proto.Message.FutureProofMessage.verify|verify} messages.
             * @param message FutureProofMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IFutureProofMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified FutureProofMessage message, length delimited. Does not implicitly {@link proto.Message.FutureProofMessage.verify|verify} messages.
             * @param message FutureProofMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IFutureProofMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a FutureProofMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns FutureProofMessage
             * @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): proto.Message.FutureProofMessage;

            /**
             * Decodes a FutureProofMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns FutureProofMessage
             * @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)): proto.Message.FutureProofMessage;

            /**
             * Verifies a FutureProofMessage 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 FutureProofMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns FutureProofMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.FutureProofMessage;

            /**
             * Creates a plain object from a FutureProofMessage message. Also converts values to other types if specified.
             * @param message FutureProofMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.FutureProofMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this FutureProofMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a GroupInviteMessage. */
        interface IGroupInviteMessage {

            /** GroupInviteMessage groupJid */
            groupJid?: (string|null);

            /** GroupInviteMessage inviteCode */
            inviteCode?: (string|null);

            /** GroupInviteMessage inviteExpiration */
            inviteExpiration?: (number|Long|null);

            /** GroupInviteMessage groupName */
            groupName?: (string|null);

            /** GroupInviteMessage jpegThumbnail */
            jpegThumbnail?: (Uint8Array|null);

            /** GroupInviteMessage caption */
            caption?: (string|null);

            /** GroupInviteMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** GroupInviteMessage groupType */
            groupType?: (proto.Message.GroupInviteMessage.GroupType|null);
        }

        /** Represents a GroupInviteMessage. */
        class GroupInviteMessage implements IGroupInviteMessage {

            /**
             * Constructs a new GroupInviteMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IGroupInviteMessage);

            /** GroupInviteMessage groupJid. */
            public groupJid: string;

            /** GroupInviteMessage inviteCode. */
            public inviteCode: string;

            /** GroupInviteMessage inviteExpiration. */
            public inviteExpiration: (number|Long);

            /** GroupInviteMessage groupName. */
            public groupName: string;

            /** GroupInviteMessage jpegThumbnail. */
            public jpegThumbnail: Uint8Array;

            /** GroupInviteMessage caption. */
            public caption: string;

            /** GroupInviteMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** GroupInviteMessage groupType. */
            public groupType: proto.Message.GroupInviteMessage.GroupType;

            /**
             * Creates a new GroupInviteMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns GroupInviteMessage instance
             */
            public static create(properties?: proto.Message.IGroupInviteMessage): proto.Message.GroupInviteMessage;

            /**
             * Encodes the specified GroupInviteMessage message. Does not implicitly {@link proto.Message.GroupInviteMessage.verify|verify} messages.
             * @param message GroupInviteMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IGroupInviteMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified GroupInviteMessage message, length delimited. Does not implicitly {@link proto.Message.GroupInviteMessage.verify|verify} messages.
             * @param message GroupInviteMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IGroupInviteMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a GroupInviteMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns GroupInviteMessage
             * @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): proto.Message.GroupInviteMessage;

            /**
             * Decodes a GroupInviteMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns GroupInviteMessage
             * @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)): proto.Message.GroupInviteMessage;

            /**
             * Verifies a GroupInviteMessage 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 GroupInviteMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns GroupInviteMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.GroupInviteMessage;

            /**
             * Creates a plain object from a GroupInviteMessage message. Also converts values to other types if specified.
             * @param message GroupInviteMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.GroupInviteMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this GroupInviteMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace GroupInviteMessage {

            /** GroupType enum. */
            enum GroupType {
                DEFAULT = 0,
                PARENT = 1
            }
        }

        /** Properties of a HighlyStructuredMessage. */
        interface IHighlyStructuredMessage {

            /** HighlyStructuredMessage namespace */
            namespace?: (string|null);

            /** HighlyStructuredMessage elementName */
            elementName?: (string|null);

            /** HighlyStructuredMessage params */
            params?: (string[]|null);

            /** HighlyStructuredMessage fallbackLg */
            fallbackLg?: (string|null);

            /** HighlyStructuredMessage fallbackLc */
            fallbackLc?: (string|null);

            /** HighlyStructuredMessage localizableParams */
            localizableParams?: (proto.Message.HighlyStructuredMessage.IHSMLocalizableParameter[]|null);

            /** HighlyStructuredMessage deterministicLg */
            deterministicLg?: (string|null);

            /** HighlyStructuredMessage deterministicLc */
            deterministicLc?: (string|null);

            /** HighlyStructuredMessage hydratedHsm */
            hydratedHsm?: (proto.Message.ITemplateMessage|null);
        }

        /** Represents a HighlyStructuredMessage. */
        class HighlyStructuredMessage implements IHighlyStructuredMessage {

            /**
             * Constructs a new HighlyStructuredMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IHighlyStructuredMessage);

            /** HighlyStructuredMessage namespace. */
            public namespace: string;

            /** HighlyStructuredMessage elementName. */
            public elementName: string;

            /** HighlyStructuredMessage params. */
            public params: string[];

            /** HighlyStructuredMessage fallbackLg. */
            public fallbackLg: string;

            /** HighlyStructuredMessage fallbackLc. */
            public fallbackLc: string;

            /** HighlyStructuredMessage localizableParams. */
            public localizableParams: proto.Message.HighlyStructuredMessage.IHSMLocalizableParameter[];

            /** HighlyStructuredMessage deterministicLg. */
            public deterministicLg: string;

            /** HighlyStructuredMessage deterministicLc. */
            public deterministicLc: string;

            /** HighlyStructuredMessage hydratedHsm. */
            public hydratedHsm?: (proto.Message.ITemplateMessage|null);

            /**
             * Creates a new HighlyStructuredMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns HighlyStructuredMessage instance
             */
            public static create(properties?: proto.Message.IHighlyStructuredMessage): proto.Message.HighlyStructuredMessage;

            /**
             * Encodes the specified HighlyStructuredMessage message. Does not implicitly {@link proto.Message.HighlyStructuredMessage.verify|verify} messages.
             * @param message HighlyStructuredMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IHighlyStructuredMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified HighlyStructuredMessage message, length delimited. Does not implicitly {@link proto.Message.HighlyStructuredMessage.verify|verify} messages.
             * @param message HighlyStructuredMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IHighlyStructuredMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a HighlyStructuredMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns HighlyStructuredMessage
             * @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): proto.Message.HighlyStructuredMessage;

            /**
             * Decodes a HighlyStructuredMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns HighlyStructuredMessage
             * @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)): proto.Message.HighlyStructuredMessage;

            /**
             * Verifies a HighlyStructuredMessage 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 HighlyStructuredMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns HighlyStructuredMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.HighlyStructuredMessage;

            /**
             * Creates a plain object from a HighlyStructuredMessage message. Also converts values to other types if specified.
             * @param message HighlyStructuredMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.HighlyStructuredMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this HighlyStructuredMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace HighlyStructuredMessage {

            /** Properties of a HSMLocalizableParameter. */
            interface IHSMLocalizableParameter {

                /** HSMLocalizableParameter default */
                "default"?: (string|null);

                /** HSMLocalizableParameter currency */
                currency?: (proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.IHSMCurrency|null);

                /** HSMLocalizableParameter dateTime */
                dateTime?: (proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.IHSMDateTime|null);
            }

            /** Represents a HSMLocalizableParameter. */
            class HSMLocalizableParameter implements IHSMLocalizableParameter {

                /**
                 * Constructs a new HSMLocalizableParameter.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.HighlyStructuredMessage.IHSMLocalizableParameter);

                /** HSMLocalizableParameter default. */
                public default: string;

                /** HSMLocalizableParameter currency. */
                public currency?: (proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.IHSMCurrency|null);

                /** HSMLocalizableParameter dateTime. */
                public dateTime?: (proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.IHSMDateTime|null);

                /** HSMLocalizableParameter paramOneof. */
                public paramOneof?: ("currency"|"dateTime");

                /**
                 * Creates a new HSMLocalizableParameter instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns HSMLocalizableParameter instance
                 */
                public static create(properties?: proto.Message.HighlyStructuredMessage.IHSMLocalizableParameter): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter;

                /**
                 * Encodes the specified HSMLocalizableParameter message. Does not implicitly {@link proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.verify|verify} messages.
                 * @param message HSMLocalizableParameter message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.HighlyStructuredMessage.IHSMLocalizableParameter, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified HSMLocalizableParameter message, length delimited. Does not implicitly {@link proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.verify|verify} messages.
                 * @param message HSMLocalizableParameter message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.HighlyStructuredMessage.IHSMLocalizableParameter, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a HSMLocalizableParameter message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns HSMLocalizableParameter
                 * @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): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter;

                /**
                 * Decodes a HSMLocalizableParameter message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns HSMLocalizableParameter
                 * @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)): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter;

                /**
                 * Verifies a HSMLocalizableParameter 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 HSMLocalizableParameter message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns HSMLocalizableParameter
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter;

                /**
                 * Creates a plain object from a HSMLocalizableParameter message. Also converts values to other types if specified.
                 * @param message HSMLocalizableParameter
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this HSMLocalizableParameter to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            namespace HSMLocalizableParameter {

                /** Properties of a HSMCurrency. */
                interface IHSMCurrency {

                    /** HSMCurrency currencyCode */
                    currencyCode?: (string|null);

                    /** HSMCurrency amount1000 */
                    amount1000?: (number|Long|null);
                }

                /** Represents a HSMCurrency. */
                class HSMCurrency implements IHSMCurrency {

                    /**
                     * Constructs a new HSMCurrency.
                     * @param [properties] Properties to set
                     */
                    constructor(properties?: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.IHSMCurrency);

                    /** HSMCurrency currencyCode. */
                    public currencyCode: string;

                    /** HSMCurrency amount1000. */
                    public amount1000: (number|Long);

                    /**
                     * Creates a new HSMCurrency instance using the specified properties.
                     * @param [properties] Properties to set
                     * @returns HSMCurrency instance
                     */
                    public static create(properties?: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.IHSMCurrency): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency;

                    /**
                     * Encodes the specified HSMCurrency message. Does not implicitly {@link proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.verify|verify} messages.
                     * @param message HSMCurrency message or plain object to encode
                     * @param [writer] Writer to encode to
                     * @returns Writer
                     */
                    public static encode(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.IHSMCurrency, writer?: $protobuf.Writer): $protobuf.Writer;

                    /**
                     * Encodes the specified HSMCurrency message, length delimited. Does not implicitly {@link proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.verify|verify} messages.
                     * @param message HSMCurrency message or plain object to encode
                     * @param [writer] Writer to encode to
                     * @returns Writer
                     */
                    public static encodeDelimited(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.IHSMCurrency, writer?: $protobuf.Writer): $protobuf.Writer;

                    /**
                     * Decodes a HSMCurrency message from the specified reader or buffer.
                     * @param reader Reader or buffer to decode from
                     * @param [length] Message length if known beforehand
                     * @returns HSMCurrency
                     * @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): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency;

                    /**
                     * Decodes a HSMCurrency message from the specified reader or buffer, length delimited.
                     * @param reader Reader or buffer to decode from
                     * @returns HSMCurrency
                     * @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)): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency;

                    /**
                     * Verifies a HSMCurrency 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 HSMCurrency message from a plain object. Also converts values to their respective internal types.
                     * @param object Plain object
                     * @returns HSMCurrency
                     */
                    public static fromObject(object: { [k: string]: any }): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency;

                    /**
                     * Creates a plain object from a HSMCurrency message. Also converts values to other types if specified.
                     * @param message HSMCurrency
                     * @param [options] Conversion options
                     * @returns Plain object
                     */
                    public static toObject(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency, options?: $protobuf.IConversionOptions): { [k: string]: any };

                    /**
                     * Converts this HSMCurrency to JSON.
                     * @returns JSON object
                     */
                    public toJSON(): { [k: string]: any };
                }

                /** Properties of a HSMDateTime. */
                interface IHSMDateTime {

                    /** HSMDateTime component */
                    component?: (proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.IHSMDateTimeComponent|null);

                    /** HSMDateTime unixEpoch */
                    unixEpoch?: (proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.IHSMDateTimeUnixEpoch|null);
                }

                /** Represents a HSMDateTime. */
                class HSMDateTime implements IHSMDateTime {

                    /**
                     * Constructs a new HSMDateTime.
                     * @param [properties] Properties to set
                     */
                    constructor(properties?: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.IHSMDateTime);

                    /** HSMDateTime component. */
                    public component?: (proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.IHSMDateTimeComponent|null);

                    /** HSMDateTime unixEpoch. */
                    public unixEpoch?: (proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.IHSMDateTimeUnixEpoch|null);

                    /** HSMDateTime datetimeOneof. */
                    public datetimeOneof?: ("component"|"unixEpoch");

                    /**
                     * Creates a new HSMDateTime instance using the specified properties.
                     * @param [properties] Properties to set
                     * @returns HSMDateTime instance
                     */
                    public static create(properties?: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.IHSMDateTime): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime;

                    /**
                     * Encodes the specified HSMDateTime message. Does not implicitly {@link proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.verify|verify} messages.
                     * @param message HSMDateTime message or plain object to encode
                     * @param [writer] Writer to encode to
                     * @returns Writer
                     */
                    public static encode(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.IHSMDateTime, writer?: $protobuf.Writer): $protobuf.Writer;

                    /**
                     * Encodes the specified HSMDateTime message, length delimited. Does not implicitly {@link proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.verify|verify} messages.
                     * @param message HSMDateTime message or plain object to encode
                     * @param [writer] Writer to encode to
                     * @returns Writer
                     */
                    public static encodeDelimited(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.IHSMDateTime, writer?: $protobuf.Writer): $protobuf.Writer;

                    /**
                     * Decodes a HSMDateTime message from the specified reader or buffer.
                     * @param reader Reader or buffer to decode from
                     * @param [length] Message length if known beforehand
                     * @returns HSMDateTime
                     * @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): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime;

                    /**
                     * Decodes a HSMDateTime message from the specified reader or buffer, length delimited.
                     * @param reader Reader or buffer to decode from
                     * @returns HSMDateTime
                     * @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)): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime;

                    /**
                     * Verifies a HSMDateTime 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 HSMDateTime message from a plain object. Also converts values to their respective internal types.
                     * @param object Plain object
                     * @returns HSMDateTime
                     */
                    public static fromObject(object: { [k: string]: any }): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime;

                    /**
                     * Creates a plain object from a HSMDateTime message. Also converts values to other types if specified.
                     * @param message HSMDateTime
                     * @param [options] Conversion options
                     * @returns Plain object
                     */
                    public static toObject(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime, options?: $protobuf.IConversionOptions): { [k: string]: any };

                    /**
                     * Converts this HSMDateTime to JSON.
                     * @returns JSON object
                     */
                    public toJSON(): { [k: string]: any };
                }

                namespace HSMDateTime {

                    /** Properties of a HSMDateTimeComponent. */
                    interface IHSMDateTimeComponent {

                        /** HSMDateTimeComponent dayOfWeek */
                        dayOfWeek?: (proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType|null);

                        /** HSMDateTimeComponent year */
                        year?: (number|null);

                        /** HSMDateTimeComponent month */
                        month?: (number|null);

                        /** HSMDateTimeComponent dayOfMonth */
                        dayOfMonth?: (number|null);

                        /** HSMDateTimeComponent hour */
                        hour?: (number|null);

                        /** HSMDateTimeComponent minute */
                        minute?: (number|null);

                        /** HSMDateTimeComponent calendar */
                        calendar?: (proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType|null);
                    }

                    /** Represents a HSMDateTimeComponent. */
                    class HSMDateTimeComponent implements IHSMDateTimeComponent {

                        /**
                         * Constructs a new HSMDateTimeComponent.
                         * @param [properties] Properties to set
                         */
                        constructor(properties?: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.IHSMDateTimeComponent);

                        /** HSMDateTimeComponent dayOfWeek. */
                        public dayOfWeek: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType;

                        /** HSMDateTimeComponent year. */
                        public year: number;

                        /** HSMDateTimeComponent month. */
                        public month: number;

                        /** HSMDateTimeComponent dayOfMonth. */
                        public dayOfMonth: number;

                        /** HSMDateTimeComponent hour. */
                        public hour: number;

                        /** HSMDateTimeComponent minute. */
                        public minute: number;

                        /** HSMDateTimeComponent calendar. */
                        public calendar: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType;

                        /**
                         * Creates a new HSMDateTimeComponent instance using the specified properties.
                         * @param [properties] Properties to set
                         * @returns HSMDateTimeComponent instance
                         */
                        public static create(properties?: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.IHSMDateTimeComponent): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent;

                        /**
                         * Encodes the specified HSMDateTimeComponent message. Does not implicitly {@link proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.verify|verify} messages.
                         * @param message HSMDateTimeComponent message or plain object to encode
                         * @param [writer] Writer to encode to
                         * @returns Writer
                         */
                        public static encode(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.IHSMDateTimeComponent, writer?: $protobuf.Writer): $protobuf.Writer;

                        /**
                         * Encodes the specified HSMDateTimeComponent message, length delimited. Does not implicitly {@link proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.verify|verify} messages.
                         * @param message HSMDateTimeComponent message or plain object to encode
                         * @param [writer] Writer to encode to
                         * @returns Writer
                         */
                        public static encodeDelimited(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.IHSMDateTimeComponent, writer?: $protobuf.Writer): $protobuf.Writer;

                        /**
                         * Decodes a HSMDateTimeComponent message from the specified reader or buffer.
                         * @param reader Reader or buffer to decode from
                         * @param [length] Message length if known beforehand
                         * @returns HSMDateTimeComponent
                         * @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): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent;

                        /**
                         * Decodes a HSMDateTimeComponent message from the specified reader or buffer, length delimited.
                         * @param reader Reader or buffer to decode from
                         * @returns HSMDateTimeComponent
                         * @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)): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent;

                        /**
                         * Verifies a HSMDateTimeComponent 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 HSMDateTimeComponent message from a plain object. Also converts values to their respective internal types.
                         * @param object Plain object
                         * @returns HSMDateTimeComponent
                         */
                        public static fromObject(object: { [k: string]: any }): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent;

                        /**
                         * Creates a plain object from a HSMDateTimeComponent message. Also converts values to other types if specified.
                         * @param message HSMDateTimeComponent
                         * @param [options] Conversion options
                         * @returns Plain object
                         */
                        public static toObject(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent, options?: $protobuf.IConversionOptions): { [k: string]: any };

                        /**
                         * Converts this HSMDateTimeComponent to JSON.
                         * @returns JSON object
                         */
                        public toJSON(): { [k: string]: any };
                    }

                    namespace HSMDateTimeComponent {

                        /** CalendarType enum. */
                        enum CalendarType {
                            GREGORIAN = 1,
                            SOLAR_HIJRI = 2
                        }

                        /** DayOfWeekType enum. */
                        enum DayOfWeekType {
                            MONDAY = 1,
                            TUESDAY = 2,
                            WEDNESDAY = 3,
                            THURSDAY = 4,
                            FRIDAY = 5,
                            SATURDAY = 6,
                            SUNDAY = 7
                        }
                    }

                    /** Properties of a HSMDateTimeUnixEpoch. */
                    interface IHSMDateTimeUnixEpoch {

                        /** HSMDateTimeUnixEpoch timestamp */
                        timestamp?: (number|Long|null);
                    }

                    /** Represents a HSMDateTimeUnixEpoch. */
                    class HSMDateTimeUnixEpoch implements IHSMDateTimeUnixEpoch {

                        /**
                         * Constructs a new HSMDateTimeUnixEpoch.
                         * @param [properties] Properties to set
                         */
                        constructor(properties?: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.IHSMDateTimeUnixEpoch);

                        /** HSMDateTimeUnixEpoch timestamp. */
                        public timestamp: (number|Long);

                        /**
                         * Creates a new HSMDateTimeUnixEpoch instance using the specified properties.
                         * @param [properties] Properties to set
                         * @returns HSMDateTimeUnixEpoch instance
                         */
                        public static create(properties?: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.IHSMDateTimeUnixEpoch): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch;

                        /**
                         * Encodes the specified HSMDateTimeUnixEpoch message. Does not implicitly {@link proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch.verify|verify} messages.
                         * @param message HSMDateTimeUnixEpoch message or plain object to encode
                         * @param [writer] Writer to encode to
                         * @returns Writer
                         */
                        public static encode(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.IHSMDateTimeUnixEpoch, writer?: $protobuf.Writer): $protobuf.Writer;

                        /**
                         * Encodes the specified HSMDateTimeUnixEpoch message, length delimited. Does not implicitly {@link proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch.verify|verify} messages.
                         * @param message HSMDateTimeUnixEpoch message or plain object to encode
                         * @param [writer] Writer to encode to
                         * @returns Writer
                         */
                        public static encodeDelimited(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.IHSMDateTimeUnixEpoch, writer?: $protobuf.Writer): $protobuf.Writer;

                        /**
                         * Decodes a HSMDateTimeUnixEpoch message from the specified reader or buffer.
                         * @param reader Reader or buffer to decode from
                         * @param [length] Message length if known beforehand
                         * @returns HSMDateTimeUnixEpoch
                         * @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): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch;

                        /**
                         * Decodes a HSMDateTimeUnixEpoch message from the specified reader or buffer, length delimited.
                         * @param reader Reader or buffer to decode from
                         * @returns HSMDateTimeUnixEpoch
                         * @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)): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch;

                        /**
                         * Verifies a HSMDateTimeUnixEpoch 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 HSMDateTimeUnixEpoch message from a plain object. Also converts values to their respective internal types.
                         * @param object Plain object
                         * @returns HSMDateTimeUnixEpoch
                         */
                        public static fromObject(object: { [k: string]: any }): proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch;

                        /**
                         * Creates a plain object from a HSMDateTimeUnixEpoch message. Also converts values to other types if specified.
                         * @param message HSMDateTimeUnixEpoch
                         * @param [options] Conversion options
                         * @returns Plain object
                         */
                        public static toObject(message: proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch, options?: $protobuf.IConversionOptions): { [k: string]: any };

                        /**
                         * Converts this HSMDateTimeUnixEpoch to JSON.
                         * @returns JSON object
                         */
                        public toJSON(): { [k: string]: any };
                    }
                }
            }
        }

        /** Properties of a HistorySyncNotification. */
        interface IHistorySyncNotification {

            /** HistorySyncNotification fileSha256 */
            fileSha256?: (Uint8Array|null);

            /** HistorySyncNotification fileLength */
            fileLength?: (number|Long|null);

            /** HistorySyncNotification mediaKey */
            mediaKey?: (Uint8Array|null);

            /** HistorySyncNotification fileEncSha256 */
            fileEncSha256?: (Uint8Array|null);

            /** HistorySyncNotification directPath */
            directPath?: (string|null);

            /** HistorySyncNotification syncType */
            syncType?: (proto.Message.HistorySyncNotification.HistorySyncType|null);

            /** HistorySyncNotification chunkOrder */
            chunkOrder?: (number|null);

            /** HistorySyncNotification originalMessageId */
            originalMessageId?: (string|null);

            /** HistorySyncNotification progress */
            progress?: (number|null);

            /** HistorySyncNotification oldestMsgInChunkTimestampSec */
            oldestMsgInChunkTimestampSec?: (number|Long|null);

            /** HistorySyncNotification initialHistBootstrapInlinePayload */
            initialHistBootstrapInlinePayload?: (Uint8Array|null);

            /** HistorySyncNotification peerDataRequestSessionId */
            peerDataRequestSessionId?: (string|null);
        }

        /** Represents a HistorySyncNotification. */
        class HistorySyncNotification implements IHistorySyncNotification {

            /**
             * Constructs a new HistorySyncNotification.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IHistorySyncNotification);

            /** HistorySyncNotification fileSha256. */
            public fileSha256: Uint8Array;

            /** HistorySyncNotification fileLength. */
            public fileLength: (number|Long);

            /** HistorySyncNotification mediaKey. */
            public mediaKey: Uint8Array;

            /** HistorySyncNotification fileEncSha256. */
            public fileEncSha256: Uint8Array;

            /** HistorySyncNotification directPath. */
            public directPath: string;

            /** HistorySyncNotification syncType. */
            public syncType: proto.Message.HistorySyncNotification.HistorySyncType;

            /** HistorySyncNotification chunkOrder. */
            public chunkOrder: number;

            /** HistorySyncNotification originalMessageId. */
            public originalMessageId: string;

            /** HistorySyncNotification progress. */
            public progress: number;

            /** HistorySyncNotification oldestMsgInChunkTimestampSec. */
            public oldestMsgInChunkTimestampSec: (number|Long);

            /** HistorySyncNotification initialHistBootstrapInlinePayload. */
            public initialHistBootstrapInlinePayload: Uint8Array;

            /** HistorySyncNotification peerDataRequestSessionId. */
            public peerDataRequestSessionId: string;

            /**
             * Creates a new HistorySyncNotification instance using the specified properties.
             * @param [properties] Properties to set
             * @returns HistorySyncNotification instance
             */
            public static create(properties?: proto.Message.IHistorySyncNotification): proto.Message.HistorySyncNotification;

            /**
             * Encodes the specified HistorySyncNotification message. Does not implicitly {@link proto.Message.HistorySyncNotification.verify|verify} messages.
             * @param message HistorySyncNotification message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IHistorySyncNotification, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified HistorySyncNotification message, length delimited. Does not implicitly {@link proto.Message.HistorySyncNotification.verify|verify} messages.
             * @param message HistorySyncNotification message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IHistorySyncNotification, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a HistorySyncNotification message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns HistorySyncNotification
             * @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): proto.Message.HistorySyncNotification;

            /**
             * Decodes a HistorySyncNotification message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns HistorySyncNotification
             * @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)): proto.Message.HistorySyncNotification;

            /**
             * Verifies a HistorySyncNotification 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 HistorySyncNotification message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns HistorySyncNotification
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.HistorySyncNotification;

            /**
             * Creates a plain object from a HistorySyncNotification message. Also converts values to other types if specified.
             * @param message HistorySyncNotification
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.HistorySyncNotification, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this HistorySyncNotification to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace HistorySyncNotification {

            /** HistorySyncType enum. */
            enum HistorySyncType {
                INITIAL_BOOTSTRAP = 0,
                INITIAL_STATUS_V3 = 1,
                FULL = 2,
                RECENT = 3,
                PUSH_NAME = 4,
                NON_BLOCKING_DATA = 5,
                ON_DEMAND = 6
            }
        }

        /** Properties of an ImageMessage. */
        interface IImageMessage {

            /** ImageMessage url */
            url?: (string|null);

            /** ImageMessage mimetype */
            mimetype?: (string|null);

            /** ImageMessage caption */
            caption?: (string|null);

            /** ImageMessage fileSha256 */
            fileSha256?: (Uint8Array|null);

            /** ImageMessage fileLength */
            fileLength?: (number|Long|null);

            /** ImageMessage height */
            height?: (number|null);

            /** ImageMessage width */
            width?: (number|null);

            /** ImageMessage mediaKey */
            mediaKey?: (Uint8Array|null);

            /** ImageMessage fileEncSha256 */
            fileEncSha256?: (Uint8Array|null);

            /** ImageMessage interactiveAnnotations */
            interactiveAnnotations?: (proto.IInteractiveAnnotation[]|null);

            /** ImageMessage directPath */
            directPath?: (string|null);

            /** ImageMessage mediaKeyTimestamp */
            mediaKeyTimestamp?: (number|Long|null);

            /** ImageMessage jpegThumbnail */
            jpegThumbnail?: (Uint8Array|null);

            /** ImageMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** ImageMessage firstScanSidecar */
            firstScanSidecar?: (Uint8Array|null);

            /** ImageMessage firstScanLength */
            firstScanLength?: (number|null);

            /** ImageMessage experimentGroupId */
            experimentGroupId?: (number|null);

            /** ImageMessage scansSidecar */
            scansSidecar?: (Uint8Array|null);

            /** ImageMessage scanLengths */
            scanLengths?: (number[]|null);

            /** ImageMessage midQualityFileSha256 */
            midQualityFileSha256?: (Uint8Array|null);

            /** ImageMessage midQualityFileEncSha256 */
            midQualityFileEncSha256?: (Uint8Array|null);

            /** ImageMessage viewOnce */
            viewOnce?: (boolean|null);

            /** ImageMessage thumbnailDirectPath */
            thumbnailDirectPath?: (string|null);

            /** ImageMessage thumbnailSha256 */
            thumbnailSha256?: (Uint8Array|null);

            /** ImageMessage thumbnailEncSha256 */
            thumbnailEncSha256?: (Uint8Array|null);

            /** ImageMessage staticUrl */
            staticUrl?: (string|null);

            /** ImageMessage annotations */
            annotations?: (proto.IInteractiveAnnotation[]|null);
        }

        /** Represents an ImageMessage. */
        class ImageMessage implements IImageMessage {

            /**
             * Constructs a new ImageMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IImageMessage);

            /** ImageMessage url. */
            public url: string;

            /** ImageMessage mimetype. */
            public mimetype: string;

            /** ImageMessage caption. */
            public caption: string;

            /** ImageMessage fileSha256. */
            public fileSha256: Uint8Array;

            /** ImageMessage fileLength. */
            public fileLength: (number|Long);

            /** ImageMessage height. */
            public height: number;

            /** ImageMessage width. */
            public width: number;

            /** ImageMessage mediaKey. */
            public mediaKey: Uint8Array;

            /** ImageMessage fileEncSha256. */
            public fileEncSha256: Uint8Array;

            /** ImageMessage interactiveAnnotations. */
            public interactiveAnnotations: proto.IInteractiveAnnotation[];

            /** ImageMessage directPath. */
            public directPath: string;

            /** ImageMessage mediaKeyTimestamp. */
            public mediaKeyTimestamp: (number|Long);

            /** ImageMessage jpegThumbnail. */
            public jpegThumbnail: Uint8Array;

            /** ImageMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** ImageMessage firstScanSidecar. */
            public firstScanSidecar: Uint8Array;

            /** ImageMessage firstScanLength. */
            public firstScanLength: number;

            /** ImageMessage experimentGroupId. */
            public experimentGroupId: number;

            /** ImageMessage scansSidecar. */
            public scansSidecar: Uint8Array;

            /** ImageMessage scanLengths. */
            public scanLengths: number[];

            /** ImageMessage midQualityFileSha256. */
            public midQualityFileSha256: Uint8Array;

            /** ImageMessage midQualityFileEncSha256. */
            public midQualityFileEncSha256: Uint8Array;

            /** ImageMessage viewOnce. */
            public viewOnce: boolean;

            /** ImageMessage thumbnailDirectPath. */
            public thumbnailDirectPath: string;

            /** ImageMessage thumbnailSha256. */
            public thumbnailSha256: Uint8Array;

            /** ImageMessage thumbnailEncSha256. */
            public thumbnailEncSha256: Uint8Array;

            /** ImageMessage staticUrl. */
            public staticUrl: string;

            /** ImageMessage annotations. */
            public annotations: proto.IInteractiveAnnotation[];

            /**
             * Creates a new ImageMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ImageMessage instance
             */
            public static create(properties?: proto.Message.IImageMessage): proto.Message.ImageMessage;

            /**
             * Encodes the specified ImageMessage message. Does not implicitly {@link proto.Message.ImageMessage.verify|verify} messages.
             * @param message ImageMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IImageMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ImageMessage message, length delimited. Does not implicitly {@link proto.Message.ImageMessage.verify|verify} messages.
             * @param message ImageMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IImageMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an ImageMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ImageMessage
             * @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): proto.Message.ImageMessage;

            /**
             * Decodes an ImageMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ImageMessage
             * @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)): proto.Message.ImageMessage;

            /**
             * Verifies an ImageMessage 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 ImageMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ImageMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.ImageMessage;

            /**
             * Creates a plain object from an ImageMessage message. Also converts values to other types if specified.
             * @param message ImageMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.ImageMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ImageMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an InitialSecurityNotificationSettingSync. */
        interface IInitialSecurityNotificationSettingSync {

            /** InitialSecurityNotificationSettingSync securityNotificationEnabled */
            securityNotificationEnabled?: (boolean|null);
        }

        /** Represents an InitialSecurityNotificationSettingSync. */
        class InitialSecurityNotificationSettingSync implements IInitialSecurityNotificationSettingSync {

            /**
             * Constructs a new InitialSecurityNotificationSettingSync.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IInitialSecurityNotificationSettingSync);

            /** InitialSecurityNotificationSettingSync securityNotificationEnabled. */
            public securityNotificationEnabled: boolean;

            /**
             * Creates a new InitialSecurityNotificationSettingSync instance using the specified properties.
             * @param [properties] Properties to set
             * @returns InitialSecurityNotificationSettingSync instance
             */
            public static create(properties?: proto.Message.IInitialSecurityNotificationSettingSync): proto.Message.InitialSecurityNotificationSettingSync;

            /**
             * Encodes the specified InitialSecurityNotificationSettingSync message. Does not implicitly {@link proto.Message.InitialSecurityNotificationSettingSync.verify|verify} messages.
             * @param message InitialSecurityNotificationSettingSync message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IInitialSecurityNotificationSettingSync, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified InitialSecurityNotificationSettingSync message, length delimited. Does not implicitly {@link proto.Message.InitialSecurityNotificationSettingSync.verify|verify} messages.
             * @param message InitialSecurityNotificationSettingSync message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IInitialSecurityNotificationSettingSync, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an InitialSecurityNotificationSettingSync message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns InitialSecurityNotificationSettingSync
             * @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): proto.Message.InitialSecurityNotificationSettingSync;

            /**
             * Decodes an InitialSecurityNotificationSettingSync message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns InitialSecurityNotificationSettingSync
             * @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)): proto.Message.InitialSecurityNotificationSettingSync;

            /**
             * Verifies an InitialSecurityNotificationSettingSync 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 InitialSecurityNotificationSettingSync message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns InitialSecurityNotificationSettingSync
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.InitialSecurityNotificationSettingSync;

            /**
             * Creates a plain object from an InitialSecurityNotificationSettingSync message. Also converts values to other types if specified.
             * @param message InitialSecurityNotificationSettingSync
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.InitialSecurityNotificationSettingSync, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this InitialSecurityNotificationSettingSync to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an InteractiveMessage. */
        interface IInteractiveMessage {

            /** InteractiveMessage header */
            header?: (proto.Message.InteractiveMessage.IHeader|null);

            /** InteractiveMessage body */
            body?: (proto.Message.InteractiveMessage.IBody|null);

            /** InteractiveMessage footer */
            footer?: (proto.Message.InteractiveMessage.IFooter|null);

            /** InteractiveMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** InteractiveMessage shopStorefrontMessage */
            shopStorefrontMessage?: (proto.Message.InteractiveMessage.IShopMessage|null);

            /** InteractiveMessage collectionMessage */
            collectionMessage?: (proto.Message.InteractiveMessage.ICollectionMessage|null);

            /** InteractiveMessage nativeFlowMessage */
            nativeFlowMessage?: (proto.Message.InteractiveMessage.INativeFlowMessage|null);

            /** InteractiveMessage carouselMessage */
            carouselMessage?: (proto.Message.InteractiveMessage.ICarouselMessage|null);
        }

        /** Represents an InteractiveMessage. */
        class InteractiveMessage implements IInteractiveMessage {

            /**
             * Constructs a new InteractiveMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IInteractiveMessage);

            /** InteractiveMessage header. */
            public header?: (proto.Message.InteractiveMessage.IHeader|null);

            /** InteractiveMessage body. */
            public body?: (proto.Message.InteractiveMessage.IBody|null);

            /** InteractiveMessage footer. */
            public footer?: (proto.Message.InteractiveMessage.IFooter|null);

            /** InteractiveMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** InteractiveMessage shopStorefrontMessage. */
            public shopStorefrontMessage?: (proto.Message.InteractiveMessage.IShopMessage|null);

            /** InteractiveMessage collectionMessage. */
            public collectionMessage?: (proto.Message.InteractiveMessage.ICollectionMessage|null);

            /** InteractiveMessage nativeFlowMessage. */
            public nativeFlowMessage?: (proto.Message.InteractiveMessage.INativeFlowMessage|null);

            /** InteractiveMessage carouselMessage. */
            public carouselMessage?: (proto.Message.InteractiveMessage.ICarouselMessage|null);

            /** InteractiveMessage interactiveMessage. */
            public interactiveMessage?: ("shopStorefrontMessage"|"collectionMessage"|"nativeFlowMessage"|"carouselMessage");

            /**
             * Creates a new InteractiveMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns InteractiveMessage instance
             */
            public static create(properties?: proto.Message.IInteractiveMessage): proto.Message.InteractiveMessage;

            /**
             * Encodes the specified InteractiveMessage message. Does not implicitly {@link proto.Message.InteractiveMessage.verify|verify} messages.
             * @param message InteractiveMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IInteractiveMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified InteractiveMessage message, length delimited. Does not implicitly {@link proto.Message.InteractiveMessage.verify|verify} messages.
             * @param message InteractiveMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IInteractiveMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an InteractiveMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns InteractiveMessage
             * @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): proto.Message.InteractiveMessage;

            /**
             * Decodes an InteractiveMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns InteractiveMessage
             * @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)): proto.Message.InteractiveMessage;

            /**
             * Verifies an InteractiveMessage 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 InteractiveMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns InteractiveMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.InteractiveMessage;

            /**
             * Creates a plain object from an InteractiveMessage message. Also converts values to other types if specified.
             * @param message InteractiveMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.InteractiveMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this InteractiveMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace InteractiveMessage {

            /** Properties of a Body. */
            interface IBody {

                /** Body text */
                text?: (string|null);
            }

            /** Represents a Body. */
            class Body implements IBody {

                /**
                 * Constructs a new Body.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.InteractiveMessage.IBody);

                /** Body text. */
                public text: string;

                /**
                 * Creates a new Body instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns Body instance
                 */
                public static create(properties?: proto.Message.InteractiveMessage.IBody): proto.Message.InteractiveMessage.Body;

                /**
                 * Encodes the specified Body message. Does not implicitly {@link proto.Message.InteractiveMessage.Body.verify|verify} messages.
                 * @param message Body message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.InteractiveMessage.IBody, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified Body message, length delimited. Does not implicitly {@link proto.Message.InteractiveMessage.Body.verify|verify} messages.
                 * @param message Body message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.InteractiveMessage.IBody, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a Body message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns Body
                 * @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): proto.Message.InteractiveMessage.Body;

                /**
                 * Decodes a Body message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns Body
                 * @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)): proto.Message.InteractiveMessage.Body;

                /**
                 * Verifies a Body 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 Body message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns Body
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.InteractiveMessage.Body;

                /**
                 * Creates a plain object from a Body message. Also converts values to other types if specified.
                 * @param message Body
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.InteractiveMessage.Body, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this Body to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a CarouselMessage. */
            interface ICarouselMessage {

                /** CarouselMessage cards */
                cards?: (proto.Message.IInteractiveMessage[]|null);

                /** CarouselMessage messageVersion */
                messageVersion?: (number|null);
            }

            /** Represents a CarouselMessage. */
            class CarouselMessage implements ICarouselMessage {

                /**
                 * Constructs a new CarouselMessage.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.InteractiveMessage.ICarouselMessage);

                /** CarouselMessage cards. */
                public cards: proto.Message.IInteractiveMessage[];

                /** CarouselMessage messageVersion. */
                public messageVersion: number;

                /**
                 * Creates a new CarouselMessage instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns CarouselMessage instance
                 */
                public static create(properties?: proto.Message.InteractiveMessage.ICarouselMessage): proto.Message.InteractiveMessage.CarouselMessage;

                /**
                 * Encodes the specified CarouselMessage message. Does not implicitly {@link proto.Message.InteractiveMessage.CarouselMessage.verify|verify} messages.
                 * @param message CarouselMessage message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.InteractiveMessage.ICarouselMessage, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified CarouselMessage message, length delimited. Does not implicitly {@link proto.Message.InteractiveMessage.CarouselMessage.verify|verify} messages.
                 * @param message CarouselMessage message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.InteractiveMessage.ICarouselMessage, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a CarouselMessage message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns CarouselMessage
                 * @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): proto.Message.InteractiveMessage.CarouselMessage;

                /**
                 * Decodes a CarouselMessage message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns CarouselMessage
                 * @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)): proto.Message.InteractiveMessage.CarouselMessage;

                /**
                 * Verifies a CarouselMessage 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 CarouselMessage message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns CarouselMessage
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.InteractiveMessage.CarouselMessage;

                /**
                 * Creates a plain object from a CarouselMessage message. Also converts values to other types if specified.
                 * @param message CarouselMessage
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.InteractiveMessage.CarouselMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this CarouselMessage to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a CollectionMessage. */
            interface ICollectionMessage {

                /** CollectionMessage bizJid */
                bizJid?: (string|null);

                /** CollectionMessage id */
                id?: (string|null);

                /** CollectionMessage messageVersion */
                messageVersion?: (number|null);
            }

            /** Represents a CollectionMessage. */
            class CollectionMessage implements ICollectionMessage {

                /**
                 * Constructs a new CollectionMessage.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.InteractiveMessage.ICollectionMessage);

                /** CollectionMessage bizJid. */
                public bizJid: string;

                /** CollectionMessage id. */
                public id: string;

                /** CollectionMessage messageVersion. */
                public messageVersion: number;

                /**
                 * Creates a new CollectionMessage instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns CollectionMessage instance
                 */
                public static create(properties?: proto.Message.InteractiveMessage.ICollectionMessage): proto.Message.InteractiveMessage.CollectionMessage;

                /**
                 * Encodes the specified CollectionMessage message. Does not implicitly {@link proto.Message.InteractiveMessage.CollectionMessage.verify|verify} messages.
                 * @param message CollectionMessage message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.InteractiveMessage.ICollectionMessage, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified CollectionMessage message, length delimited. Does not implicitly {@link proto.Message.InteractiveMessage.CollectionMessage.verify|verify} messages.
                 * @param message CollectionMessage message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.InteractiveMessage.ICollectionMessage, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a CollectionMessage message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns CollectionMessage
                 * @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): proto.Message.InteractiveMessage.CollectionMessage;

                /**
                 * Decodes a CollectionMessage message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns CollectionMessage
                 * @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)): proto.Message.InteractiveMessage.CollectionMessage;

                /**
                 * Verifies a CollectionMessage 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 CollectionMessage message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns CollectionMessage
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.InteractiveMessage.CollectionMessage;

                /**
                 * Creates a plain object from a CollectionMessage message. Also converts values to other types if specified.
                 * @param message CollectionMessage
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.InteractiveMessage.CollectionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this CollectionMessage to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a Footer. */
            interface IFooter {

                /** Footer text */
                text?: (string|null);
            }

            /** Represents a Footer. */
            class Footer implements IFooter {

                /**
                 * Constructs a new Footer.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.InteractiveMessage.IFooter);

                /** Footer text. */
                public text: string;

                /**
                 * Creates a new Footer instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns Footer instance
                 */
                public static create(properties?: proto.Message.InteractiveMessage.IFooter): proto.Message.InteractiveMessage.Footer;

                /**
                 * Encodes the specified Footer message. Does not implicitly {@link proto.Message.InteractiveMessage.Footer.verify|verify} messages.
                 * @param message Footer message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.InteractiveMessage.IFooter, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified Footer message, length delimited. Does not implicitly {@link proto.Message.InteractiveMessage.Footer.verify|verify} messages.
                 * @param message Footer message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.InteractiveMessage.IFooter, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a Footer message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns Footer
                 * @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): proto.Message.InteractiveMessage.Footer;

                /**
                 * Decodes a Footer message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns Footer
                 * @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)): proto.Message.InteractiveMessage.Footer;

                /**
                 * Verifies a Footer 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 Footer message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns Footer
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.InteractiveMessage.Footer;

                /**
                 * Creates a plain object from a Footer message. Also converts values to other types if specified.
                 * @param message Footer
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.InteractiveMessage.Footer, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this Footer to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a Header. */
            interface IHeader {

                /** Header title */
                title?: (string|null);

                /** Header subtitle */
                subtitle?: (string|null);

                /** Header hasMediaAttachment */
                hasMediaAttachment?: (boolean|null);

                /** Header documentMessage */
                documentMessage?: (proto.Message.IDocumentMessage|null);

                /** Header imageMessage */
                imageMessage?: (proto.Message.IImageMessage|null);

                /** Header jpegThumbnail */
                jpegThumbnail?: (Uint8Array|null);

                /** Header videoMessage */
                videoMessage?: (proto.Message.IVideoMessage|null);

                /** Header locationMessage */
                locationMessage?: (proto.Message.ILocationMessage|null);
            }

            /** Represents a Header. */
            class Header implements IHeader {

                /**
                 * Constructs a new Header.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.InteractiveMessage.IHeader);

                /** Header title. */
                public title: string;

                /** Header subtitle. */
                public subtitle: string;

                /** Header hasMediaAttachment. */
                public hasMediaAttachment: boolean;

                /** Header documentMessage. */
                public documentMessage?: (proto.Message.IDocumentMessage|null);

                /** Header imageMessage. */
                public imageMessage?: (proto.Message.IImageMessage|null);

                /** Header jpegThumbnail. */
                public jpegThumbnail?: (Uint8Array|null);

                /** Header videoMessage. */
                public videoMessage?: (proto.Message.IVideoMessage|null);

                /** Header locationMessage. */
                public locationMessage?: (proto.Message.ILocationMessage|null);

                /** Header media. */
                public media?: ("documentMessage"|"imageMessage"|"jpegThumbnail"|"videoMessage"|"locationMessage");

                /**
                 * Creates a new Header instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns Header instance
                 */
                public static create(properties?: proto.Message.InteractiveMessage.IHeader): proto.Message.InteractiveMessage.Header;

                /**
                 * Encodes the specified Header message. Does not implicitly {@link proto.Message.InteractiveMessage.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: proto.Message.InteractiveMessage.IHeader, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified Header message, length delimited. Does not implicitly {@link proto.Message.InteractiveMessage.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: proto.Message.InteractiveMessage.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): proto.Message.InteractiveMessage.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)): proto.Message.InteractiveMessage.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 }): proto.Message.InteractiveMessage.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: proto.Message.InteractiveMessage.Header, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this Header to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a NativeFlowMessage. */
            interface INativeFlowMessage {

                /** NativeFlowMessage buttons */
                buttons?: (proto.Message.InteractiveMessage.NativeFlowMessage.INativeFlowButton[]|null);

                /** NativeFlowMessage messageParamsJson */
                messageParamsJson?: (string|null);

                /** NativeFlowMessage messageVersion */
                messageVersion?: (number|null);
            }

            /** Represents a NativeFlowMessage. */
            class NativeFlowMessage implements INativeFlowMessage {

                /**
                 * Constructs a new NativeFlowMessage.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.InteractiveMessage.INativeFlowMessage);

                /** NativeFlowMessage buttons. */
                public buttons: proto.Message.InteractiveMessage.NativeFlowMessage.INativeFlowButton[];

                /** NativeFlowMessage messageParamsJson. */
                public messageParamsJson: string;

                /** NativeFlowMessage messageVersion. */
                public messageVersion: number;

                /**
                 * Creates a new NativeFlowMessage instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns NativeFlowMessage instance
                 */
                public static create(properties?: proto.Message.InteractiveMessage.INativeFlowMessage): proto.Message.InteractiveMessage.NativeFlowMessage;

                /**
                 * Encodes the specified NativeFlowMessage message. Does not implicitly {@link proto.Message.InteractiveMessage.NativeFlowMessage.verify|verify} messages.
                 * @param message NativeFlowMessage message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.InteractiveMessage.INativeFlowMessage, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified NativeFlowMessage message, length delimited. Does not implicitly {@link proto.Message.InteractiveMessage.NativeFlowMessage.verify|verify} messages.
                 * @param message NativeFlowMessage message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.InteractiveMessage.INativeFlowMessage, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a NativeFlowMessage message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns NativeFlowMessage
                 * @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): proto.Message.InteractiveMessage.NativeFlowMessage;

                /**
                 * Decodes a NativeFlowMessage message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns NativeFlowMessage
                 * @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)): proto.Message.InteractiveMessage.NativeFlowMessage;

                /**
                 * Verifies a NativeFlowMessage 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 NativeFlowMessage message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns NativeFlowMessage
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.InteractiveMessage.NativeFlowMessage;

                /**
                 * Creates a plain object from a NativeFlowMessage message. Also converts values to other types if specified.
                 * @param message NativeFlowMessage
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.InteractiveMessage.NativeFlowMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this NativeFlowMessage to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            namespace NativeFlowMessage {

                /** Properties of a NativeFlowButton. */
                interface INativeFlowButton {

                    /** NativeFlowButton name */
                    name?: (string|null);

                    /** NativeFlowButton buttonParamsJson */
                    buttonParamsJson?: (string|null);
                }

                /** Represents a NativeFlowButton. */
                class NativeFlowButton implements INativeFlowButton {

                    /**
                     * Constructs a new NativeFlowButton.
                     * @param [properties] Properties to set
                     */
                    constructor(properties?: proto.Message.InteractiveMessage.NativeFlowMessage.INativeFlowButton);

                    /** NativeFlowButton name. */
                    public name: string;

                    /** NativeFlowButton buttonParamsJson. */
                    public buttonParamsJson: string;

                    /**
                     * Creates a new NativeFlowButton instance using the specified properties.
                     * @param [properties] Properties to set
                     * @returns NativeFlowButton instance
                     */
                    public static create(properties?: proto.Message.InteractiveMessage.NativeFlowMessage.INativeFlowButton): proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton;

                    /**
                     * Encodes the specified NativeFlowButton message. Does not implicitly {@link proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.verify|verify} messages.
                     * @param message NativeFlowButton message or plain object to encode
                     * @param [writer] Writer to encode to
                     * @returns Writer
                     */
                    public static encode(message: proto.Message.InteractiveMessage.NativeFlowMessage.INativeFlowButton, writer?: $protobuf.Writer): $protobuf.Writer;

                    /**
                     * Encodes the specified NativeFlowButton message, length delimited. Does not implicitly {@link proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.verify|verify} messages.
                     * @param message NativeFlowButton message or plain object to encode
                     * @param [writer] Writer to encode to
                     * @returns Writer
                     */
                    public static encodeDelimited(message: proto.Message.InteractiveMessage.NativeFlowMessage.INativeFlowButton, writer?: $protobuf.Writer): $protobuf.Writer;

                    /**
                     * Decodes a NativeFlowButton message from the specified reader or buffer.
                     * @param reader Reader or buffer to decode from
                     * @param [length] Message length if known beforehand
                     * @returns NativeFlowButton
                     * @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): proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton;

                    /**
                     * Decodes a NativeFlowButton message from the specified reader or buffer, length delimited.
                     * @param reader Reader or buffer to decode from
                     * @returns NativeFlowButton
                     * @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)): proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton;

                    /**
                     * Verifies a NativeFlowButton 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 NativeFlowButton message from a plain object. Also converts values to their respective internal types.
                     * @param object Plain object
                     * @returns NativeFlowButton
                     */
                    public static fromObject(object: { [k: string]: any }): proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton;

                    /**
                     * Creates a plain object from a NativeFlowButton message. Also converts values to other types if specified.
                     * @param message NativeFlowButton
                     * @param [options] Conversion options
                     * @returns Plain object
                     */
                    public static toObject(message: proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton, options?: $protobuf.IConversionOptions): { [k: string]: any };

                    /**
                     * Converts this NativeFlowButton to JSON.
                     * @returns JSON object
                     */
                    public toJSON(): { [k: string]: any };
                }
            }

            /** Properties of a ShopMessage. */
            interface IShopMessage {

                /** ShopMessage id */
                id?: (string|null);

                /** ShopMessage surface */
                surface?: (proto.Message.InteractiveMessage.ShopMessage.Surface|null);

                /** ShopMessage messageVersion */
                messageVersion?: (number|null);
            }

            /** Represents a ShopMessage. */
            class ShopMessage implements IShopMessage {

                /**
                 * Constructs a new ShopMessage.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.InteractiveMessage.IShopMessage);

                /** ShopMessage id. */
                public id: string;

                /** ShopMessage surface. */
                public surface: proto.Message.InteractiveMessage.ShopMessage.Surface;

                /** ShopMessage messageVersion. */
                public messageVersion: number;

                /**
                 * Creates a new ShopMessage instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns ShopMessage instance
                 */
                public static create(properties?: proto.Message.InteractiveMessage.IShopMessage): proto.Message.InteractiveMessage.ShopMessage;

                /**
                 * Encodes the specified ShopMessage message. Does not implicitly {@link proto.Message.InteractiveMessage.ShopMessage.verify|verify} messages.
                 * @param message ShopMessage message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.InteractiveMessage.IShopMessage, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified ShopMessage message, length delimited. Does not implicitly {@link proto.Message.InteractiveMessage.ShopMessage.verify|verify} messages.
                 * @param message ShopMessage message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.InteractiveMessage.IShopMessage, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a ShopMessage message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns ShopMessage
                 * @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): proto.Message.InteractiveMessage.ShopMessage;

                /**
                 * Decodes a ShopMessage message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns ShopMessage
                 * @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)): proto.Message.InteractiveMessage.ShopMessage;

                /**
                 * Verifies a ShopMessage 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 ShopMessage message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns ShopMessage
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.InteractiveMessage.ShopMessage;

                /**
                 * Creates a plain object from a ShopMessage message. Also converts values to other types if specified.
                 * @param message ShopMessage
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.InteractiveMessage.ShopMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this ShopMessage to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            namespace ShopMessage {

                /** Surface enum. */
                enum Surface {
                    UNKNOWN_SURFACE = 0,
                    FB = 1,
                    IG = 2,
                    WA = 3
                }
            }
        }

        /** Properties of an InteractiveResponseMessage. */
        interface IInteractiveResponseMessage {

            /** InteractiveResponseMessage body */
            body?: (proto.Message.InteractiveResponseMessage.IBody|null);

            /** InteractiveResponseMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** InteractiveResponseMessage nativeFlowResponseMessage */
            nativeFlowResponseMessage?: (proto.Message.InteractiveResponseMessage.INativeFlowResponseMessage|null);
        }

        /** Represents an InteractiveResponseMessage. */
        class InteractiveResponseMessage implements IInteractiveResponseMessage {

            /**
             * Constructs a new InteractiveResponseMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IInteractiveResponseMessage);

            /** InteractiveResponseMessage body. */
            public body?: (proto.Message.InteractiveResponseMessage.IBody|null);

            /** InteractiveResponseMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** InteractiveResponseMessage nativeFlowResponseMessage. */
            public nativeFlowResponseMessage?: (proto.Message.InteractiveResponseMessage.INativeFlowResponseMessage|null);

            /** InteractiveResponseMessage interactiveResponseMessage. */
            public interactiveResponseMessage?: "nativeFlowResponseMessage";

            /**
             * Creates a new InteractiveResponseMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns InteractiveResponseMessage instance
             */
            public static create(properties?: proto.Message.IInteractiveResponseMessage): proto.Message.InteractiveResponseMessage;

            /**
             * Encodes the specified InteractiveResponseMessage message. Does not implicitly {@link proto.Message.InteractiveResponseMessage.verify|verify} messages.
             * @param message InteractiveResponseMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IInteractiveResponseMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified InteractiveResponseMessage message, length delimited. Does not implicitly {@link proto.Message.InteractiveResponseMessage.verify|verify} messages.
             * @param message InteractiveResponseMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IInteractiveResponseMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an InteractiveResponseMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns InteractiveResponseMessage
             * @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): proto.Message.InteractiveResponseMessage;

            /**
             * Decodes an InteractiveResponseMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns InteractiveResponseMessage
             * @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)): proto.Message.InteractiveResponseMessage;

            /**
             * Verifies an InteractiveResponseMessage 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 InteractiveResponseMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns InteractiveResponseMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.InteractiveResponseMessage;

            /**
             * Creates a plain object from an InteractiveResponseMessage message. Also converts values to other types if specified.
             * @param message InteractiveResponseMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.InteractiveResponseMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this InteractiveResponseMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace InteractiveResponseMessage {

            /** Properties of a Body. */
            interface IBody {

                /** Body text */
                text?: (string|null);

                /** Body format */
                format?: (proto.Message.InteractiveResponseMessage.Body.Format|null);
            }

            /** Represents a Body. */
            class Body implements IBody {

                /**
                 * Constructs a new Body.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.InteractiveResponseMessage.IBody);

                /** Body text. */
                public text: string;

                /** Body format. */
                public format: proto.Message.InteractiveResponseMessage.Body.Format;

                /**
                 * Creates a new Body instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns Body instance
                 */
                public static create(properties?: proto.Message.InteractiveResponseMessage.IBody): proto.Message.InteractiveResponseMessage.Body;

                /**
                 * Encodes the specified Body message. Does not implicitly {@link proto.Message.InteractiveResponseMessage.Body.verify|verify} messages.
                 * @param message Body message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.InteractiveResponseMessage.IBody, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified Body message, length delimited. Does not implicitly {@link proto.Message.InteractiveResponseMessage.Body.verify|verify} messages.
                 * @param message Body message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.InteractiveResponseMessage.IBody, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a Body message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns Body
                 * @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): proto.Message.InteractiveResponseMessage.Body;

                /**
                 * Decodes a Body message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns Body
                 * @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)): proto.Message.InteractiveResponseMessage.Body;

                /**
                 * Verifies a Body 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 Body message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns Body
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.InteractiveResponseMessage.Body;

                /**
                 * Creates a plain object from a Body message. Also converts values to other types if specified.
                 * @param message Body
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.InteractiveResponseMessage.Body, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this Body to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            namespace Body {

                /** Format enum. */
                enum Format {
                    DEFAULT = 0,
                    EXTENSIONS_1 = 1
                }
            }

            /** Properties of a NativeFlowResponseMessage. */
            interface INativeFlowResponseMessage {

                /** NativeFlowResponseMessage name */
                name?: (string|null);

                /** NativeFlowResponseMessage paramsJson */
                paramsJson?: (string|null);

                /** NativeFlowResponseMessage version */
                version?: (number|null);
            }

            /** Represents a NativeFlowResponseMessage. */
            class NativeFlowResponseMessage implements INativeFlowResponseMessage {

                /**
                 * Constructs a new NativeFlowResponseMessage.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.InteractiveResponseMessage.INativeFlowResponseMessage);

                /** NativeFlowResponseMessage name. */
                public name: string;

                /** NativeFlowResponseMessage paramsJson. */
                public paramsJson: string;

                /** NativeFlowResponseMessage version. */
                public version: number;

                /**
                 * Creates a new NativeFlowResponseMessage instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns NativeFlowResponseMessage instance
                 */
                public static create(properties?: proto.Message.InteractiveResponseMessage.INativeFlowResponseMessage): proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage;

                /**
                 * Encodes the specified NativeFlowResponseMessage message. Does not implicitly {@link proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.verify|verify} messages.
                 * @param message NativeFlowResponseMessage message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.InteractiveResponseMessage.INativeFlowResponseMessage, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified NativeFlowResponseMessage message, length delimited. Does not implicitly {@link proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.verify|verify} messages.
                 * @param message NativeFlowResponseMessage message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.InteractiveResponseMessage.INativeFlowResponseMessage, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a NativeFlowResponseMessage message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns NativeFlowResponseMessage
                 * @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): proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage;

                /**
                 * Decodes a NativeFlowResponseMessage message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns NativeFlowResponseMessage
                 * @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)): proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage;

                /**
                 * Verifies a NativeFlowResponseMessage 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 NativeFlowResponseMessage message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns NativeFlowResponseMessage
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage;

                /**
                 * Creates a plain object from a NativeFlowResponseMessage message. Also converts values to other types if specified.
                 * @param message NativeFlowResponseMessage
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this NativeFlowResponseMessage to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }
        }

        /** Properties of an InvoiceMessage. */
        interface IInvoiceMessage {

            /** InvoiceMessage note */
            note?: (string|null);

            /** InvoiceMessage token */
            token?: (string|null);

            /** InvoiceMessage attachmentType */
            attachmentType?: (proto.Message.InvoiceMessage.AttachmentType|null);

            /** InvoiceMessage attachmentMimetype */
            attachmentMimetype?: (string|null);

            /** InvoiceMessage attachmentMediaKey */
            attachmentMediaKey?: (Uint8Array|null);

            /** InvoiceMessage attachmentMediaKeyTimestamp */
            attachmentMediaKeyTimestamp?: (number|Long|null);

            /** InvoiceMessage attachmentFileSha256 */
            attachmentFileSha256?: (Uint8Array|null);

            /** InvoiceMessage attachmentFileEncSha256 */
            attachmentFileEncSha256?: (Uint8Array|null);

            /** InvoiceMessage attachmentDirectPath */
            attachmentDirectPath?: (string|null);

            /** InvoiceMessage attachmentJpegThumbnail */
            attachmentJpegThumbnail?: (Uint8Array|null);
        }

        /** Represents an InvoiceMessage. */
        class InvoiceMessage implements IInvoiceMessage {

            /**
             * Constructs a new InvoiceMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IInvoiceMessage);

            /** InvoiceMessage note. */
            public note: string;

            /** InvoiceMessage token. */
            public token: string;

            /** InvoiceMessage attachmentType. */
            public attachmentType: proto.Message.InvoiceMessage.AttachmentType;

            /** InvoiceMessage attachmentMimetype. */
            public attachmentMimetype: string;

            /** InvoiceMessage attachmentMediaKey. */
            public attachmentMediaKey: Uint8Array;

            /** InvoiceMessage attachmentMediaKeyTimestamp. */
            public attachmentMediaKeyTimestamp: (number|Long);

            /** InvoiceMessage attachmentFileSha256. */
            public attachmentFileSha256: Uint8Array;

            /** InvoiceMessage attachmentFileEncSha256. */
            public attachmentFileEncSha256: Uint8Array;

            /** InvoiceMessage attachmentDirectPath. */
            public attachmentDirectPath: string;

            /** InvoiceMessage attachmentJpegThumbnail. */
            public attachmentJpegThumbnail: Uint8Array;

            /**
             * Creates a new InvoiceMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns InvoiceMessage instance
             */
            public static create(properties?: proto.Message.IInvoiceMessage): proto.Message.InvoiceMessage;

            /**
             * Encodes the specified InvoiceMessage message. Does not implicitly {@link proto.Message.InvoiceMessage.verify|verify} messages.
             * @param message InvoiceMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IInvoiceMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified InvoiceMessage message, length delimited. Does not implicitly {@link proto.Message.InvoiceMessage.verify|verify} messages.
             * @param message InvoiceMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IInvoiceMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an InvoiceMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns InvoiceMessage
             * @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): proto.Message.InvoiceMessage;

            /**
             * Decodes an InvoiceMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns InvoiceMessage
             * @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)): proto.Message.InvoiceMessage;

            /**
             * Verifies an InvoiceMessage 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 InvoiceMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns InvoiceMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.InvoiceMessage;

            /**
             * Creates a plain object from an InvoiceMessage message. Also converts values to other types if specified.
             * @param message InvoiceMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.InvoiceMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this InvoiceMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace InvoiceMessage {

            /** AttachmentType enum. */
            enum AttachmentType {
                IMAGE = 0,
                PDF = 1
            }
        }

        /** Properties of a KeepInChatMessage. */
        interface IKeepInChatMessage {

            /** KeepInChatMessage key */
            key?: (proto.IMessageKey|null);

            /** KeepInChatMessage keepType */
            keepType?: (proto.KeepType|null);

            /** KeepInChatMessage timestampMs */
            timestampMs?: (number|Long|null);
        }

        /** Represents a KeepInChatMessage. */
        class KeepInChatMessage implements IKeepInChatMessage {

            /**
             * Constructs a new KeepInChatMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IKeepInChatMessage);

            /** KeepInChatMessage key. */
            public key?: (proto.IMessageKey|null);

            /** KeepInChatMessage keepType. */
            public keepType: proto.KeepType;

            /** KeepInChatMessage timestampMs. */
            public timestampMs: (number|Long);

            /**
             * Creates a new KeepInChatMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns KeepInChatMessage instance
             */
            public static create(properties?: proto.Message.IKeepInChatMessage): proto.Message.KeepInChatMessage;

            /**
             * Encodes the specified KeepInChatMessage message. Does not implicitly {@link proto.Message.KeepInChatMessage.verify|verify} messages.
             * @param message KeepInChatMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IKeepInChatMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified KeepInChatMessage message, length delimited. Does not implicitly {@link proto.Message.KeepInChatMessage.verify|verify} messages.
             * @param message KeepInChatMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IKeepInChatMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a KeepInChatMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns KeepInChatMessage
             * @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): proto.Message.KeepInChatMessage;

            /**
             * Decodes a KeepInChatMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns KeepInChatMessage
             * @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)): proto.Message.KeepInChatMessage;

            /**
             * Verifies a KeepInChatMessage 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 KeepInChatMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns KeepInChatMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.KeepInChatMessage;

            /**
             * Creates a plain object from a KeepInChatMessage message. Also converts values to other types if specified.
             * @param message KeepInChatMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.KeepInChatMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this KeepInChatMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a ListMessage. */
        interface IListMessage {

            /** ListMessage title */
            title?: (string|null);

            /** ListMessage description */
            description?: (string|null);

            /** ListMessage buttonText */
            buttonText?: (string|null);

            /** ListMessage listType */
            listType?: (proto.Message.ListMessage.ListType|null);

            /** ListMessage sections */
            sections?: (proto.Message.ListMessage.ISection[]|null);

            /** ListMessage productListInfo */
            productListInfo?: (proto.Message.ListMessage.IProductListInfo|null);

            /** ListMessage footerText */
            footerText?: (string|null);

            /** ListMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);
        }

        /** Represents a ListMessage. */
        class ListMessage implements IListMessage {

            /**
             * Constructs a new ListMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IListMessage);

            /** ListMessage title. */
            public title: string;

            /** ListMessage description. */
            public description: string;

            /** ListMessage buttonText. */
            public buttonText: string;

            /** ListMessage listType. */
            public listType: proto.Message.ListMessage.ListType;

            /** ListMessage sections. */
            public sections: proto.Message.ListMessage.ISection[];

            /** ListMessage productListInfo. */
            public productListInfo?: (proto.Message.ListMessage.IProductListInfo|null);

            /** ListMessage footerText. */
            public footerText: string;

            /** ListMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /**
             * Creates a new ListMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ListMessage instance
             */
            public static create(properties?: proto.Message.IListMessage): proto.Message.ListMessage;

            /**
             * Encodes the specified ListMessage message. Does not implicitly {@link proto.Message.ListMessage.verify|verify} messages.
             * @param message ListMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IListMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ListMessage message, length delimited. Does not implicitly {@link proto.Message.ListMessage.verify|verify} messages.
             * @param message ListMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IListMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ListMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ListMessage
             * @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): proto.Message.ListMessage;

            /**
             * Decodes a ListMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ListMessage
             * @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)): proto.Message.ListMessage;

            /**
             * Verifies a ListMessage 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 ListMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ListMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.ListMessage;

            /**
             * Creates a plain object from a ListMessage message. Also converts values to other types if specified.
             * @param message ListMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.ListMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ListMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace ListMessage {

            /** ListType enum. */
            enum ListType {
                UNKNOWN = 0,
                SINGLE_SELECT = 1,
                PRODUCT_LIST = 2
            }

            /** Properties of a Product. */
            interface IProduct {

                /** Product productId */
                productId?: (string|null);
            }

            /** Represents a Product. */
            class Product implements IProduct {

                /**
                 * Constructs a new Product.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.ListMessage.IProduct);

                /** Product productId. */
                public productId: string;

                /**
                 * Creates a new Product instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns Product instance
                 */
                public static create(properties?: proto.Message.ListMessage.IProduct): proto.Message.ListMessage.Product;

                /**
                 * Encodes the specified Product message. Does not implicitly {@link proto.Message.ListMessage.Product.verify|verify} messages.
                 * @param message Product message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.ListMessage.IProduct, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified Product message, length delimited. Does not implicitly {@link proto.Message.ListMessage.Product.verify|verify} messages.
                 * @param message Product message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.ListMessage.IProduct, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a Product message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns Product
                 * @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): proto.Message.ListMessage.Product;

                /**
                 * Decodes a Product message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns Product
                 * @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)): proto.Message.ListMessage.Product;

                /**
                 * Verifies a Product 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 Product message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns Product
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.ListMessage.Product;

                /**
                 * Creates a plain object from a Product message. Also converts values to other types if specified.
                 * @param message Product
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.ListMessage.Product, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this Product to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a ProductListHeaderImage. */
            interface IProductListHeaderImage {

                /** ProductListHeaderImage productId */
                productId?: (string|null);

                /** ProductListHeaderImage jpegThumbnail */
                jpegThumbnail?: (Uint8Array|null);
            }

            /** Represents a ProductListHeaderImage. */
            class ProductListHeaderImage implements IProductListHeaderImage {

                /**
                 * Constructs a new ProductListHeaderImage.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.ListMessage.IProductListHeaderImage);

                /** ProductListHeaderImage productId. */
                public productId: string;

                /** ProductListHeaderImage jpegThumbnail. */
                public jpegThumbnail: Uint8Array;

                /**
                 * Creates a new ProductListHeaderImage instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns ProductListHeaderImage instance
                 */
                public static create(properties?: proto.Message.ListMessage.IProductListHeaderImage): proto.Message.ListMessage.ProductListHeaderImage;

                /**
                 * Encodes the specified ProductListHeaderImage message. Does not implicitly {@link proto.Message.ListMessage.ProductListHeaderImage.verify|verify} messages.
                 * @param message ProductListHeaderImage message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.ListMessage.IProductListHeaderImage, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified ProductListHeaderImage message, length delimited. Does not implicitly {@link proto.Message.ListMessage.ProductListHeaderImage.verify|verify} messages.
                 * @param message ProductListHeaderImage message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.ListMessage.IProductListHeaderImage, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a ProductListHeaderImage message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns ProductListHeaderImage
                 * @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): proto.Message.ListMessage.ProductListHeaderImage;

                /**
                 * Decodes a ProductListHeaderImage message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns ProductListHeaderImage
                 * @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)): proto.Message.ListMessage.ProductListHeaderImage;

                /**
                 * Verifies a ProductListHeaderImage 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 ProductListHeaderImage message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns ProductListHeaderImage
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.ListMessage.ProductListHeaderImage;

                /**
                 * Creates a plain object from a ProductListHeaderImage message. Also converts values to other types if specified.
                 * @param message ProductListHeaderImage
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.ListMessage.ProductListHeaderImage, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this ProductListHeaderImage to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a ProductListInfo. */
            interface IProductListInfo {

                /** ProductListInfo productSections */
                productSections?: (proto.Message.ListMessage.IProductSection[]|null);

                /** ProductListInfo headerImage */
                headerImage?: (proto.Message.ListMessage.IProductListHeaderImage|null);

                /** ProductListInfo businessOwnerJid */
                businessOwnerJid?: (string|null);
            }

            /** Represents a ProductListInfo. */
            class ProductListInfo implements IProductListInfo {

                /**
                 * Constructs a new ProductListInfo.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.ListMessage.IProductListInfo);

                /** ProductListInfo productSections. */
                public productSections: proto.Message.ListMessage.IProductSection[];

                /** ProductListInfo headerImage. */
                public headerImage?: (proto.Message.ListMessage.IProductListHeaderImage|null);

                /** ProductListInfo businessOwnerJid. */
                public businessOwnerJid: string;

                /**
                 * Creates a new ProductListInfo instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns ProductListInfo instance
                 */
                public static create(properties?: proto.Message.ListMessage.IProductListInfo): proto.Message.ListMessage.ProductListInfo;

                /**
                 * Encodes the specified ProductListInfo message. Does not implicitly {@link proto.Message.ListMessage.ProductListInfo.verify|verify} messages.
                 * @param message ProductListInfo message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.ListMessage.IProductListInfo, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified ProductListInfo message, length delimited. Does not implicitly {@link proto.Message.ListMessage.ProductListInfo.verify|verify} messages.
                 * @param message ProductListInfo message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.ListMessage.IProductListInfo, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a ProductListInfo message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns ProductListInfo
                 * @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): proto.Message.ListMessage.ProductListInfo;

                /**
                 * Decodes a ProductListInfo message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns ProductListInfo
                 * @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)): proto.Message.ListMessage.ProductListInfo;

                /**
                 * Verifies a ProductListInfo 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 ProductListInfo message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns ProductListInfo
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.ListMessage.ProductListInfo;

                /**
                 * Creates a plain object from a ProductListInfo message. Also converts values to other types if specified.
                 * @param message ProductListInfo
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.ListMessage.ProductListInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this ProductListInfo to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a ProductSection. */
            interface IProductSection {

                /** ProductSection title */
                title?: (string|null);

                /** ProductSection products */
                products?: (proto.Message.ListMessage.IProduct[]|null);
            }

            /** Represents a ProductSection. */
            class ProductSection implements IProductSection {

                /**
                 * Constructs a new ProductSection.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.ListMessage.IProductSection);

                /** ProductSection title. */
                public title: string;

                /** ProductSection products. */
                public products: proto.Message.ListMessage.IProduct[];

                /**
                 * Creates a new ProductSection instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns ProductSection instance
                 */
                public static create(properties?: proto.Message.ListMessage.IProductSection): proto.Message.ListMessage.ProductSection;

                /**
                 * Encodes the specified ProductSection message. Does not implicitly {@link proto.Message.ListMessage.ProductSection.verify|verify} messages.
                 * @param message ProductSection message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.ListMessage.IProductSection, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified ProductSection message, length delimited. Does not implicitly {@link proto.Message.ListMessage.ProductSection.verify|verify} messages.
                 * @param message ProductSection message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.ListMessage.IProductSection, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a ProductSection message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns ProductSection
                 * @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): proto.Message.ListMessage.ProductSection;

                /**
                 * Decodes a ProductSection message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns ProductSection
                 * @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)): proto.Message.ListMessage.ProductSection;

                /**
                 * Verifies a ProductSection 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 ProductSection message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns ProductSection
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.ListMessage.ProductSection;

                /**
                 * Creates a plain object from a ProductSection message. Also converts values to other types if specified.
                 * @param message ProductSection
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.ListMessage.ProductSection, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this ProductSection to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a Row. */
            interface IRow {

                /** Row title */
                title?: (string|null);

                /** Row description */
                description?: (string|null);

                /** Row rowId */
                rowId?: (string|null);
            }

            /** Represents a Row. */
            class Row implements IRow {

                /**
                 * Constructs a new Row.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.ListMessage.IRow);

                /** Row title. */
                public title: string;

                /** Row description. */
                public description: string;

                /** Row rowId. */
                public rowId: string;

                /**
                 * Creates a new Row instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns Row instance
                 */
                public static create(properties?: proto.Message.ListMessage.IRow): proto.Message.ListMessage.Row;

                /**
                 * Encodes the specified Row message. Does not implicitly {@link proto.Message.ListMessage.Row.verify|verify} messages.
                 * @param message Row message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.ListMessage.IRow, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified Row message, length delimited. Does not implicitly {@link proto.Message.ListMessage.Row.verify|verify} messages.
                 * @param message Row message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.ListMessage.IRow, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a Row message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns Row
                 * @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): proto.Message.ListMessage.Row;

                /**
                 * Decodes a Row message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns Row
                 * @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)): proto.Message.ListMessage.Row;

                /**
                 * Verifies a Row 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 Row message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns Row
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.ListMessage.Row;

                /**
                 * Creates a plain object from a Row message. Also converts values to other types if specified.
                 * @param message Row
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.ListMessage.Row, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this Row to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a Section. */
            interface ISection {

                /** Section title */
                title?: (string|null);

                /** Section rows */
                rows?: (proto.Message.ListMessage.IRow[]|null);
            }

            /** Represents a Section. */
            class Section implements ISection {

                /**
                 * Constructs a new Section.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.ListMessage.ISection);

                /** Section title. */
                public title: string;

                /** Section rows. */
                public rows: proto.Message.ListMessage.IRow[];

                /**
                 * Creates a new Section instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns Section instance
                 */
                public static create(properties?: proto.Message.ListMessage.ISection): proto.Message.ListMessage.Section;

                /**
                 * Encodes the specified Section message. Does not implicitly {@link proto.Message.ListMessage.Section.verify|verify} messages.
                 * @param message Section message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.ListMessage.ISection, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified Section message, length delimited. Does not implicitly {@link proto.Message.ListMessage.Section.verify|verify} messages.
                 * @param message Section message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.ListMessage.ISection, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a Section message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns Section
                 * @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): proto.Message.ListMessage.Section;

                /**
                 * Decodes a Section message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns Section
                 * @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)): proto.Message.ListMessage.Section;

                /**
                 * Verifies a Section 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 Section message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns Section
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.ListMessage.Section;

                /**
                 * Creates a plain object from a Section message. Also converts values to other types if specified.
                 * @param message Section
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.ListMessage.Section, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this Section to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }
        }

        /** Properties of a ListResponseMessage. */
        interface IListResponseMessage {

            /** ListResponseMessage title */
            title?: (string|null);

            /** ListResponseMessage listType */
            listType?: (proto.Message.ListResponseMessage.ListType|null);

            /** ListResponseMessage singleSelectReply */
            singleSelectReply?: (proto.Message.ListResponseMessage.ISingleSelectReply|null);

            /** ListResponseMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** ListResponseMessage description */
            description?: (string|null);
        }

        /** Represents a ListResponseMessage. */
        class ListResponseMessage implements IListResponseMessage {

            /**
             * Constructs a new ListResponseMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IListResponseMessage);

            /** ListResponseMessage title. */
            public title: string;

            /** ListResponseMessage listType. */
            public listType: proto.Message.ListResponseMessage.ListType;

            /** ListResponseMessage singleSelectReply. */
            public singleSelectReply?: (proto.Message.ListResponseMessage.ISingleSelectReply|null);

            /** ListResponseMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** ListResponseMessage description. */
            public description: string;

            /**
             * Creates a new ListResponseMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ListResponseMessage instance
             */
            public static create(properties?: proto.Message.IListResponseMessage): proto.Message.ListResponseMessage;

            /**
             * Encodes the specified ListResponseMessage message. Does not implicitly {@link proto.Message.ListResponseMessage.verify|verify} messages.
             * @param message ListResponseMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IListResponseMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ListResponseMessage message, length delimited. Does not implicitly {@link proto.Message.ListResponseMessage.verify|verify} messages.
             * @param message ListResponseMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IListResponseMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ListResponseMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ListResponseMessage
             * @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): proto.Message.ListResponseMessage;

            /**
             * Decodes a ListResponseMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ListResponseMessage
             * @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)): proto.Message.ListResponseMessage;

            /**
             * Verifies a ListResponseMessage 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 ListResponseMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ListResponseMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.ListResponseMessage;

            /**
             * Creates a plain object from a ListResponseMessage message. Also converts values to other types if specified.
             * @param message ListResponseMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.ListResponseMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ListResponseMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace ListResponseMessage {

            /** ListType enum. */
            enum ListType {
                UNKNOWN = 0,
                SINGLE_SELECT = 1
            }

            /** Properties of a SingleSelectReply. */
            interface ISingleSelectReply {

                /** SingleSelectReply selectedRowId */
                selectedRowId?: (string|null);
            }

            /** Represents a SingleSelectReply. */
            class SingleSelectReply implements ISingleSelectReply {

                /**
                 * Constructs a new SingleSelectReply.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.ListResponseMessage.ISingleSelectReply);

                /** SingleSelectReply selectedRowId. */
                public selectedRowId: string;

                /**
                 * Creates a new SingleSelectReply instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns SingleSelectReply instance
                 */
                public static create(properties?: proto.Message.ListResponseMessage.ISingleSelectReply): proto.Message.ListResponseMessage.SingleSelectReply;

                /**
                 * Encodes the specified SingleSelectReply message. Does not implicitly {@link proto.Message.ListResponseMessage.SingleSelectReply.verify|verify} messages.
                 * @param message SingleSelectReply message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.ListResponseMessage.ISingleSelectReply, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified SingleSelectReply message, length delimited. Does not implicitly {@link proto.Message.ListResponseMessage.SingleSelectReply.verify|verify} messages.
                 * @param message SingleSelectReply message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.ListResponseMessage.ISingleSelectReply, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a SingleSelectReply message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns SingleSelectReply
                 * @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): proto.Message.ListResponseMessage.SingleSelectReply;

                /**
                 * Decodes a SingleSelectReply message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns SingleSelectReply
                 * @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)): proto.Message.ListResponseMessage.SingleSelectReply;

                /**
                 * Verifies a SingleSelectReply 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 SingleSelectReply message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns SingleSelectReply
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.ListResponseMessage.SingleSelectReply;

                /**
                 * Creates a plain object from a SingleSelectReply message. Also converts values to other types if specified.
                 * @param message SingleSelectReply
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.ListResponseMessage.SingleSelectReply, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this SingleSelectReply to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }
        }

        /** Properties of a LiveLocationMessage. */
        interface ILiveLocationMessage {

            /** LiveLocationMessage degreesLatitude */
            degreesLatitude?: (number|null);

            /** LiveLocationMessage degreesLongitude */
            degreesLongitude?: (number|null);

            /** LiveLocationMessage accuracyInMeters */
            accuracyInMeters?: (number|null);

            /** LiveLocationMessage speedInMps */
            speedInMps?: (number|null);

            /** LiveLocationMessage degreesClockwiseFromMagneticNorth */
            degreesClockwiseFromMagneticNorth?: (number|null);

            /** LiveLocationMessage caption */
            caption?: (string|null);

            /** LiveLocationMessage sequenceNumber */
            sequenceNumber?: (number|Long|null);

            /** LiveLocationMessage timeOffset */
            timeOffset?: (number|null);

            /** LiveLocationMessage jpegThumbnail */
            jpegThumbnail?: (Uint8Array|null);

            /** LiveLocationMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);
        }

        /** Represents a LiveLocationMessage. */
        class LiveLocationMessage implements ILiveLocationMessage {

            /**
             * Constructs a new LiveLocationMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.ILiveLocationMessage);

            /** LiveLocationMessage degreesLatitude. */
            public degreesLatitude: number;

            /** LiveLocationMessage degreesLongitude. */
            public degreesLongitude: number;

            /** LiveLocationMessage accuracyInMeters. */
            public accuracyInMeters: number;

            /** LiveLocationMessage speedInMps. */
            public speedInMps: number;

            /** LiveLocationMessage degreesClockwiseFromMagneticNorth. */
            public degreesClockwiseFromMagneticNorth: number;

            /** LiveLocationMessage caption. */
            public caption: string;

            /** LiveLocationMessage sequenceNumber. */
            public sequenceNumber: (number|Long);

            /** LiveLocationMessage timeOffset. */
            public timeOffset: number;

            /** LiveLocationMessage jpegThumbnail. */
            public jpegThumbnail: Uint8Array;

            /** LiveLocationMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /**
             * Creates a new LiveLocationMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns LiveLocationMessage instance
             */
            public static create(properties?: proto.Message.ILiveLocationMessage): proto.Message.LiveLocationMessage;

            /**
             * Encodes the specified LiveLocationMessage message. Does not implicitly {@link proto.Message.LiveLocationMessage.verify|verify} messages.
             * @param message LiveLocationMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.ILiveLocationMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified LiveLocationMessage message, length delimited. Does not implicitly {@link proto.Message.LiveLocationMessage.verify|verify} messages.
             * @param message LiveLocationMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.ILiveLocationMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a LiveLocationMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns LiveLocationMessage
             * @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): proto.Message.LiveLocationMessage;

            /**
             * Decodes a LiveLocationMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns LiveLocationMessage
             * @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)): proto.Message.LiveLocationMessage;

            /**
             * Verifies a LiveLocationMessage 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 LiveLocationMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns LiveLocationMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.LiveLocationMessage;

            /**
             * Creates a plain object from a LiveLocationMessage message. Also converts values to other types if specified.
             * @param message LiveLocationMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.LiveLocationMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this LiveLocationMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a LocationMessage. */
        interface ILocationMessage {

            /** LocationMessage degreesLatitude */
            degreesLatitude?: (number|null);

            /** LocationMessage degreesLongitude */
            degreesLongitude?: (number|null);

            /** LocationMessage name */
            name?: (string|null);

            /** LocationMessage address */
            address?: (string|null);

            /** LocationMessage url */
            url?: (string|null);

            /** LocationMessage isLive */
            isLive?: (boolean|null);

            /** LocationMessage accuracyInMeters */
            accuracyInMeters?: (number|null);

            /** LocationMessage speedInMps */
            speedInMps?: (number|null);

            /** LocationMessage degreesClockwiseFromMagneticNorth */
            degreesClockwiseFromMagneticNorth?: (number|null);

            /** LocationMessage comment */
            comment?: (string|null);

            /** LocationMessage jpegThumbnail */
            jpegThumbnail?: (Uint8Array|null);

            /** LocationMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);
        }

        /** Represents a LocationMessage. */
        class LocationMessage implements ILocationMessage {

            /**
             * Constructs a new LocationMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.ILocationMessage);

            /** LocationMessage degreesLatitude. */
            public degreesLatitude: number;

            /** LocationMessage degreesLongitude. */
            public degreesLongitude: number;

            /** LocationMessage name. */
            public name: string;

            /** LocationMessage address. */
            public address: string;

            /** LocationMessage url. */
            public url: string;

            /** LocationMessage isLive. */
            public isLive: boolean;

            /** LocationMessage accuracyInMeters. */
            public accuracyInMeters: number;

            /** LocationMessage speedInMps. */
            public speedInMps: number;

            /** LocationMessage degreesClockwiseFromMagneticNorth. */
            public degreesClockwiseFromMagneticNorth: number;

            /** LocationMessage comment. */
            public comment: string;

            /** LocationMessage jpegThumbnail. */
            public jpegThumbnail: Uint8Array;

            /** LocationMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /**
             * Creates a new LocationMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns LocationMessage instance
             */
            public static create(properties?: proto.Message.ILocationMessage): proto.Message.LocationMessage;

            /**
             * Encodes the specified LocationMessage message. Does not implicitly {@link proto.Message.LocationMessage.verify|verify} messages.
             * @param message LocationMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.ILocationMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified LocationMessage message, length delimited. Does not implicitly {@link proto.Message.LocationMessage.verify|verify} messages.
             * @param message LocationMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.ILocationMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a LocationMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns LocationMessage
             * @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): proto.Message.LocationMessage;

            /**
             * Decodes a LocationMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns LocationMessage
             * @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)): proto.Message.LocationMessage;

            /**
             * Verifies a LocationMessage 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 LocationMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns LocationMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.LocationMessage;

            /**
             * Creates a plain object from a LocationMessage message. Also converts values to other types if specified.
             * @param message LocationMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.LocationMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this LocationMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a MessageHistoryBundle. */
        interface IMessageHistoryBundle {

            /** MessageHistoryBundle mimetype */
            mimetype?: (string|null);

            /** MessageHistoryBundle fileSha256 */
            fileSha256?: (Uint8Array|null);

            /** MessageHistoryBundle mediaKey */
            mediaKey?: (Uint8Array|null);

            /** MessageHistoryBundle fileEncSha256 */
            fileEncSha256?: (Uint8Array|null);

            /** MessageHistoryBundle directPath */
            directPath?: (string|null);

            /** MessageHistoryBundle mediaKeyTimestamp */
            mediaKeyTimestamp?: (number|Long|null);

            /** MessageHistoryBundle contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** MessageHistoryBundle participants */
            participants?: (string[]|null);
        }

        /** Represents a MessageHistoryBundle. */
        class MessageHistoryBundle implements IMessageHistoryBundle {

            /**
             * Constructs a new MessageHistoryBundle.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IMessageHistoryBundle);

            /** MessageHistoryBundle mimetype. */
            public mimetype: string;

            /** MessageHistoryBundle fileSha256. */
            public fileSha256: Uint8Array;

            /** MessageHistoryBundle mediaKey. */
            public mediaKey: Uint8Array;

            /** MessageHistoryBundle fileEncSha256. */
            public fileEncSha256: Uint8Array;

            /** MessageHistoryBundle directPath. */
            public directPath: string;

            /** MessageHistoryBundle mediaKeyTimestamp. */
            public mediaKeyTimestamp: (number|Long);

            /** MessageHistoryBundle contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** MessageHistoryBundle participants. */
            public participants: string[];

            /**
             * Creates a new MessageHistoryBundle instance using the specified properties.
             * @param [properties] Properties to set
             * @returns MessageHistoryBundle instance
             */
            public static create(properties?: proto.Message.IMessageHistoryBundle): proto.Message.MessageHistoryBundle;

            /**
             * Encodes the specified MessageHistoryBundle message. Does not implicitly {@link proto.Message.MessageHistoryBundle.verify|verify} messages.
             * @param message MessageHistoryBundle message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IMessageHistoryBundle, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified MessageHistoryBundle message, length delimited. Does not implicitly {@link proto.Message.MessageHistoryBundle.verify|verify} messages.
             * @param message MessageHistoryBundle message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IMessageHistoryBundle, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a MessageHistoryBundle message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns MessageHistoryBundle
             * @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): proto.Message.MessageHistoryBundle;

            /**
             * Decodes a MessageHistoryBundle message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns MessageHistoryBundle
             * @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)): proto.Message.MessageHistoryBundle;

            /**
             * Verifies a MessageHistoryBundle 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 MessageHistoryBundle message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns MessageHistoryBundle
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.MessageHistoryBundle;

            /**
             * Creates a plain object from a MessageHistoryBundle message. Also converts values to other types if specified.
             * @param message MessageHistoryBundle
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.MessageHistoryBundle, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this MessageHistoryBundle to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a NewsletterAdminInviteMessage. */
        interface INewsletterAdminInviteMessage {

            /** NewsletterAdminInviteMessage newsletterJid */
            newsletterJid?: (string|null);

            /** NewsletterAdminInviteMessage newsletterName */
            newsletterName?: (string|null);

            /** NewsletterAdminInviteMessage jpegThumbnail */
            jpegThumbnail?: (Uint8Array|null);

            /** NewsletterAdminInviteMessage caption */
            caption?: (string|null);

            /** NewsletterAdminInviteMessage inviteExpiration */
            inviteExpiration?: (number|Long|null);
        }

        /** Represents a NewsletterAdminInviteMessage. */
        class NewsletterAdminInviteMessage implements INewsletterAdminInviteMessage {

            /**
             * Constructs a new NewsletterAdminInviteMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.INewsletterAdminInviteMessage);

            /** NewsletterAdminInviteMessage newsletterJid. */
            public newsletterJid: string;

            /** NewsletterAdminInviteMessage newsletterName. */
            public newsletterName: string;

            /** NewsletterAdminInviteMessage jpegThumbnail. */
            public jpegThumbnail: Uint8Array;

            /** NewsletterAdminInviteMessage caption. */
            public caption: string;

            /** NewsletterAdminInviteMessage inviteExpiration. */
            public inviteExpiration: (number|Long);

            /**
             * Creates a new NewsletterAdminInviteMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns NewsletterAdminInviteMessage instance
             */
            public static create(properties?: proto.Message.INewsletterAdminInviteMessage): proto.Message.NewsletterAdminInviteMessage;

            /**
             * Encodes the specified NewsletterAdminInviteMessage message. Does not implicitly {@link proto.Message.NewsletterAdminInviteMessage.verify|verify} messages.
             * @param message NewsletterAdminInviteMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.INewsletterAdminInviteMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified NewsletterAdminInviteMessage message, length delimited. Does not implicitly {@link proto.Message.NewsletterAdminInviteMessage.verify|verify} messages.
             * @param message NewsletterAdminInviteMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.INewsletterAdminInviteMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a NewsletterAdminInviteMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns NewsletterAdminInviteMessage
             * @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): proto.Message.NewsletterAdminInviteMessage;

            /**
             * Decodes a NewsletterAdminInviteMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns NewsletterAdminInviteMessage
             * @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)): proto.Message.NewsletterAdminInviteMessage;

            /**
             * Verifies a NewsletterAdminInviteMessage 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 NewsletterAdminInviteMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns NewsletterAdminInviteMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.NewsletterAdminInviteMessage;

            /**
             * Creates a plain object from a NewsletterAdminInviteMessage message. Also converts values to other types if specified.
             * @param message NewsletterAdminInviteMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.NewsletterAdminInviteMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this NewsletterAdminInviteMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an OrderMessage. */
        interface IOrderMessage {

            /** OrderMessage orderId */
            orderId?: (string|null);

            /** OrderMessage thumbnail */
            thumbnail?: (Uint8Array|null);

            /** OrderMessage itemCount */
            itemCount?: (number|null);

            /** OrderMessage status */
            status?: (proto.Message.OrderMessage.OrderStatus|null);

            /** OrderMessage surface */
            surface?: (proto.Message.OrderMessage.OrderSurface|null);

            /** OrderMessage message */
            message?: (string|null);

            /** OrderMessage orderTitle */
            orderTitle?: (string|null);

            /** OrderMessage sellerJid */
            sellerJid?: (string|null);

            /** OrderMessage token */
            token?: (string|null);

            /** OrderMessage totalAmount1000 */
            totalAmount1000?: (number|Long|null);

            /** OrderMessage totalCurrencyCode */
            totalCurrencyCode?: (string|null);

            /** OrderMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** OrderMessage messageVersion */
            messageVersion?: (number|null);

            /** OrderMessage orderRequestMessageId */
            orderRequestMessageId?: (proto.IMessageKey|null);
        }

        /** Represents an OrderMessage. */
        class OrderMessage implements IOrderMessage {

            /**
             * Constructs a new OrderMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IOrderMessage);

            /** OrderMessage orderId. */
            public orderId: string;

            /** OrderMessage thumbnail. */
            public thumbnail: Uint8Array;

            /** OrderMessage itemCount. */
            public itemCount: number;

            /** OrderMessage status. */
            public status: proto.Message.OrderMessage.OrderStatus;

            /** OrderMessage surface. */
            public surface: proto.Message.OrderMessage.OrderSurface;

            /** OrderMessage message. */
            public message: string;

            /** OrderMessage orderTitle. */
            public orderTitle: string;

            /** OrderMessage sellerJid. */
            public sellerJid: string;

            /** OrderMessage token. */
            public token: string;

            /** OrderMessage totalAmount1000. */
            public totalAmount1000: (number|Long);

            /** OrderMessage totalCurrencyCode. */
            public totalCurrencyCode: string;

            /** OrderMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** OrderMessage messageVersion. */
            public messageVersion: number;

            /** OrderMessage orderRequestMessageId. */
            public orderRequestMessageId?: (proto.IMessageKey|null);

            /**
             * Creates a new OrderMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns OrderMessage instance
             */
            public static create(properties?: proto.Message.IOrderMessage): proto.Message.OrderMessage;

            /**
             * Encodes the specified OrderMessage message. Does not implicitly {@link proto.Message.OrderMessage.verify|verify} messages.
             * @param message OrderMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IOrderMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified OrderMessage message, length delimited. Does not implicitly {@link proto.Message.OrderMessage.verify|verify} messages.
             * @param message OrderMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IOrderMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an OrderMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns OrderMessage
             * @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): proto.Message.OrderMessage;

            /**
             * Decodes an OrderMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns OrderMessage
             * @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)): proto.Message.OrderMessage;

            /**
             * Verifies an OrderMessage 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 OrderMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns OrderMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.OrderMessage;

            /**
             * Creates a plain object from an OrderMessage message. Also converts values to other types if specified.
             * @param message OrderMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.OrderMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this OrderMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace OrderMessage {

            /** OrderStatus enum. */
            enum OrderStatus {
                INQUIRY = 1,
                ACCEPTED = 2,
                DECLINED = 3
            }

            /** OrderSurface enum. */
            enum OrderSurface {
                CATALOG = 1
            }
        }

        /** Properties of a PaymentInviteMessage. */
        interface IPaymentInviteMessage {

            /** PaymentInviteMessage serviceType */
            serviceType?: (proto.Message.PaymentInviteMessage.ServiceType|null);

            /** PaymentInviteMessage expiryTimestamp */
            expiryTimestamp?: (number|Long|null);
        }

        /** Represents a PaymentInviteMessage. */
        class PaymentInviteMessage implements IPaymentInviteMessage {

            /**
             * Constructs a new PaymentInviteMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IPaymentInviteMessage);

            /** PaymentInviteMessage serviceType. */
            public serviceType: proto.Message.PaymentInviteMessage.ServiceType;

            /** PaymentInviteMessage expiryTimestamp. */
            public expiryTimestamp: (number|Long);

            /**
             * Creates a new PaymentInviteMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PaymentInviteMessage instance
             */
            public static create(properties?: proto.Message.IPaymentInviteMessage): proto.Message.PaymentInviteMessage;

            /**
             * Encodes the specified PaymentInviteMessage message. Does not implicitly {@link proto.Message.PaymentInviteMessage.verify|verify} messages.
             * @param message PaymentInviteMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IPaymentInviteMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PaymentInviteMessage message, length delimited. Does not implicitly {@link proto.Message.PaymentInviteMessage.verify|verify} messages.
             * @param message PaymentInviteMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IPaymentInviteMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PaymentInviteMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PaymentInviteMessage
             * @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): proto.Message.PaymentInviteMessage;

            /**
             * Decodes a PaymentInviteMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PaymentInviteMessage
             * @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)): proto.Message.PaymentInviteMessage;

            /**
             * Verifies a PaymentInviteMessage 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 PaymentInviteMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PaymentInviteMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.PaymentInviteMessage;

            /**
             * Creates a plain object from a PaymentInviteMessage message. Also converts values to other types if specified.
             * @param message PaymentInviteMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.PaymentInviteMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PaymentInviteMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace PaymentInviteMessage {

            /** ServiceType enum. */
            enum ServiceType {
                UNKNOWN = 0,
                FBPAY = 1,
                NOVI = 2,
                UPI = 3
            }
        }

        /** Properties of a PeerDataOperationRequestMessage. */
        interface IPeerDataOperationRequestMessage {

            /** PeerDataOperationRequestMessage peerDataOperationRequestType */
            peerDataOperationRequestType?: (proto.Message.PeerDataOperationRequestType|null);

            /** PeerDataOperationRequestMessage requestStickerReupload */
            requestStickerReupload?: (proto.Message.PeerDataOperationRequestMessage.IRequestStickerReupload[]|null);

            /** PeerDataOperationRequestMessage requestUrlPreview */
            requestUrlPreview?: (proto.Message.PeerDataOperationRequestMessage.IRequestUrlPreview[]|null);

            /** PeerDataOperationRequestMessage historySyncOnDemandRequest */
            historySyncOnDemandRequest?: (proto.Message.PeerDataOperationRequestMessage.IHistorySyncOnDemandRequest|null);

            /** PeerDataOperationRequestMessage placeholderMessageResendRequest */
            placeholderMessageResendRequest?: (proto.Message.PeerDataOperationRequestMessage.IPlaceholderMessageResendRequest[]|null);
        }

        /** Represents a PeerDataOperationRequestMessage. */
        class PeerDataOperationRequestMessage implements IPeerDataOperationRequestMessage {

            /**
             * Constructs a new PeerDataOperationRequestMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IPeerDataOperationRequestMessage);

            /** PeerDataOperationRequestMessage peerDataOperationRequestType. */
            public peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType;

            /** PeerDataOperationRequestMessage requestStickerReupload. */
            public requestStickerReupload: proto.Message.PeerDataOperationRequestMessage.IRequestStickerReupload[];

            /** PeerDataOperationRequestMessage requestUrlPreview. */
            public requestUrlPreview: proto.Message.PeerDataOperationRequestMessage.IRequestUrlPreview[];

            /** PeerDataOperationRequestMessage historySyncOnDemandRequest. */
            public historySyncOnDemandRequest?: (proto.Message.PeerDataOperationRequestMessage.IHistorySyncOnDemandRequest|null);

            /** PeerDataOperationRequestMessage placeholderMessageResendRequest. */
            public placeholderMessageResendRequest: proto.Message.PeerDataOperationRequestMessage.IPlaceholderMessageResendRequest[];

            /**
             * Creates a new PeerDataOperationRequestMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PeerDataOperationRequestMessage instance
             */
            public static create(properties?: proto.Message.IPeerDataOperationRequestMessage): proto.Message.PeerDataOperationRequestMessage;

            /**
             * Encodes the specified PeerDataOperationRequestMessage message. Does not implicitly {@link proto.Message.PeerDataOperationRequestMessage.verify|verify} messages.
             * @param message PeerDataOperationRequestMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IPeerDataOperationRequestMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PeerDataOperationRequestMessage message, length delimited. Does not implicitly {@link proto.Message.PeerDataOperationRequestMessage.verify|verify} messages.
             * @param message PeerDataOperationRequestMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IPeerDataOperationRequestMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PeerDataOperationRequestMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PeerDataOperationRequestMessage
             * @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): proto.Message.PeerDataOperationRequestMessage;

            /**
             * Decodes a PeerDataOperationRequestMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PeerDataOperationRequestMessage
             * @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)): proto.Message.PeerDataOperationRequestMessage;

            /**
             * Verifies a PeerDataOperationRequestMessage 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 PeerDataOperationRequestMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PeerDataOperationRequestMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.PeerDataOperationRequestMessage;

            /**
             * Creates a plain object from a PeerDataOperationRequestMessage message. Also converts values to other types if specified.
             * @param message PeerDataOperationRequestMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.PeerDataOperationRequestMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PeerDataOperationRequestMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace PeerDataOperationRequestMessage {

            /** Properties of a HistorySyncOnDemandRequest. */
            interface IHistorySyncOnDemandRequest {

                /** HistorySyncOnDemandRequest chatJid */
                chatJid?: (string|null);

                /** HistorySyncOnDemandRequest oldestMsgId */
                oldestMsgId?: (string|null);

                /** HistorySyncOnDemandRequest oldestMsgFromMe */
                oldestMsgFromMe?: (boolean|null);

                /** HistorySyncOnDemandRequest onDemandMsgCount */
                onDemandMsgCount?: (number|null);

                /** HistorySyncOnDemandRequest oldestMsgTimestampMs */
                oldestMsgTimestampMs?: (number|Long|null);
            }

            /** Represents a HistorySyncOnDemandRequest. */
            class HistorySyncOnDemandRequest implements IHistorySyncOnDemandRequest {

                /**
                 * Constructs a new HistorySyncOnDemandRequest.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.PeerDataOperationRequestMessage.IHistorySyncOnDemandRequest);

                /** HistorySyncOnDemandRequest chatJid. */
                public chatJid: string;

                /** HistorySyncOnDemandRequest oldestMsgId. */
                public oldestMsgId: string;

                /** HistorySyncOnDemandRequest oldestMsgFromMe. */
                public oldestMsgFromMe: boolean;

                /** HistorySyncOnDemandRequest onDemandMsgCount. */
                public onDemandMsgCount: number;

                /** HistorySyncOnDemandRequest oldestMsgTimestampMs. */
                public oldestMsgTimestampMs: (number|Long);

                /**
                 * Creates a new HistorySyncOnDemandRequest instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns HistorySyncOnDemandRequest instance
                 */
                public static create(properties?: proto.Message.PeerDataOperationRequestMessage.IHistorySyncOnDemandRequest): proto.Message.PeerDataOperationRequestMessage.HistorySyncOnDemandRequest;

                /**
                 * Encodes the specified HistorySyncOnDemandRequest message. Does not implicitly {@link proto.Message.PeerDataOperationRequestMessage.HistorySyncOnDemandRequest.verify|verify} messages.
                 * @param message HistorySyncOnDemandRequest message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.PeerDataOperationRequestMessage.IHistorySyncOnDemandRequest, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified HistorySyncOnDemandRequest message, length delimited. Does not implicitly {@link proto.Message.PeerDataOperationRequestMessage.HistorySyncOnDemandRequest.verify|verify} messages.
                 * @param message HistorySyncOnDemandRequest message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.PeerDataOperationRequestMessage.IHistorySyncOnDemandRequest, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a HistorySyncOnDemandRequest message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns HistorySyncOnDemandRequest
                 * @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): proto.Message.PeerDataOperationRequestMessage.HistorySyncOnDemandRequest;

                /**
                 * Decodes a HistorySyncOnDemandRequest message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns HistorySyncOnDemandRequest
                 * @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)): proto.Message.PeerDataOperationRequestMessage.HistorySyncOnDemandRequest;

                /**
                 * Verifies a HistorySyncOnDemandRequest 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 HistorySyncOnDemandRequest message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns HistorySyncOnDemandRequest
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.PeerDataOperationRequestMessage.HistorySyncOnDemandRequest;

                /**
                 * Creates a plain object from a HistorySyncOnDemandRequest message. Also converts values to other types if specified.
                 * @param message HistorySyncOnDemandRequest
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.PeerDataOperationRequestMessage.HistorySyncOnDemandRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this HistorySyncOnDemandRequest to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a PlaceholderMessageResendRequest. */
            interface IPlaceholderMessageResendRequest {

                /** PlaceholderMessageResendRequest messageKey */
                messageKey?: (proto.IMessageKey|null);
            }

            /** Represents a PlaceholderMessageResendRequest. */
            class PlaceholderMessageResendRequest implements IPlaceholderMessageResendRequest {

                /**
                 * Constructs a new PlaceholderMessageResendRequest.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.PeerDataOperationRequestMessage.IPlaceholderMessageResendRequest);

                /** PlaceholderMessageResendRequest messageKey. */
                public messageKey?: (proto.IMessageKey|null);

                /**
                 * Creates a new PlaceholderMessageResendRequest instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns PlaceholderMessageResendRequest instance
                 */
                public static create(properties?: proto.Message.PeerDataOperationRequestMessage.IPlaceholderMessageResendRequest): proto.Message.PeerDataOperationRequestMessage.PlaceholderMessageResendRequest;

                /**
                 * Encodes the specified PlaceholderMessageResendRequest message. Does not implicitly {@link proto.Message.PeerDataOperationRequestMessage.PlaceholderMessageResendRequest.verify|verify} messages.
                 * @param message PlaceholderMessageResendRequest message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.PeerDataOperationRequestMessage.IPlaceholderMessageResendRequest, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified PlaceholderMessageResendRequest message, length delimited. Does not implicitly {@link proto.Message.PeerDataOperationRequestMessage.PlaceholderMessageResendRequest.verify|verify} messages.
                 * @param message PlaceholderMessageResendRequest message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.PeerDataOperationRequestMessage.IPlaceholderMessageResendRequest, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a PlaceholderMessageResendRequest message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns PlaceholderMessageResendRequest
                 * @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): proto.Message.PeerDataOperationRequestMessage.PlaceholderMessageResendRequest;

                /**
                 * Decodes a PlaceholderMessageResendRequest message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns PlaceholderMessageResendRequest
                 * @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)): proto.Message.PeerDataOperationRequestMessage.PlaceholderMessageResendRequest;

                /**
                 * Verifies a PlaceholderMessageResendRequest 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 PlaceholderMessageResendRequest message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns PlaceholderMessageResendRequest
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.PeerDataOperationRequestMessage.PlaceholderMessageResendRequest;

                /**
                 * Creates a plain object from a PlaceholderMessageResendRequest message. Also converts values to other types if specified.
                 * @param message PlaceholderMessageResendRequest
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.PeerDataOperationRequestMessage.PlaceholderMessageResendRequest, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this PlaceholderMessageResendRequest to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a RequestStickerReupload. */
            interface IRequestStickerReupload {

                /** RequestStickerReupload fileSha256 */
                fileSha256?: (string|null);
            }

            /** Represents a RequestStickerReupload. */
            class RequestStickerReupload implements IRequestStickerReupload {

                /**
                 * Constructs a new RequestStickerReupload.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.PeerDataOperationRequestMessage.IRequestStickerReupload);

                /** RequestStickerReupload fileSha256. */
                public fileSha256: string;

                /**
                 * Creates a new RequestStickerReupload instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns RequestStickerReupload instance
                 */
                public static create(properties?: proto.Message.PeerDataOperationRequestMessage.IRequestStickerReupload): proto.Message.PeerDataOperationRequestMessage.RequestStickerReupload;

                /**
                 * Encodes the specified RequestStickerReupload message. Does not implicitly {@link proto.Message.PeerDataOperationRequestMessage.RequestStickerReupload.verify|verify} messages.
                 * @param message RequestStickerReupload message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.PeerDataOperationRequestMessage.IRequestStickerReupload, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified RequestStickerReupload message, length delimited. Does not implicitly {@link proto.Message.PeerDataOperationRequestMessage.RequestStickerReupload.verify|verify} messages.
                 * @param message RequestStickerReupload message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.PeerDataOperationRequestMessage.IRequestStickerReupload, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a RequestStickerReupload message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns RequestStickerReupload
                 * @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): proto.Message.PeerDataOperationRequestMessage.RequestStickerReupload;

                /**
                 * Decodes a RequestStickerReupload message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns RequestStickerReupload
                 * @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)): proto.Message.PeerDataOperationRequestMessage.RequestStickerReupload;

                /**
                 * Verifies a RequestStickerReupload 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 RequestStickerReupload message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns RequestStickerReupload
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.PeerDataOperationRequestMessage.RequestStickerReupload;

                /**
                 * Creates a plain object from a RequestStickerReupload message. Also converts values to other types if specified.
                 * @param message RequestStickerReupload
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.PeerDataOperationRequestMessage.RequestStickerReupload, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this RequestStickerReupload to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a RequestUrlPreview. */
            interface IRequestUrlPreview {

                /** RequestUrlPreview url */
                url?: (string|null);

                /** RequestUrlPreview includeHqThumbnail */
                includeHqThumbnail?: (boolean|null);
            }

            /** Represents a RequestUrlPreview. */
            class RequestUrlPreview implements IRequestUrlPreview {

                /**
                 * Constructs a new RequestUrlPreview.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.PeerDataOperationRequestMessage.IRequestUrlPreview);

                /** RequestUrlPreview url. */
                public url: string;

                /** RequestUrlPreview includeHqThumbnail. */
                public includeHqThumbnail: boolean;

                /**
                 * Creates a new RequestUrlPreview instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns RequestUrlPreview instance
                 */
                public static create(properties?: proto.Message.PeerDataOperationRequestMessage.IRequestUrlPreview): proto.Message.PeerDataOperationRequestMessage.RequestUrlPreview;

                /**
                 * Encodes the specified RequestUrlPreview message. Does not implicitly {@link proto.Message.PeerDataOperationRequestMessage.RequestUrlPreview.verify|verify} messages.
                 * @param message RequestUrlPreview message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.PeerDataOperationRequestMessage.IRequestUrlPreview, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified RequestUrlPreview message, length delimited. Does not implicitly {@link proto.Message.PeerDataOperationRequestMessage.RequestUrlPreview.verify|verify} messages.
                 * @param message RequestUrlPreview message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.PeerDataOperationRequestMessage.IRequestUrlPreview, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a RequestUrlPreview message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns RequestUrlPreview
                 * @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): proto.Message.PeerDataOperationRequestMessage.RequestUrlPreview;

                /**
                 * Decodes a RequestUrlPreview message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns RequestUrlPreview
                 * @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)): proto.Message.PeerDataOperationRequestMessage.RequestUrlPreview;

                /**
                 * Verifies a RequestUrlPreview 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 RequestUrlPreview message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns RequestUrlPreview
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.PeerDataOperationRequestMessage.RequestUrlPreview;

                /**
                 * Creates a plain object from a RequestUrlPreview message. Also converts values to other types if specified.
                 * @param message RequestUrlPreview
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.PeerDataOperationRequestMessage.RequestUrlPreview, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this RequestUrlPreview to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }
        }

        /** Properties of a PeerDataOperationRequestResponseMessage. */
        interface IPeerDataOperationRequestResponseMessage {

            /** PeerDataOperationRequestResponseMessage peerDataOperationRequestType */
            peerDataOperationRequestType?: (proto.Message.PeerDataOperationRequestType|null);

            /** PeerDataOperationRequestResponseMessage stanzaId */
            stanzaId?: (string|null);

            /** PeerDataOperationRequestResponseMessage peerDataOperationResult */
            peerDataOperationResult?: (proto.Message.PeerDataOperationRequestResponseMessage.IPeerDataOperationResult[]|null);
        }

        /** Represents a PeerDataOperationRequestResponseMessage. */
        class PeerDataOperationRequestResponseMessage implements IPeerDataOperationRequestResponseMessage {

            /**
             * Constructs a new PeerDataOperationRequestResponseMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IPeerDataOperationRequestResponseMessage);

            /** PeerDataOperationRequestResponseMessage peerDataOperationRequestType. */
            public peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType;

            /** PeerDataOperationRequestResponseMessage stanzaId. */
            public stanzaId: string;

            /** PeerDataOperationRequestResponseMessage peerDataOperationResult. */
            public peerDataOperationResult: proto.Message.PeerDataOperationRequestResponseMessage.IPeerDataOperationResult[];

            /**
             * Creates a new PeerDataOperationRequestResponseMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PeerDataOperationRequestResponseMessage instance
             */
            public static create(properties?: proto.Message.IPeerDataOperationRequestResponseMessage): proto.Message.PeerDataOperationRequestResponseMessage;

            /**
             * Encodes the specified PeerDataOperationRequestResponseMessage message. Does not implicitly {@link proto.Message.PeerDataOperationRequestResponseMessage.verify|verify} messages.
             * @param message PeerDataOperationRequestResponseMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IPeerDataOperationRequestResponseMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PeerDataOperationRequestResponseMessage message, length delimited. Does not implicitly {@link proto.Message.PeerDataOperationRequestResponseMessage.verify|verify} messages.
             * @param message PeerDataOperationRequestResponseMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IPeerDataOperationRequestResponseMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PeerDataOperationRequestResponseMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PeerDataOperationRequestResponseMessage
             * @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): proto.Message.PeerDataOperationRequestResponseMessage;

            /**
             * Decodes a PeerDataOperationRequestResponseMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PeerDataOperationRequestResponseMessage
             * @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)): proto.Message.PeerDataOperationRequestResponseMessage;

            /**
             * Verifies a PeerDataOperationRequestResponseMessage 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 PeerDataOperationRequestResponseMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PeerDataOperationRequestResponseMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.PeerDataOperationRequestResponseMessage;

            /**
             * Creates a plain object from a PeerDataOperationRequestResponseMessage message. Also converts values to other types if specified.
             * @param message PeerDataOperationRequestResponseMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.PeerDataOperationRequestResponseMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PeerDataOperationRequestResponseMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace PeerDataOperationRequestResponseMessage {

            /** Properties of a PeerDataOperationResult. */
            interface IPeerDataOperationResult {

                /** PeerDataOperationResult mediaUploadResult */
                mediaUploadResult?: (proto.MediaRetryNotification.ResultType|null);

                /** PeerDataOperationResult stickerMessage */
                stickerMessage?: (proto.Message.IStickerMessage|null);

                /** PeerDataOperationResult linkPreviewResponse */
                linkPreviewResponse?: (proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.ILinkPreviewResponse|null);

                /** PeerDataOperationResult placeholderMessageResendResponse */
                placeholderMessageResendResponse?: (proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.IPlaceholderMessageResendResponse|null);
            }

            /** Represents a PeerDataOperationResult. */
            class PeerDataOperationResult implements IPeerDataOperationResult {

                /**
                 * Constructs a new PeerDataOperationResult.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.PeerDataOperationRequestResponseMessage.IPeerDataOperationResult);

                /** PeerDataOperationResult mediaUploadResult. */
                public mediaUploadResult: proto.MediaRetryNotification.ResultType;

                /** PeerDataOperationResult stickerMessage. */
                public stickerMessage?: (proto.Message.IStickerMessage|null);

                /** PeerDataOperationResult linkPreviewResponse. */
                public linkPreviewResponse?: (proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.ILinkPreviewResponse|null);

                /** PeerDataOperationResult placeholderMessageResendResponse. */
                public placeholderMessageResendResponse?: (proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.IPlaceholderMessageResendResponse|null);

                /**
                 * Creates a new PeerDataOperationResult instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns PeerDataOperationResult instance
                 */
                public static create(properties?: proto.Message.PeerDataOperationRequestResponseMessage.IPeerDataOperationResult): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult;

                /**
                 * Encodes the specified PeerDataOperationResult message. Does not implicitly {@link proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.verify|verify} messages.
                 * @param message PeerDataOperationResult message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.PeerDataOperationRequestResponseMessage.IPeerDataOperationResult, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified PeerDataOperationResult message, length delimited. Does not implicitly {@link proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.verify|verify} messages.
                 * @param message PeerDataOperationResult message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.PeerDataOperationRequestResponseMessage.IPeerDataOperationResult, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a PeerDataOperationResult message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns PeerDataOperationResult
                 * @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): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult;

                /**
                 * Decodes a PeerDataOperationResult message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns PeerDataOperationResult
                 * @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)): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult;

                /**
                 * Verifies a PeerDataOperationResult 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 PeerDataOperationResult message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns PeerDataOperationResult
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult;

                /**
                 * Creates a plain object from a PeerDataOperationResult message. Also converts values to other types if specified.
                 * @param message PeerDataOperationResult
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this PeerDataOperationResult to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            namespace PeerDataOperationResult {

                /** Properties of a LinkPreviewResponse. */
                interface ILinkPreviewResponse {

                    /** LinkPreviewResponse url */
                    url?: (string|null);

                    /** LinkPreviewResponse title */
                    title?: (string|null);

                    /** LinkPreviewResponse description */
                    description?: (string|null);

                    /** LinkPreviewResponse thumbData */
                    thumbData?: (Uint8Array|null);

                    /** LinkPreviewResponse canonicalUrl */
                    canonicalUrl?: (string|null);

                    /** LinkPreviewResponse matchText */
                    matchText?: (string|null);

                    /** LinkPreviewResponse previewType */
                    previewType?: (string|null);

                    /** LinkPreviewResponse hqThumbnail */
                    hqThumbnail?: (proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.ILinkPreviewHighQualityThumbnail|null);
                }

                /** Represents a LinkPreviewResponse. */
                class LinkPreviewResponse implements ILinkPreviewResponse {

                    /**
                     * Constructs a new LinkPreviewResponse.
                     * @param [properties] Properties to set
                     */
                    constructor(properties?: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.ILinkPreviewResponse);

                    /** LinkPreviewResponse url. */
                    public url: string;

                    /** LinkPreviewResponse title. */
                    public title: string;

                    /** LinkPreviewResponse description. */
                    public description: string;

                    /** LinkPreviewResponse thumbData. */
                    public thumbData: Uint8Array;

                    /** LinkPreviewResponse canonicalUrl. */
                    public canonicalUrl: string;

                    /** LinkPreviewResponse matchText. */
                    public matchText: string;

                    /** LinkPreviewResponse previewType. */
                    public previewType: string;

                    /** LinkPreviewResponse hqThumbnail. */
                    public hqThumbnail?: (proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.ILinkPreviewHighQualityThumbnail|null);

                    /**
                     * Creates a new LinkPreviewResponse instance using the specified properties.
                     * @param [properties] Properties to set
                     * @returns LinkPreviewResponse instance
                     */
                    public static create(properties?: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.ILinkPreviewResponse): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse;

                    /**
                     * Encodes the specified LinkPreviewResponse message. Does not implicitly {@link proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.verify|verify} messages.
                     * @param message LinkPreviewResponse message or plain object to encode
                     * @param [writer] Writer to encode to
                     * @returns Writer
                     */
                    public static encode(message: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.ILinkPreviewResponse, writer?: $protobuf.Writer): $protobuf.Writer;

                    /**
                     * Encodes the specified LinkPreviewResponse message, length delimited. Does not implicitly {@link proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.verify|verify} messages.
                     * @param message LinkPreviewResponse message or plain object to encode
                     * @param [writer] Writer to encode to
                     * @returns Writer
                     */
                    public static encodeDelimited(message: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.ILinkPreviewResponse, writer?: $protobuf.Writer): $protobuf.Writer;

                    /**
                     * Decodes a LinkPreviewResponse message from the specified reader or buffer.
                     * @param reader Reader or buffer to decode from
                     * @param [length] Message length if known beforehand
                     * @returns LinkPreviewResponse
                     * @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): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse;

                    /**
                     * Decodes a LinkPreviewResponse message from the specified reader or buffer, length delimited.
                     * @param reader Reader or buffer to decode from
                     * @returns LinkPreviewResponse
                     * @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)): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse;

                    /**
                     * Verifies a LinkPreviewResponse 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 LinkPreviewResponse message from a plain object. Also converts values to their respective internal types.
                     * @param object Plain object
                     * @returns LinkPreviewResponse
                     */
                    public static fromObject(object: { [k: string]: any }): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse;

                    /**
                     * Creates a plain object from a LinkPreviewResponse message. Also converts values to other types if specified.
                     * @param message LinkPreviewResponse
                     * @param [options] Conversion options
                     * @returns Plain object
                     */
                    public static toObject(message: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };

                    /**
                     * Converts this LinkPreviewResponse to JSON.
                     * @returns JSON object
                     */
                    public toJSON(): { [k: string]: any };
                }

                namespace LinkPreviewResponse {

                    /** Properties of a LinkPreviewHighQualityThumbnail. */
                    interface ILinkPreviewHighQualityThumbnail {

                        /** LinkPreviewHighQualityThumbnail directPath */
                        directPath?: (string|null);

                        /** LinkPreviewHighQualityThumbnail thumbHash */
                        thumbHash?: (string|null);

                        /** LinkPreviewHighQualityThumbnail encThumbHash */
                        encThumbHash?: (string|null);

                        /** LinkPreviewHighQualityThumbnail mediaKey */
                        mediaKey?: (Uint8Array|null);

                        /** LinkPreviewHighQualityThumbnail mediaKeyTimestampMs */
                        mediaKeyTimestampMs?: (number|Long|null);

                        /** LinkPreviewHighQualityThumbnail thumbWidth */
                        thumbWidth?: (number|null);

                        /** LinkPreviewHighQualityThumbnail thumbHeight */
                        thumbHeight?: (number|null);
                    }

                    /** Represents a LinkPreviewHighQualityThumbnail. */
                    class LinkPreviewHighQualityThumbnail implements ILinkPreviewHighQualityThumbnail {

                        /**
                         * Constructs a new LinkPreviewHighQualityThumbnail.
                         * @param [properties] Properties to set
                         */
                        constructor(properties?: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.ILinkPreviewHighQualityThumbnail);

                        /** LinkPreviewHighQualityThumbnail directPath. */
                        public directPath: string;

                        /** LinkPreviewHighQualityThumbnail thumbHash. */
                        public thumbHash: string;

                        /** LinkPreviewHighQualityThumbnail encThumbHash. */
                        public encThumbHash: string;

                        /** LinkPreviewHighQualityThumbnail mediaKey. */
                        public mediaKey: Uint8Array;

                        /** LinkPreviewHighQualityThumbnail mediaKeyTimestampMs. */
                        public mediaKeyTimestampMs: (number|Long);

                        /** LinkPreviewHighQualityThumbnail thumbWidth. */
                        public thumbWidth: number;

                        /** LinkPreviewHighQualityThumbnail thumbHeight. */
                        public thumbHeight: number;

                        /**
                         * Creates a new LinkPreviewHighQualityThumbnail instance using the specified properties.
                         * @param [properties] Properties to set
                         * @returns LinkPreviewHighQualityThumbnail instance
                         */
                        public static create(properties?: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.ILinkPreviewHighQualityThumbnail): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.LinkPreviewHighQualityThumbnail;

                        /**
                         * Encodes the specified LinkPreviewHighQualityThumbnail message. Does not implicitly {@link proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.LinkPreviewHighQualityThumbnail.verify|verify} messages.
                         * @param message LinkPreviewHighQualityThumbnail message or plain object to encode
                         * @param [writer] Writer to encode to
                         * @returns Writer
                         */
                        public static encode(message: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.ILinkPreviewHighQualityThumbnail, writer?: $protobuf.Writer): $protobuf.Writer;

                        /**
                         * Encodes the specified LinkPreviewHighQualityThumbnail message, length delimited. Does not implicitly {@link proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.LinkPreviewHighQualityThumbnail.verify|verify} messages.
                         * @param message LinkPreviewHighQualityThumbnail message or plain object to encode
                         * @param [writer] Writer to encode to
                         * @returns Writer
                         */
                        public static encodeDelimited(message: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.ILinkPreviewHighQualityThumbnail, writer?: $protobuf.Writer): $protobuf.Writer;

                        /**
                         * Decodes a LinkPreviewHighQualityThumbnail message from the specified reader or buffer.
                         * @param reader Reader or buffer to decode from
                         * @param [length] Message length if known beforehand
                         * @returns LinkPreviewHighQualityThumbnail
                         * @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): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.LinkPreviewHighQualityThumbnail;

                        /**
                         * Decodes a LinkPreviewHighQualityThumbnail message from the specified reader or buffer, length delimited.
                         * @param reader Reader or buffer to decode from
                         * @returns LinkPreviewHighQualityThumbnail
                         * @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)): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.LinkPreviewHighQualityThumbnail;

                        /**
                         * Verifies a LinkPreviewHighQualityThumbnail 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 LinkPreviewHighQualityThumbnail message from a plain object. Also converts values to their respective internal types.
                         * @param object Plain object
                         * @returns LinkPreviewHighQualityThumbnail
                         */
                        public static fromObject(object: { [k: string]: any }): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.LinkPreviewHighQualityThumbnail;

                        /**
                         * Creates a plain object from a LinkPreviewHighQualityThumbnail message. Also converts values to other types if specified.
                         * @param message LinkPreviewHighQualityThumbnail
                         * @param [options] Conversion options
                         * @returns Plain object
                         */
                        public static toObject(message: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.LinkPreviewResponse.LinkPreviewHighQualityThumbnail, options?: $protobuf.IConversionOptions): { [k: string]: any };

                        /**
                         * Converts this LinkPreviewHighQualityThumbnail to JSON.
                         * @returns JSON object
                         */
                        public toJSON(): { [k: string]: any };
                    }
                }

                /** Properties of a PlaceholderMessageResendResponse. */
                interface IPlaceholderMessageResendResponse {

                    /** PlaceholderMessageResendResponse webMessageInfoBytes */
                    webMessageInfoBytes?: (Uint8Array|null);
                }

                /** Represents a PlaceholderMessageResendResponse. */
                class PlaceholderMessageResendResponse implements IPlaceholderMessageResendResponse {

                    /**
                     * Constructs a new PlaceholderMessageResendResponse.
                     * @param [properties] Properties to set
                     */
                    constructor(properties?: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.IPlaceholderMessageResendResponse);

                    /** PlaceholderMessageResendResponse webMessageInfoBytes. */
                    public webMessageInfoBytes: Uint8Array;

                    /**
                     * Creates a new PlaceholderMessageResendResponse instance using the specified properties.
                     * @param [properties] Properties to set
                     * @returns PlaceholderMessageResendResponse instance
                     */
                    public static create(properties?: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.IPlaceholderMessageResendResponse): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.PlaceholderMessageResendResponse;

                    /**
                     * Encodes the specified PlaceholderMessageResendResponse message. Does not implicitly {@link proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.PlaceholderMessageResendResponse.verify|verify} messages.
                     * @param message PlaceholderMessageResendResponse message or plain object to encode
                     * @param [writer] Writer to encode to
                     * @returns Writer
                     */
                    public static encode(message: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.IPlaceholderMessageResendResponse, writer?: $protobuf.Writer): $protobuf.Writer;

                    /**
                     * Encodes the specified PlaceholderMessageResendResponse message, length delimited. Does not implicitly {@link proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.PlaceholderMessageResendResponse.verify|verify} messages.
                     * @param message PlaceholderMessageResendResponse message or plain object to encode
                     * @param [writer] Writer to encode to
                     * @returns Writer
                     */
                    public static encodeDelimited(message: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.IPlaceholderMessageResendResponse, writer?: $protobuf.Writer): $protobuf.Writer;

                    /**
                     * Decodes a PlaceholderMessageResendResponse message from the specified reader or buffer.
                     * @param reader Reader or buffer to decode from
                     * @param [length] Message length if known beforehand
                     * @returns PlaceholderMessageResendResponse
                     * @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): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.PlaceholderMessageResendResponse;

                    /**
                     * Decodes a PlaceholderMessageResendResponse message from the specified reader or buffer, length delimited.
                     * @param reader Reader or buffer to decode from
                     * @returns PlaceholderMessageResendResponse
                     * @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)): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.PlaceholderMessageResendResponse;

                    /**
                     * Verifies a PlaceholderMessageResendResponse 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 PlaceholderMessageResendResponse message from a plain object. Also converts values to their respective internal types.
                     * @param object Plain object
                     * @returns PlaceholderMessageResendResponse
                     */
                    public static fromObject(object: { [k: string]: any }): proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.PlaceholderMessageResendResponse;

                    /**
                     * Creates a plain object from a PlaceholderMessageResendResponse message. Also converts values to other types if specified.
                     * @param message PlaceholderMessageResendResponse
                     * @param [options] Conversion options
                     * @returns Plain object
                     */
                    public static toObject(message: proto.Message.PeerDataOperationRequestResponseMessage.PeerDataOperationResult.PlaceholderMessageResendResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };

                    /**
                     * Converts this PlaceholderMessageResendResponse to JSON.
                     * @returns JSON object
                     */
                    public toJSON(): { [k: string]: any };
                }
            }
        }

        /** PeerDataOperationRequestType enum. */
        enum PeerDataOperationRequestType {
            UPLOAD_STICKER = 0,
            SEND_RECENT_STICKER_BOOTSTRAP = 1,
            GENERATE_LINK_PREVIEW = 2,
            HISTORY_SYNC_ON_DEMAND = 3,
            PLACEHOLDER_MESSAGE_RESEND = 4
        }

        /** Properties of a PinInChatMessage. */
        interface IPinInChatMessage {

            /** PinInChatMessage key */
            key?: (proto.IMessageKey|null);

            /** PinInChatMessage type */
            type?: (proto.Message.PinInChatMessage.Type|null);

            /** PinInChatMessage senderTimestampMs */
            senderTimestampMs?: (number|Long|null);
        }

        /** Represents a PinInChatMessage. */
        class PinInChatMessage implements IPinInChatMessage {

            /**
             * Constructs a new PinInChatMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IPinInChatMessage);

            /** PinInChatMessage key. */
            public key?: (proto.IMessageKey|null);

            /** PinInChatMessage type. */
            public type: proto.Message.PinInChatMessage.Type;

            /** PinInChatMessage senderTimestampMs. */
            public senderTimestampMs: (number|Long);

            /**
             * Creates a new PinInChatMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PinInChatMessage instance
             */
            public static create(properties?: proto.Message.IPinInChatMessage): proto.Message.PinInChatMessage;

            /**
             * Encodes the specified PinInChatMessage message. Does not implicitly {@link proto.Message.PinInChatMessage.verify|verify} messages.
             * @param message PinInChatMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IPinInChatMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PinInChatMessage message, length delimited. Does not implicitly {@link proto.Message.PinInChatMessage.verify|verify} messages.
             * @param message PinInChatMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IPinInChatMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PinInChatMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PinInChatMessage
             * @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): proto.Message.PinInChatMessage;

            /**
             * Decodes a PinInChatMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PinInChatMessage
             * @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)): proto.Message.PinInChatMessage;

            /**
             * Verifies a PinInChatMessage 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 PinInChatMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PinInChatMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.PinInChatMessage;

            /**
             * Creates a plain object from a PinInChatMessage message. Also converts values to other types if specified.
             * @param message PinInChatMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.PinInChatMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PinInChatMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace PinInChatMessage {

            /** Type enum. */
            enum Type {
                UNKNOWN_TYPE = 0,
                PIN_FOR_ALL = 1,
                UNPIN_FOR_ALL = 2
            }
        }

        /** Properties of a PlaceholderMessage. */
        interface IPlaceholderMessage {

            /** PlaceholderMessage type */
            type?: (proto.Message.PlaceholderMessage.PlaceholderType|null);
        }

        /** Represents a PlaceholderMessage. */
        class PlaceholderMessage implements IPlaceholderMessage {

            /**
             * Constructs a new PlaceholderMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IPlaceholderMessage);

            /** PlaceholderMessage type. */
            public type: proto.Message.PlaceholderMessage.PlaceholderType;

            /**
             * Creates a new PlaceholderMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PlaceholderMessage instance
             */
            public static create(properties?: proto.Message.IPlaceholderMessage): proto.Message.PlaceholderMessage;

            /**
             * Encodes the specified PlaceholderMessage message. Does not implicitly {@link proto.Message.PlaceholderMessage.verify|verify} messages.
             * @param message PlaceholderMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IPlaceholderMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PlaceholderMessage message, length delimited. Does not implicitly {@link proto.Message.PlaceholderMessage.verify|verify} messages.
             * @param message PlaceholderMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IPlaceholderMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PlaceholderMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PlaceholderMessage
             * @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): proto.Message.PlaceholderMessage;

            /**
             * Decodes a PlaceholderMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PlaceholderMessage
             * @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)): proto.Message.PlaceholderMessage;

            /**
             * Verifies a PlaceholderMessage 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 PlaceholderMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PlaceholderMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.PlaceholderMessage;

            /**
             * Creates a plain object from a PlaceholderMessage message. Also converts values to other types if specified.
             * @param message PlaceholderMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.PlaceholderMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PlaceholderMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace PlaceholderMessage {

            /** PlaceholderType enum. */
            enum PlaceholderType {
                MASK_LINKED_DEVICES = 0
            }
        }

        /** Properties of a PollCreationMessage. */
        interface IPollCreationMessage {

            /** PollCreationMessage encKey */
            encKey?: (Uint8Array|null);

            /** PollCreationMessage name */
            name?: (string|null);

            /** PollCreationMessage options */
            options?: (proto.Message.PollCreationMessage.IOption[]|null);

            /** PollCreationMessage selectableOptionsCount */
            selectableOptionsCount?: (number|null);

            /** PollCreationMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);
        }

        /** Represents a PollCreationMessage. */
        class PollCreationMessage implements IPollCreationMessage {

            /**
             * Constructs a new PollCreationMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IPollCreationMessage);

            /** PollCreationMessage encKey. */
            public encKey: Uint8Array;

            /** PollCreationMessage name. */
            public name: string;

            /** PollCreationMessage options. */
            public options: proto.Message.PollCreationMessage.IOption[];

            /** PollCreationMessage selectableOptionsCount. */
            public selectableOptionsCount: number;

            /** PollCreationMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /**
             * Creates a new PollCreationMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PollCreationMessage instance
             */
            public static create(properties?: proto.Message.IPollCreationMessage): proto.Message.PollCreationMessage;

            /**
             * Encodes the specified PollCreationMessage message. Does not implicitly {@link proto.Message.PollCreationMessage.verify|verify} messages.
             * @param message PollCreationMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IPollCreationMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PollCreationMessage message, length delimited. Does not implicitly {@link proto.Message.PollCreationMessage.verify|verify} messages.
             * @param message PollCreationMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IPollCreationMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PollCreationMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PollCreationMessage
             * @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): proto.Message.PollCreationMessage;

            /**
             * Decodes a PollCreationMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PollCreationMessage
             * @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)): proto.Message.PollCreationMessage;

            /**
             * Verifies a PollCreationMessage 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 PollCreationMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PollCreationMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.PollCreationMessage;

            /**
             * Creates a plain object from a PollCreationMessage message. Also converts values to other types if specified.
             * @param message PollCreationMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.PollCreationMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PollCreationMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace PollCreationMessage {

            /** Properties of an Option. */
            interface IOption {

                /** Option optionName */
                optionName?: (string|null);
            }

            /** Represents an Option. */
            class Option implements IOption {

                /**
                 * Constructs a new Option.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.PollCreationMessage.IOption);

                /** Option optionName. */
                public optionName: string;

                /**
                 * Creates a new Option instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns Option instance
                 */
                public static create(properties?: proto.Message.PollCreationMessage.IOption): proto.Message.PollCreationMessage.Option;

                /**
                 * Encodes the specified Option message. Does not implicitly {@link proto.Message.PollCreationMessage.Option.verify|verify} messages.
                 * @param message Option message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.PollCreationMessage.IOption, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified Option message, length delimited. Does not implicitly {@link proto.Message.PollCreationMessage.Option.verify|verify} messages.
                 * @param message Option message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.PollCreationMessage.IOption, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes an Option message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns Option
                 * @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): proto.Message.PollCreationMessage.Option;

                /**
                 * Decodes an Option message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns Option
                 * @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)): proto.Message.PollCreationMessage.Option;

                /**
                 * Verifies an Option 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 Option message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns Option
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.PollCreationMessage.Option;

                /**
                 * Creates a plain object from an Option message. Also converts values to other types if specified.
                 * @param message Option
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.PollCreationMessage.Option, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this Option to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }
        }

        /** Properties of a PollEncValue. */
        interface IPollEncValue {

            /** PollEncValue encPayload */
            encPayload?: (Uint8Array|null);

            /** PollEncValue encIv */
            encIv?: (Uint8Array|null);
        }

        /** Represents a PollEncValue. */
        class PollEncValue implements IPollEncValue {

            /**
             * Constructs a new PollEncValue.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IPollEncValue);

            /** PollEncValue encPayload. */
            public encPayload: Uint8Array;

            /** PollEncValue encIv. */
            public encIv: Uint8Array;

            /**
             * Creates a new PollEncValue instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PollEncValue instance
             */
            public static create(properties?: proto.Message.IPollEncValue): proto.Message.PollEncValue;

            /**
             * Encodes the specified PollEncValue message. Does not implicitly {@link proto.Message.PollEncValue.verify|verify} messages.
             * @param message PollEncValue message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IPollEncValue, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PollEncValue message, length delimited. Does not implicitly {@link proto.Message.PollEncValue.verify|verify} messages.
             * @param message PollEncValue message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IPollEncValue, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PollEncValue message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PollEncValue
             * @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): proto.Message.PollEncValue;

            /**
             * Decodes a PollEncValue message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PollEncValue
             * @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)): proto.Message.PollEncValue;

            /**
             * Verifies a PollEncValue 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 PollEncValue message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PollEncValue
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.PollEncValue;

            /**
             * Creates a plain object from a PollEncValue message. Also converts values to other types if specified.
             * @param message PollEncValue
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.PollEncValue, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PollEncValue to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a PollUpdateMessage. */
        interface IPollUpdateMessage {

            /** PollUpdateMessage pollCreationMessageKey */
            pollCreationMessageKey?: (proto.IMessageKey|null);

            /** PollUpdateMessage vote */
            vote?: (proto.Message.IPollEncValue|null);

            /** PollUpdateMessage metadata */
            metadata?: (proto.Message.IPollUpdateMessageMetadata|null);

            /** PollUpdateMessage senderTimestampMs */
            senderTimestampMs?: (number|Long|null);
        }

        /** Represents a PollUpdateMessage. */
        class PollUpdateMessage implements IPollUpdateMessage {

            /**
             * Constructs a new PollUpdateMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IPollUpdateMessage);

            /** PollUpdateMessage pollCreationMessageKey. */
            public pollCreationMessageKey?: (proto.IMessageKey|null);

            /** PollUpdateMessage vote. */
            public vote?: (proto.Message.IPollEncValue|null);

            /** PollUpdateMessage metadata. */
            public metadata?: (proto.Message.IPollUpdateMessageMetadata|null);

            /** PollUpdateMessage senderTimestampMs. */
            public senderTimestampMs: (number|Long);

            /**
             * Creates a new PollUpdateMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PollUpdateMessage instance
             */
            public static create(properties?: proto.Message.IPollUpdateMessage): proto.Message.PollUpdateMessage;

            /**
             * Encodes the specified PollUpdateMessage message. Does not implicitly {@link proto.Message.PollUpdateMessage.verify|verify} messages.
             * @param message PollUpdateMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IPollUpdateMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PollUpdateMessage message, length delimited. Does not implicitly {@link proto.Message.PollUpdateMessage.verify|verify} messages.
             * @param message PollUpdateMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IPollUpdateMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PollUpdateMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PollUpdateMessage
             * @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): proto.Message.PollUpdateMessage;

            /**
             * Decodes a PollUpdateMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PollUpdateMessage
             * @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)): proto.Message.PollUpdateMessage;

            /**
             * Verifies a PollUpdateMessage 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 PollUpdateMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PollUpdateMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.PollUpdateMessage;

            /**
             * Creates a plain object from a PollUpdateMessage message. Also converts values to other types if specified.
             * @param message PollUpdateMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.PollUpdateMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PollUpdateMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a PollUpdateMessageMetadata. */
        interface IPollUpdateMessageMetadata {
        }

        /** Represents a PollUpdateMessageMetadata. */
        class PollUpdateMessageMetadata implements IPollUpdateMessageMetadata {

            /**
             * Constructs a new PollUpdateMessageMetadata.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IPollUpdateMessageMetadata);

            /**
             * Creates a new PollUpdateMessageMetadata instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PollUpdateMessageMetadata instance
             */
            public static create(properties?: proto.Message.IPollUpdateMessageMetadata): proto.Message.PollUpdateMessageMetadata;

            /**
             * Encodes the specified PollUpdateMessageMetadata message. Does not implicitly {@link proto.Message.PollUpdateMessageMetadata.verify|verify} messages.
             * @param message PollUpdateMessageMetadata message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IPollUpdateMessageMetadata, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PollUpdateMessageMetadata message, length delimited. Does not implicitly {@link proto.Message.PollUpdateMessageMetadata.verify|verify} messages.
             * @param message PollUpdateMessageMetadata message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IPollUpdateMessageMetadata, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PollUpdateMessageMetadata message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PollUpdateMessageMetadata
             * @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): proto.Message.PollUpdateMessageMetadata;

            /**
             * Decodes a PollUpdateMessageMetadata message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PollUpdateMessageMetadata
             * @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)): proto.Message.PollUpdateMessageMetadata;

            /**
             * Verifies a PollUpdateMessageMetadata 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 PollUpdateMessageMetadata message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PollUpdateMessageMetadata
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.PollUpdateMessageMetadata;

            /**
             * Creates a plain object from a PollUpdateMessageMetadata message. Also converts values to other types if specified.
             * @param message PollUpdateMessageMetadata
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.PollUpdateMessageMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PollUpdateMessageMetadata to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a PollVoteMessage. */
        interface IPollVoteMessage {

            /** PollVoteMessage selectedOptions */
            selectedOptions?: (Uint8Array[]|null);
        }

        /** Represents a PollVoteMessage. */
        class PollVoteMessage implements IPollVoteMessage {

            /**
             * Constructs a new PollVoteMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IPollVoteMessage);

            /** PollVoteMessage selectedOptions. */
            public selectedOptions: Uint8Array[];

            /**
             * Creates a new PollVoteMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PollVoteMessage instance
             */
            public static create(properties?: proto.Message.IPollVoteMessage): proto.Message.PollVoteMessage;

            /**
             * Encodes the specified PollVoteMessage message. Does not implicitly {@link proto.Message.PollVoteMessage.verify|verify} messages.
             * @param message PollVoteMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IPollVoteMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PollVoteMessage message, length delimited. Does not implicitly {@link proto.Message.PollVoteMessage.verify|verify} messages.
             * @param message PollVoteMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IPollVoteMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PollVoteMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PollVoteMessage
             * @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): proto.Message.PollVoteMessage;

            /**
             * Decodes a PollVoteMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PollVoteMessage
             * @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)): proto.Message.PollVoteMessage;

            /**
             * Verifies a PollVoteMessage 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 PollVoteMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PollVoteMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.PollVoteMessage;

            /**
             * Creates a plain object from a PollVoteMessage message. Also converts values to other types if specified.
             * @param message PollVoteMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.PollVoteMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PollVoteMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a ProductMessage. */
        interface IProductMessage {

            /** ProductMessage product */
            product?: (proto.Message.ProductMessage.IProductSnapshot|null);

            /** ProductMessage businessOwnerJid */
            businessOwnerJid?: (string|null);

            /** ProductMessage catalog */
            catalog?: (proto.Message.ProductMessage.ICatalogSnapshot|null);

            /** ProductMessage body */
            body?: (string|null);

            /** ProductMessage footer */
            footer?: (string|null);

            /** ProductMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);
        }

        /** Represents a ProductMessage. */
        class ProductMessage implements IProductMessage {

            /**
             * Constructs a new ProductMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IProductMessage);

            /** ProductMessage product. */
            public product?: (proto.Message.ProductMessage.IProductSnapshot|null);

            /** ProductMessage businessOwnerJid. */
            public businessOwnerJid: string;

            /** ProductMessage catalog. */
            public catalog?: (proto.Message.ProductMessage.ICatalogSnapshot|null);

            /** ProductMessage body. */
            public body: string;

            /** ProductMessage footer. */
            public footer: string;

            /** ProductMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /**
             * Creates a new ProductMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ProductMessage instance
             */
            public static create(properties?: proto.Message.IProductMessage): proto.Message.ProductMessage;

            /**
             * Encodes the specified ProductMessage message. Does not implicitly {@link proto.Message.ProductMessage.verify|verify} messages.
             * @param message ProductMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IProductMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ProductMessage message, length delimited. Does not implicitly {@link proto.Message.ProductMessage.verify|verify} messages.
             * @param message ProductMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IProductMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ProductMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ProductMessage
             * @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): proto.Message.ProductMessage;

            /**
             * Decodes a ProductMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ProductMessage
             * @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)): proto.Message.ProductMessage;

            /**
             * Verifies a ProductMessage 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 ProductMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ProductMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.ProductMessage;

            /**
             * Creates a plain object from a ProductMessage message. Also converts values to other types if specified.
             * @param message ProductMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.ProductMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ProductMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace ProductMessage {

            /** Properties of a CatalogSnapshot. */
            interface ICatalogSnapshot {

                /** CatalogSnapshot catalogImage */
                catalogImage?: (proto.Message.IImageMessage|null);

                /** CatalogSnapshot title */
                title?: (string|null);

                /** CatalogSnapshot description */
                description?: (string|null);
            }

            /** Represents a CatalogSnapshot. */
            class CatalogSnapshot implements ICatalogSnapshot {

                /**
                 * Constructs a new CatalogSnapshot.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.ProductMessage.ICatalogSnapshot);

                /** CatalogSnapshot catalogImage. */
                public catalogImage?: (proto.Message.IImageMessage|null);

                /** CatalogSnapshot title. */
                public title: string;

                /** CatalogSnapshot description. */
                public description: string;

                /**
                 * Creates a new CatalogSnapshot instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns CatalogSnapshot instance
                 */
                public static create(properties?: proto.Message.ProductMessage.ICatalogSnapshot): proto.Message.ProductMessage.CatalogSnapshot;

                /**
                 * Encodes the specified CatalogSnapshot message. Does not implicitly {@link proto.Message.ProductMessage.CatalogSnapshot.verify|verify} messages.
                 * @param message CatalogSnapshot message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.ProductMessage.ICatalogSnapshot, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified CatalogSnapshot message, length delimited. Does not implicitly {@link proto.Message.ProductMessage.CatalogSnapshot.verify|verify} messages.
                 * @param message CatalogSnapshot message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.ProductMessage.ICatalogSnapshot, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a CatalogSnapshot message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns CatalogSnapshot
                 * @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): proto.Message.ProductMessage.CatalogSnapshot;

                /**
                 * Decodes a CatalogSnapshot message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns CatalogSnapshot
                 * @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)): proto.Message.ProductMessage.CatalogSnapshot;

                /**
                 * Verifies a CatalogSnapshot 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 CatalogSnapshot message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns CatalogSnapshot
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.ProductMessage.CatalogSnapshot;

                /**
                 * Creates a plain object from a CatalogSnapshot message. Also converts values to other types if specified.
                 * @param message CatalogSnapshot
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.ProductMessage.CatalogSnapshot, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this CatalogSnapshot to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a ProductSnapshot. */
            interface IProductSnapshot {

                /** ProductSnapshot productImage */
                productImage?: (proto.Message.IImageMessage|null);

                /** ProductSnapshot productId */
                productId?: (string|null);

                /** ProductSnapshot title */
                title?: (string|null);

                /** ProductSnapshot description */
                description?: (string|null);

                /** ProductSnapshot currencyCode */
                currencyCode?: (string|null);

                /** ProductSnapshot priceAmount1000 */
                priceAmount1000?: (number|Long|null);

                /** ProductSnapshot retailerId */
                retailerId?: (string|null);

                /** ProductSnapshot url */
                url?: (string|null);

                /** ProductSnapshot productImageCount */
                productImageCount?: (number|null);

                /** ProductSnapshot firstImageId */
                firstImageId?: (string|null);

                /** ProductSnapshot salePriceAmount1000 */
                salePriceAmount1000?: (number|Long|null);
            }

            /** Represents a ProductSnapshot. */
            class ProductSnapshot implements IProductSnapshot {

                /**
                 * Constructs a new ProductSnapshot.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.ProductMessage.IProductSnapshot);

                /** ProductSnapshot productImage. */
                public productImage?: (proto.Message.IImageMessage|null);

                /** ProductSnapshot productId. */
                public productId: string;

                /** ProductSnapshot title. */
                public title: string;

                /** ProductSnapshot description. */
                public description: string;

                /** ProductSnapshot currencyCode. */
                public currencyCode: string;

                /** ProductSnapshot priceAmount1000. */
                public priceAmount1000: (number|Long);

                /** ProductSnapshot retailerId. */
                public retailerId: string;

                /** ProductSnapshot url. */
                public url: string;

                /** ProductSnapshot productImageCount. */
                public productImageCount: number;

                /** ProductSnapshot firstImageId. */
                public firstImageId: string;

                /** ProductSnapshot salePriceAmount1000. */
                public salePriceAmount1000: (number|Long);

                /**
                 * Creates a new ProductSnapshot instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns ProductSnapshot instance
                 */
                public static create(properties?: proto.Message.ProductMessage.IProductSnapshot): proto.Message.ProductMessage.ProductSnapshot;

                /**
                 * Encodes the specified ProductSnapshot message. Does not implicitly {@link proto.Message.ProductMessage.ProductSnapshot.verify|verify} messages.
                 * @param message ProductSnapshot message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.ProductMessage.IProductSnapshot, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified ProductSnapshot message, length delimited. Does not implicitly {@link proto.Message.ProductMessage.ProductSnapshot.verify|verify} messages.
                 * @param message ProductSnapshot message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.ProductMessage.IProductSnapshot, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a ProductSnapshot message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns ProductSnapshot
                 * @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): proto.Message.ProductMessage.ProductSnapshot;

                /**
                 * Decodes a ProductSnapshot message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns ProductSnapshot
                 * @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)): proto.Message.ProductMessage.ProductSnapshot;

                /**
                 * Verifies a ProductSnapshot 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 ProductSnapshot message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns ProductSnapshot
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.ProductMessage.ProductSnapshot;

                /**
                 * Creates a plain object from a ProductSnapshot message. Also converts values to other types if specified.
                 * @param message ProductSnapshot
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.ProductMessage.ProductSnapshot, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this ProductSnapshot to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }
        }

        /** Properties of a ProtocolMessage. */
        interface IProtocolMessage {

            /** ProtocolMessage key */
            key?: (proto.IMessageKey|null);

            /** ProtocolMessage type */
            type?: (proto.Message.ProtocolMessage.Type|null);

            /** ProtocolMessage ephemeralExpiration */
            ephemeralExpiration?: (number|null);

            /** ProtocolMessage ephemeralSettingTimestamp */
            ephemeralSettingTimestamp?: (number|Long|null);

            /** ProtocolMessage historySyncNotification */
            historySyncNotification?: (proto.Message.IHistorySyncNotification|null);

            /** ProtocolMessage appStateSyncKeyShare */
            appStateSyncKeyShare?: (proto.Message.IAppStateSyncKeyShare|null);

            /** ProtocolMessage appStateSyncKeyRequest */
            appStateSyncKeyRequest?: (proto.Message.IAppStateSyncKeyRequest|null);

            /** ProtocolMessage initialSecurityNotificationSettingSync */
            initialSecurityNotificationSettingSync?: (proto.Message.IInitialSecurityNotificationSettingSync|null);

            /** ProtocolMessage appStateFatalExceptionNotification */
            appStateFatalExceptionNotification?: (proto.Message.IAppStateFatalExceptionNotification|null);

            /** ProtocolMessage disappearingMode */
            disappearingMode?: (proto.IDisappearingMode|null);

            /** ProtocolMessage editedMessage */
            editedMessage?: (proto.IMessage|null);

            /** ProtocolMessage timestampMs */
            timestampMs?: (number|Long|null);

            /** ProtocolMessage peerDataOperationRequestMessage */
            peerDataOperationRequestMessage?: (proto.Message.IPeerDataOperationRequestMessage|null);

            /** ProtocolMessage peerDataOperationRequestResponseMessage */
            peerDataOperationRequestResponseMessage?: (proto.Message.IPeerDataOperationRequestResponseMessage|null);

            /** ProtocolMessage botFeedbackMessage */
            botFeedbackMessage?: (proto.Message.IBotFeedbackMessage|null);

            /** ProtocolMessage invokerJid */
            invokerJid?: (string|null);

            /** ProtocolMessage requestWelcomeMessageMetadata */
            requestWelcomeMessageMetadata?: (proto.Message.IRequestWelcomeMessageMetadata|null);

            /** ProtocolMessage mediaNotifyMessage */
            mediaNotifyMessage?: (proto.IMediaNotifyMessage|null);
        }

        /** Represents a ProtocolMessage. */
        class ProtocolMessage implements IProtocolMessage {

            /**
             * Constructs a new ProtocolMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IProtocolMessage);

            /** ProtocolMessage key. */
            public key?: (proto.IMessageKey|null);

            /** ProtocolMessage type. */
            public type: proto.Message.ProtocolMessage.Type;

            /** ProtocolMessage ephemeralExpiration. */
            public ephemeralExpiration: number;

            /** ProtocolMessage ephemeralSettingTimestamp. */
            public ephemeralSettingTimestamp: (number|Long);

            /** ProtocolMessage historySyncNotification. */
            public historySyncNotification?: (proto.Message.IHistorySyncNotification|null);

            /** ProtocolMessage appStateSyncKeyShare. */
            public appStateSyncKeyShare?: (proto.Message.IAppStateSyncKeyShare|null);

            /** ProtocolMessage appStateSyncKeyRequest. */
            public appStateSyncKeyRequest?: (proto.Message.IAppStateSyncKeyRequest|null);

            /** ProtocolMessage initialSecurityNotificationSettingSync. */
            public initialSecurityNotificationSettingSync?: (proto.Message.IInitialSecurityNotificationSettingSync|null);

            /** ProtocolMessage appStateFatalExceptionNotification. */
            public appStateFatalExceptionNotification?: (proto.Message.IAppStateFatalExceptionNotification|null);

            /** ProtocolMessage disappearingMode. */
            public disappearingMode?: (proto.IDisappearingMode|null);

            /** ProtocolMessage editedMessage. */
            public editedMessage?: (proto.IMessage|null);

            /** ProtocolMessage timestampMs. */
            public timestampMs: (number|Long);

            /** ProtocolMessage peerDataOperationRequestMessage. */
            public peerDataOperationRequestMessage?: (proto.Message.IPeerDataOperationRequestMessage|null);

            /** ProtocolMessage peerDataOperationRequestResponseMessage. */
            public peerDataOperationRequestResponseMessage?: (proto.Message.IPeerDataOperationRequestResponseMessage|null);

            /** ProtocolMessage botFeedbackMessage. */
            public botFeedbackMessage?: (proto.Message.IBotFeedbackMessage|null);

            /** ProtocolMessage invokerJid. */
            public invokerJid: string;

            /** ProtocolMessage requestWelcomeMessageMetadata. */
            public requestWelcomeMessageMetadata?: (proto.Message.IRequestWelcomeMessageMetadata|null);

            /** ProtocolMessage mediaNotifyMessage. */
            public mediaNotifyMessage?: (proto.IMediaNotifyMessage|null);

            /**
             * Creates a new ProtocolMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ProtocolMessage instance
             */
            public static create(properties?: proto.Message.IProtocolMessage): proto.Message.ProtocolMessage;

            /**
             * Encodes the specified ProtocolMessage message. Does not implicitly {@link proto.Message.ProtocolMessage.verify|verify} messages.
             * @param message ProtocolMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IProtocolMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ProtocolMessage message, length delimited. Does not implicitly {@link proto.Message.ProtocolMessage.verify|verify} messages.
             * @param message ProtocolMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IProtocolMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ProtocolMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ProtocolMessage
             * @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): proto.Message.ProtocolMessage;

            /**
             * Decodes a ProtocolMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ProtocolMessage
             * @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)): proto.Message.ProtocolMessage;

            /**
             * Verifies a ProtocolMessage 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 ProtocolMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ProtocolMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.ProtocolMessage;

            /**
             * Creates a plain object from a ProtocolMessage message. Also converts values to other types if specified.
             * @param message ProtocolMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.ProtocolMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ProtocolMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace ProtocolMessage {

            /** Type enum. */
            enum Type {
                REVOKE = 0,
                EPHEMERAL_SETTING = 3,
                EPHEMERAL_SYNC_RESPONSE = 4,
                HISTORY_SYNC_NOTIFICATION = 5,
                APP_STATE_SYNC_KEY_SHARE = 6,
                APP_STATE_SYNC_KEY_REQUEST = 7,
                MSG_FANOUT_BACKFILL_REQUEST = 8,
                INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC = 9,
                APP_STATE_FATAL_EXCEPTION_NOTIFICATION = 10,
                SHARE_PHONE_NUMBER = 11,
                MESSAGE_EDIT = 14,
                PEER_DATA_OPERATION_REQUEST_MESSAGE = 16,
                PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE = 17,
                REQUEST_WELCOME_MESSAGE = 18,
                BOT_FEEDBACK_MESSAGE = 19,
                MEDIA_NOTIFY_MESSAGE = 20
            }
        }

        /** Properties of a ReactionMessage. */
        interface IReactionMessage {

            /** ReactionMessage key */
            key?: (proto.IMessageKey|null);

            /** ReactionMessage text */
            text?: (string|null);

            /** ReactionMessage groupingKey */
            groupingKey?: (string|null);

            /** ReactionMessage senderTimestampMs */
            senderTimestampMs?: (number|Long|null);
        }

        /** Represents a ReactionMessage. */
        class ReactionMessage implements IReactionMessage {

            /**
             * Constructs a new ReactionMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IReactionMessage);

            /** ReactionMessage key. */
            public key?: (proto.IMessageKey|null);

            /** ReactionMessage text. */
            public text: string;

            /** ReactionMessage groupingKey. */
            public groupingKey: string;

            /** ReactionMessage senderTimestampMs. */
            public senderTimestampMs: (number|Long);

            /**
             * Creates a new ReactionMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ReactionMessage instance
             */
            public static create(properties?: proto.Message.IReactionMessage): proto.Message.ReactionMessage;

            /**
             * Encodes the specified ReactionMessage message. Does not implicitly {@link proto.Message.ReactionMessage.verify|verify} messages.
             * @param message ReactionMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IReactionMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ReactionMessage message, length delimited. Does not implicitly {@link proto.Message.ReactionMessage.verify|verify} messages.
             * @param message ReactionMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IReactionMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ReactionMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ReactionMessage
             * @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): proto.Message.ReactionMessage;

            /**
             * Decodes a ReactionMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ReactionMessage
             * @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)): proto.Message.ReactionMessage;

            /**
             * Verifies a ReactionMessage 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 ReactionMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ReactionMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.ReactionMessage;

            /**
             * Creates a plain object from a ReactionMessage message. Also converts values to other types if specified.
             * @param message ReactionMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.ReactionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ReactionMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a RequestPaymentMessage. */
        interface IRequestPaymentMessage {

            /** RequestPaymentMessage noteMessage */
            noteMessage?: (proto.IMessage|null);

            /** RequestPaymentMessage currencyCodeIso4217 */
            currencyCodeIso4217?: (string|null);

            /** RequestPaymentMessage amount1000 */
            amount1000?: (number|Long|null);

            /** RequestPaymentMessage requestFrom */
            requestFrom?: (string|null);

            /** RequestPaymentMessage expiryTimestamp */
            expiryTimestamp?: (number|Long|null);

            /** RequestPaymentMessage amount */
            amount?: (proto.IMoney|null);

            /** RequestPaymentMessage background */
            background?: (proto.IPaymentBackground|null);
        }

        /** Represents a RequestPaymentMessage. */
        class RequestPaymentMessage implements IRequestPaymentMessage {

            /**
             * Constructs a new RequestPaymentMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IRequestPaymentMessage);

            /** RequestPaymentMessage noteMessage. */
            public noteMessage?: (proto.IMessage|null);

            /** RequestPaymentMessage currencyCodeIso4217. */
            public currencyCodeIso4217: string;

            /** RequestPaymentMessage amount1000. */
            public amount1000: (number|Long);

            /** RequestPaymentMessage requestFrom. */
            public requestFrom: string;

            /** RequestPaymentMessage expiryTimestamp. */
            public expiryTimestamp: (number|Long);

            /** RequestPaymentMessage amount. */
            public amount?: (proto.IMoney|null);

            /** RequestPaymentMessage background. */
            public background?: (proto.IPaymentBackground|null);

            /**
             * Creates a new RequestPaymentMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns RequestPaymentMessage instance
             */
            public static create(properties?: proto.Message.IRequestPaymentMessage): proto.Message.RequestPaymentMessage;

            /**
             * Encodes the specified RequestPaymentMessage message. Does not implicitly {@link proto.Message.RequestPaymentMessage.verify|verify} messages.
             * @param message RequestPaymentMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IRequestPaymentMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified RequestPaymentMessage message, length delimited. Does not implicitly {@link proto.Message.RequestPaymentMessage.verify|verify} messages.
             * @param message RequestPaymentMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IRequestPaymentMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a RequestPaymentMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns RequestPaymentMessage
             * @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): proto.Message.RequestPaymentMessage;

            /**
             * Decodes a RequestPaymentMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns RequestPaymentMessage
             * @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)): proto.Message.RequestPaymentMessage;

            /**
             * Verifies a RequestPaymentMessage 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 RequestPaymentMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns RequestPaymentMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.RequestPaymentMessage;

            /**
             * Creates a plain object from a RequestPaymentMessage message. Also converts values to other types if specified.
             * @param message RequestPaymentMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.RequestPaymentMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this RequestPaymentMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a RequestPhoneNumberMessage. */
        interface IRequestPhoneNumberMessage {

            /** RequestPhoneNumberMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);
        }

        /** Represents a RequestPhoneNumberMessage. */
        class RequestPhoneNumberMessage implements IRequestPhoneNumberMessage {

            /**
             * Constructs a new RequestPhoneNumberMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IRequestPhoneNumberMessage);

            /** RequestPhoneNumberMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /**
             * Creates a new RequestPhoneNumberMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns RequestPhoneNumberMessage instance
             */
            public static create(properties?: proto.Message.IRequestPhoneNumberMessage): proto.Message.RequestPhoneNumberMessage;

            /**
             * Encodes the specified RequestPhoneNumberMessage message. Does not implicitly {@link proto.Message.RequestPhoneNumberMessage.verify|verify} messages.
             * @param message RequestPhoneNumberMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IRequestPhoneNumberMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified RequestPhoneNumberMessage message, length delimited. Does not implicitly {@link proto.Message.RequestPhoneNumberMessage.verify|verify} messages.
             * @param message RequestPhoneNumberMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IRequestPhoneNumberMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a RequestPhoneNumberMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns RequestPhoneNumberMessage
             * @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): proto.Message.RequestPhoneNumberMessage;

            /**
             * Decodes a RequestPhoneNumberMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns RequestPhoneNumberMessage
             * @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)): proto.Message.RequestPhoneNumberMessage;

            /**
             * Verifies a RequestPhoneNumberMessage 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 RequestPhoneNumberMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns RequestPhoneNumberMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.RequestPhoneNumberMessage;

            /**
             * Creates a plain object from a RequestPhoneNumberMessage message. Also converts values to other types if specified.
             * @param message RequestPhoneNumberMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.RequestPhoneNumberMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this RequestPhoneNumberMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a RequestWelcomeMessageMetadata. */
        interface IRequestWelcomeMessageMetadata {

            /** RequestWelcomeMessageMetadata localChatState */
            localChatState?: (proto.Message.RequestWelcomeMessageMetadata.LocalChatState|null);
        }

        /** Represents a RequestWelcomeMessageMetadata. */
        class RequestWelcomeMessageMetadata implements IRequestWelcomeMessageMetadata {

            /**
             * Constructs a new RequestWelcomeMessageMetadata.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IRequestWelcomeMessageMetadata);

            /** RequestWelcomeMessageMetadata localChatState. */
            public localChatState: proto.Message.RequestWelcomeMessageMetadata.LocalChatState;

            /**
             * Creates a new RequestWelcomeMessageMetadata instance using the specified properties.
             * @param [properties] Properties to set
             * @returns RequestWelcomeMessageMetadata instance
             */
            public static create(properties?: proto.Message.IRequestWelcomeMessageMetadata): proto.Message.RequestWelcomeMessageMetadata;

            /**
             * Encodes the specified RequestWelcomeMessageMetadata message. Does not implicitly {@link proto.Message.RequestWelcomeMessageMetadata.verify|verify} messages.
             * @param message RequestWelcomeMessageMetadata message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IRequestWelcomeMessageMetadata, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified RequestWelcomeMessageMetadata message, length delimited. Does not implicitly {@link proto.Message.RequestWelcomeMessageMetadata.verify|verify} messages.
             * @param message RequestWelcomeMessageMetadata message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IRequestWelcomeMessageMetadata, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a RequestWelcomeMessageMetadata message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns RequestWelcomeMessageMetadata
             * @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): proto.Message.RequestWelcomeMessageMetadata;

            /**
             * Decodes a RequestWelcomeMessageMetadata message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns RequestWelcomeMessageMetadata
             * @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)): proto.Message.RequestWelcomeMessageMetadata;

            /**
             * Verifies a RequestWelcomeMessageMetadata 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 RequestWelcomeMessageMetadata message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns RequestWelcomeMessageMetadata
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.RequestWelcomeMessageMetadata;

            /**
             * Creates a plain object from a RequestWelcomeMessageMetadata message. Also converts values to other types if specified.
             * @param message RequestWelcomeMessageMetadata
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.RequestWelcomeMessageMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this RequestWelcomeMessageMetadata to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace RequestWelcomeMessageMetadata {

            /** LocalChatState enum. */
            enum LocalChatState {
                EMPTY = 0,
                NON_EMPTY = 1
            }
        }

        /** Properties of a ScheduledCallCreationMessage. */
        interface IScheduledCallCreationMessage {

            /** ScheduledCallCreationMessage scheduledTimestampMs */
            scheduledTimestampMs?: (number|Long|null);

            /** ScheduledCallCreationMessage callType */
            callType?: (proto.Message.ScheduledCallCreationMessage.CallType|null);

            /** ScheduledCallCreationMessage title */
            title?: (string|null);
        }

        /** Represents a ScheduledCallCreationMessage. */
        class ScheduledCallCreationMessage implements IScheduledCallCreationMessage {

            /**
             * Constructs a new ScheduledCallCreationMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IScheduledCallCreationMessage);

            /** ScheduledCallCreationMessage scheduledTimestampMs. */
            public scheduledTimestampMs: (number|Long);

            /** ScheduledCallCreationMessage callType. */
            public callType: proto.Message.ScheduledCallCreationMessage.CallType;

            /** ScheduledCallCreationMessage title. */
            public title: string;

            /**
             * Creates a new ScheduledCallCreationMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ScheduledCallCreationMessage instance
             */
            public static create(properties?: proto.Message.IScheduledCallCreationMessage): proto.Message.ScheduledCallCreationMessage;

            /**
             * Encodes the specified ScheduledCallCreationMessage message. Does not implicitly {@link proto.Message.ScheduledCallCreationMessage.verify|verify} messages.
             * @param message ScheduledCallCreationMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IScheduledCallCreationMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ScheduledCallCreationMessage message, length delimited. Does not implicitly {@link proto.Message.ScheduledCallCreationMessage.verify|verify} messages.
             * @param message ScheduledCallCreationMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IScheduledCallCreationMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ScheduledCallCreationMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ScheduledCallCreationMessage
             * @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): proto.Message.ScheduledCallCreationMessage;

            /**
             * Decodes a ScheduledCallCreationMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ScheduledCallCreationMessage
             * @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)): proto.Message.ScheduledCallCreationMessage;

            /**
             * Verifies a ScheduledCallCreationMessage 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 ScheduledCallCreationMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ScheduledCallCreationMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.ScheduledCallCreationMessage;

            /**
             * Creates a plain object from a ScheduledCallCreationMessage message. Also converts values to other types if specified.
             * @param message ScheduledCallCreationMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.ScheduledCallCreationMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ScheduledCallCreationMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace ScheduledCallCreationMessage {

            /** CallType enum. */
            enum CallType {
                UNKNOWN = 0,
                VOICE = 1,
                VIDEO = 2
            }
        }

        /** Properties of a ScheduledCallEditMessage. */
        interface IScheduledCallEditMessage {

            /** ScheduledCallEditMessage key */
            key?: (proto.IMessageKey|null);

            /** ScheduledCallEditMessage editType */
            editType?: (proto.Message.ScheduledCallEditMessage.EditType|null);
        }

        /** Represents a ScheduledCallEditMessage. */
        class ScheduledCallEditMessage implements IScheduledCallEditMessage {

            /**
             * Constructs a new ScheduledCallEditMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IScheduledCallEditMessage);

            /** ScheduledCallEditMessage key. */
            public key?: (proto.IMessageKey|null);

            /** ScheduledCallEditMessage editType. */
            public editType: proto.Message.ScheduledCallEditMessage.EditType;

            /**
             * Creates a new ScheduledCallEditMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ScheduledCallEditMessage instance
             */
            public static create(properties?: proto.Message.IScheduledCallEditMessage): proto.Message.ScheduledCallEditMessage;

            /**
             * Encodes the specified ScheduledCallEditMessage message. Does not implicitly {@link proto.Message.ScheduledCallEditMessage.verify|verify} messages.
             * @param message ScheduledCallEditMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IScheduledCallEditMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ScheduledCallEditMessage message, length delimited. Does not implicitly {@link proto.Message.ScheduledCallEditMessage.verify|verify} messages.
             * @param message ScheduledCallEditMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IScheduledCallEditMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ScheduledCallEditMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ScheduledCallEditMessage
             * @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): proto.Message.ScheduledCallEditMessage;

            /**
             * Decodes a ScheduledCallEditMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ScheduledCallEditMessage
             * @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)): proto.Message.ScheduledCallEditMessage;

            /**
             * Verifies a ScheduledCallEditMessage 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 ScheduledCallEditMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ScheduledCallEditMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.ScheduledCallEditMessage;

            /**
             * Creates a plain object from a ScheduledCallEditMessage message. Also converts values to other types if specified.
             * @param message ScheduledCallEditMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.ScheduledCallEditMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ScheduledCallEditMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace ScheduledCallEditMessage {

            /** EditType enum. */
            enum EditType {
                UNKNOWN = 0,
                CANCEL = 1
            }
        }

        /** Properties of a SendPaymentMessage. */
        interface ISendPaymentMessage {

            /** SendPaymentMessage noteMessage */
            noteMessage?: (proto.IMessage|null);

            /** SendPaymentMessage requestMessageKey */
            requestMessageKey?: (proto.IMessageKey|null);

            /** SendPaymentMessage background */
            background?: (proto.IPaymentBackground|null);
        }

        /** Represents a SendPaymentMessage. */
        class SendPaymentMessage implements ISendPaymentMessage {

            /**
             * Constructs a new SendPaymentMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.ISendPaymentMessage);

            /** SendPaymentMessage noteMessage. */
            public noteMessage?: (proto.IMessage|null);

            /** SendPaymentMessage requestMessageKey. */
            public requestMessageKey?: (proto.IMessageKey|null);

            /** SendPaymentMessage background. */
            public background?: (proto.IPaymentBackground|null);

            /**
             * Creates a new SendPaymentMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns SendPaymentMessage instance
             */
            public static create(properties?: proto.Message.ISendPaymentMessage): proto.Message.SendPaymentMessage;

            /**
             * Encodes the specified SendPaymentMessage message. Does not implicitly {@link proto.Message.SendPaymentMessage.verify|verify} messages.
             * @param message SendPaymentMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.ISendPaymentMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified SendPaymentMessage message, length delimited. Does not implicitly {@link proto.Message.SendPaymentMessage.verify|verify} messages.
             * @param message SendPaymentMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.ISendPaymentMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a SendPaymentMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns SendPaymentMessage
             * @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): proto.Message.SendPaymentMessage;

            /**
             * Decodes a SendPaymentMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns SendPaymentMessage
             * @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)): proto.Message.SendPaymentMessage;

            /**
             * Verifies a SendPaymentMessage 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 SendPaymentMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns SendPaymentMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.SendPaymentMessage;

            /**
             * Creates a plain object from a SendPaymentMessage message. Also converts values to other types if specified.
             * @param message SendPaymentMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.SendPaymentMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this SendPaymentMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a SenderKeyDistributionMessage. */
        interface ISenderKeyDistributionMessage {

            /** SenderKeyDistributionMessage groupId */
            groupId?: (string|null);

            /** SenderKeyDistributionMessage axolotlSenderKeyDistributionMessage */
            axolotlSenderKeyDistributionMessage?: (Uint8Array|null);
        }

        /** Represents a SenderKeyDistributionMessage. */
        class SenderKeyDistributionMessage implements ISenderKeyDistributionMessage {

            /**
             * Constructs a new SenderKeyDistributionMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.ISenderKeyDistributionMessage);

            /** SenderKeyDistributionMessage groupId. */
            public groupId: string;

            /** SenderKeyDistributionMessage axolotlSenderKeyDistributionMessage. */
            public axolotlSenderKeyDistributionMessage: Uint8Array;

            /**
             * Creates a new SenderKeyDistributionMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns SenderKeyDistributionMessage instance
             */
            public static create(properties?: proto.Message.ISenderKeyDistributionMessage): proto.Message.SenderKeyDistributionMessage;

            /**
             * Encodes the specified SenderKeyDistributionMessage message. Does not implicitly {@link proto.Message.SenderKeyDistributionMessage.verify|verify} messages.
             * @param message SenderKeyDistributionMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.ISenderKeyDistributionMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified SenderKeyDistributionMessage message, length delimited. Does not implicitly {@link proto.Message.SenderKeyDistributionMessage.verify|verify} messages.
             * @param message SenderKeyDistributionMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.ISenderKeyDistributionMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a SenderKeyDistributionMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns SenderKeyDistributionMessage
             * @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): proto.Message.SenderKeyDistributionMessage;

            /**
             * Decodes a SenderKeyDistributionMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns SenderKeyDistributionMessage
             * @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)): proto.Message.SenderKeyDistributionMessage;

            /**
             * Verifies a SenderKeyDistributionMessage 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 SenderKeyDistributionMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns SenderKeyDistributionMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.SenderKeyDistributionMessage;

            /**
             * Creates a plain object from a SenderKeyDistributionMessage message. Also converts values to other types if specified.
             * @param message SenderKeyDistributionMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.SenderKeyDistributionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this SenderKeyDistributionMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a StickerMessage. */
        interface IStickerMessage {

            /** StickerMessage url */
            url?: (string|null);

            /** StickerMessage fileSha256 */
            fileSha256?: (Uint8Array|null);

            /** StickerMessage fileEncSha256 */
            fileEncSha256?: (Uint8Array|null);

            /** StickerMessage mediaKey */
            mediaKey?: (Uint8Array|null);

            /** StickerMessage mimetype */
            mimetype?: (string|null);

            /** StickerMessage height */
            height?: (number|null);

            /** StickerMessage width */
            width?: (number|null);

            /** StickerMessage directPath */
            directPath?: (string|null);

            /** StickerMessage fileLength */
            fileLength?: (number|Long|null);

            /** StickerMessage mediaKeyTimestamp */
            mediaKeyTimestamp?: (number|Long|null);

            /** StickerMessage firstFrameLength */
            firstFrameLength?: (number|null);

            /** StickerMessage firstFrameSidecar */
            firstFrameSidecar?: (Uint8Array|null);

            /** StickerMessage isAnimated */
            isAnimated?: (boolean|null);

            /** StickerMessage pngThumbnail */
            pngThumbnail?: (Uint8Array|null);

            /** StickerMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** StickerMessage stickerSentTs */
            stickerSentTs?: (number|Long|null);

            /** StickerMessage isAvatar */
            isAvatar?: (boolean|null);

            /** StickerMessage isAiSticker */
            isAiSticker?: (boolean|null);

            /** StickerMessage isLottie */
            isLottie?: (boolean|null);
        }

        /** Represents a StickerMessage. */
        class StickerMessage implements IStickerMessage {

            /**
             * Constructs a new StickerMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IStickerMessage);

            /** StickerMessage url. */
            public url: string;

            /** StickerMessage fileSha256. */
            public fileSha256: Uint8Array;

            /** StickerMessage fileEncSha256. */
            public fileEncSha256: Uint8Array;

            /** StickerMessage mediaKey. */
            public mediaKey: Uint8Array;

            /** StickerMessage mimetype. */
            public mimetype: string;

            /** StickerMessage height. */
            public height: number;

            /** StickerMessage width. */
            public width: number;

            /** StickerMessage directPath. */
            public directPath: string;

            /** StickerMessage fileLength. */
            public fileLength: (number|Long);

            /** StickerMessage mediaKeyTimestamp. */
            public mediaKeyTimestamp: (number|Long);

            /** StickerMessage firstFrameLength. */
            public firstFrameLength: number;

            /** StickerMessage firstFrameSidecar. */
            public firstFrameSidecar: Uint8Array;

            /** StickerMessage isAnimated. */
            public isAnimated: boolean;

            /** StickerMessage pngThumbnail. */
            public pngThumbnail: Uint8Array;

            /** StickerMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** StickerMessage stickerSentTs. */
            public stickerSentTs: (number|Long);

            /** StickerMessage isAvatar. */
            public isAvatar: boolean;

            /** StickerMessage isAiSticker. */
            public isAiSticker: boolean;

            /** StickerMessage isLottie. */
            public isLottie: boolean;

            /**
             * Creates a new StickerMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns StickerMessage instance
             */
            public static create(properties?: proto.Message.IStickerMessage): proto.Message.StickerMessage;

            /**
             * Encodes the specified StickerMessage message. Does not implicitly {@link proto.Message.StickerMessage.verify|verify} messages.
             * @param message StickerMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IStickerMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified StickerMessage message, length delimited. Does not implicitly {@link proto.Message.StickerMessage.verify|verify} messages.
             * @param message StickerMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IStickerMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a StickerMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns StickerMessage
             * @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): proto.Message.StickerMessage;

            /**
             * Decodes a StickerMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns StickerMessage
             * @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)): proto.Message.StickerMessage;

            /**
             * Verifies a StickerMessage 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 StickerMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns StickerMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.StickerMessage;

            /**
             * Creates a plain object from a StickerMessage message. Also converts values to other types if specified.
             * @param message StickerMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.StickerMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this StickerMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a StickerSyncRMRMessage. */
        interface IStickerSyncRMRMessage {

            /** StickerSyncRMRMessage filehash */
            filehash?: (string[]|null);

            /** StickerSyncRMRMessage rmrSource */
            rmrSource?: (string|null);

            /** StickerSyncRMRMessage requestTimestamp */
            requestTimestamp?: (number|Long|null);
        }

        /** Represents a StickerSyncRMRMessage. */
        class StickerSyncRMRMessage implements IStickerSyncRMRMessage {

            /**
             * Constructs a new StickerSyncRMRMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IStickerSyncRMRMessage);

            /** StickerSyncRMRMessage filehash. */
            public filehash: string[];

            /** StickerSyncRMRMessage rmrSource. */
            public rmrSource: string;

            /** StickerSyncRMRMessage requestTimestamp. */
            public requestTimestamp: (number|Long);

            /**
             * Creates a new StickerSyncRMRMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns StickerSyncRMRMessage instance
             */
            public static create(properties?: proto.Message.IStickerSyncRMRMessage): proto.Message.StickerSyncRMRMessage;

            /**
             * Encodes the specified StickerSyncRMRMessage message. Does not implicitly {@link proto.Message.StickerSyncRMRMessage.verify|verify} messages.
             * @param message StickerSyncRMRMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IStickerSyncRMRMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified StickerSyncRMRMessage message, length delimited. Does not implicitly {@link proto.Message.StickerSyncRMRMessage.verify|verify} messages.
             * @param message StickerSyncRMRMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IStickerSyncRMRMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a StickerSyncRMRMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns StickerSyncRMRMessage
             * @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): proto.Message.StickerSyncRMRMessage;

            /**
             * Decodes a StickerSyncRMRMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns StickerSyncRMRMessage
             * @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)): proto.Message.StickerSyncRMRMessage;

            /**
             * Verifies a StickerSyncRMRMessage 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 StickerSyncRMRMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns StickerSyncRMRMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.StickerSyncRMRMessage;

            /**
             * Creates a plain object from a StickerSyncRMRMessage message. Also converts values to other types if specified.
             * @param message StickerSyncRMRMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.StickerSyncRMRMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this StickerSyncRMRMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a TemplateButtonReplyMessage. */
        interface ITemplateButtonReplyMessage {

            /** TemplateButtonReplyMessage selectedId */
            selectedId?: (string|null);

            /** TemplateButtonReplyMessage selectedDisplayText */
            selectedDisplayText?: (string|null);

            /** TemplateButtonReplyMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** TemplateButtonReplyMessage selectedIndex */
            selectedIndex?: (number|null);

            /** TemplateButtonReplyMessage selectedCarouselCardIndex */
            selectedCarouselCardIndex?: (number|null);
        }

        /** Represents a TemplateButtonReplyMessage. */
        class TemplateButtonReplyMessage implements ITemplateButtonReplyMessage {

            /**
             * Constructs a new TemplateButtonReplyMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.ITemplateButtonReplyMessage);

            /** TemplateButtonReplyMessage selectedId. */
            public selectedId: string;

            /** TemplateButtonReplyMessage selectedDisplayText. */
            public selectedDisplayText: string;

            /** TemplateButtonReplyMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** TemplateButtonReplyMessage selectedIndex. */
            public selectedIndex: number;

            /** TemplateButtonReplyMessage selectedCarouselCardIndex. */
            public selectedCarouselCardIndex: number;

            /**
             * Creates a new TemplateButtonReplyMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns TemplateButtonReplyMessage instance
             */
            public static create(properties?: proto.Message.ITemplateButtonReplyMessage): proto.Message.TemplateButtonReplyMessage;

            /**
             * Encodes the specified TemplateButtonReplyMessage message. Does not implicitly {@link proto.Message.TemplateButtonReplyMessage.verify|verify} messages.
             * @param message TemplateButtonReplyMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.ITemplateButtonReplyMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified TemplateButtonReplyMessage message, length delimited. Does not implicitly {@link proto.Message.TemplateButtonReplyMessage.verify|verify} messages.
             * @param message TemplateButtonReplyMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.ITemplateButtonReplyMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a TemplateButtonReplyMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns TemplateButtonReplyMessage
             * @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): proto.Message.TemplateButtonReplyMessage;

            /**
             * Decodes a TemplateButtonReplyMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns TemplateButtonReplyMessage
             * @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)): proto.Message.TemplateButtonReplyMessage;

            /**
             * Verifies a TemplateButtonReplyMessage 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 TemplateButtonReplyMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns TemplateButtonReplyMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.TemplateButtonReplyMessage;

            /**
             * Creates a plain object from a TemplateButtonReplyMessage message. Also converts values to other types if specified.
             * @param message TemplateButtonReplyMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.TemplateButtonReplyMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this TemplateButtonReplyMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a TemplateMessage. */
        interface ITemplateMessage {

            /** TemplateMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** TemplateMessage hydratedTemplate */
            hydratedTemplate?: (proto.Message.TemplateMessage.IHydratedFourRowTemplate|null);

            /** TemplateMessage templateId */
            templateId?: (string|null);

            /** TemplateMessage fourRowTemplate */
            fourRowTemplate?: (proto.Message.TemplateMessage.IFourRowTemplate|null);

            /** TemplateMessage hydratedFourRowTemplate */
            hydratedFourRowTemplate?: (proto.Message.TemplateMessage.IHydratedFourRowTemplate|null);

            /** TemplateMessage interactiveMessageTemplate */
            interactiveMessageTemplate?: (proto.Message.IInteractiveMessage|null);
        }

        /** Represents a TemplateMessage. */
        class TemplateMessage implements ITemplateMessage {

            /**
             * Constructs a new TemplateMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.ITemplateMessage);

            /** TemplateMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** TemplateMessage hydratedTemplate. */
            public hydratedTemplate?: (proto.Message.TemplateMessage.IHydratedFourRowTemplate|null);

            /** TemplateMessage templateId. */
            public templateId: string;

            /** TemplateMessage fourRowTemplate. */
            public fourRowTemplate?: (proto.Message.TemplateMessage.IFourRowTemplate|null);

            /** TemplateMessage hydratedFourRowTemplate. */
            public hydratedFourRowTemplate?: (proto.Message.TemplateMessage.IHydratedFourRowTemplate|null);

            /** TemplateMessage interactiveMessageTemplate. */
            public interactiveMessageTemplate?: (proto.Message.IInteractiveMessage|null);

            /** TemplateMessage format. */
            public format?: ("fourRowTemplate"|"hydratedFourRowTemplate"|"interactiveMessageTemplate");

            /**
             * Creates a new TemplateMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns TemplateMessage instance
             */
            public static create(properties?: proto.Message.ITemplateMessage): proto.Message.TemplateMessage;

            /**
             * Encodes the specified TemplateMessage message. Does not implicitly {@link proto.Message.TemplateMessage.verify|verify} messages.
             * @param message TemplateMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.ITemplateMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified TemplateMessage message, length delimited. Does not implicitly {@link proto.Message.TemplateMessage.verify|verify} messages.
             * @param message TemplateMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.ITemplateMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a TemplateMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns TemplateMessage
             * @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): proto.Message.TemplateMessage;

            /**
             * Decodes a TemplateMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns TemplateMessage
             * @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)): proto.Message.TemplateMessage;

            /**
             * Verifies a TemplateMessage 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 TemplateMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns TemplateMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.TemplateMessage;

            /**
             * Creates a plain object from a TemplateMessage message. Also converts values to other types if specified.
             * @param message TemplateMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.TemplateMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this TemplateMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace TemplateMessage {

            /** Properties of a FourRowTemplate. */
            interface IFourRowTemplate {

                /** FourRowTemplate content */
                content?: (proto.Message.IHighlyStructuredMessage|null);

                /** FourRowTemplate footer */
                footer?: (proto.Message.IHighlyStructuredMessage|null);

                /** FourRowTemplate buttons */
                buttons?: (proto.ITemplateButton[]|null);

                /** FourRowTemplate documentMessage */
                documentMessage?: (proto.Message.IDocumentMessage|null);

                /** FourRowTemplate highlyStructuredMessage */
                highlyStructuredMessage?: (proto.Message.IHighlyStructuredMessage|null);

                /** FourRowTemplate imageMessage */
                imageMessage?: (proto.Message.IImageMessage|null);

                /** FourRowTemplate videoMessage */
                videoMessage?: (proto.Message.IVideoMessage|null);

                /** FourRowTemplate locationMessage */
                locationMessage?: (proto.Message.ILocationMessage|null);
            }

            /** Represents a FourRowTemplate. */
            class FourRowTemplate implements IFourRowTemplate {

                /**
                 * Constructs a new FourRowTemplate.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.TemplateMessage.IFourRowTemplate);

                /** FourRowTemplate content. */
                public content?: (proto.Message.IHighlyStructuredMessage|null);

                /** FourRowTemplate footer. */
                public footer?: (proto.Message.IHighlyStructuredMessage|null);

                /** FourRowTemplate buttons. */
                public buttons: proto.ITemplateButton[];

                /** FourRowTemplate documentMessage. */
                public documentMessage?: (proto.Message.IDocumentMessage|null);

                /** FourRowTemplate highlyStructuredMessage. */
                public highlyStructuredMessage?: (proto.Message.IHighlyStructuredMessage|null);

                /** FourRowTemplate imageMessage. */
                public imageMessage?: (proto.Message.IImageMessage|null);

                /** FourRowTemplate videoMessage. */
                public videoMessage?: (proto.Message.IVideoMessage|null);

                /** FourRowTemplate locationMessage. */
                public locationMessage?: (proto.Message.ILocationMessage|null);

                /** FourRowTemplate title. */
                public title?: ("documentMessage"|"highlyStructuredMessage"|"imageMessage"|"videoMessage"|"locationMessage");

                /**
                 * Creates a new FourRowTemplate instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns FourRowTemplate instance
                 */
                public static create(properties?: proto.Message.TemplateMessage.IFourRowTemplate): proto.Message.TemplateMessage.FourRowTemplate;

                /**
                 * Encodes the specified FourRowTemplate message. Does not implicitly {@link proto.Message.TemplateMessage.FourRowTemplate.verify|verify} messages.
                 * @param message FourRowTemplate message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.TemplateMessage.IFourRowTemplate, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified FourRowTemplate message, length delimited. Does not implicitly {@link proto.Message.TemplateMessage.FourRowTemplate.verify|verify} messages.
                 * @param message FourRowTemplate message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.TemplateMessage.IFourRowTemplate, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a FourRowTemplate message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns FourRowTemplate
                 * @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): proto.Message.TemplateMessage.FourRowTemplate;

                /**
                 * Decodes a FourRowTemplate message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns FourRowTemplate
                 * @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)): proto.Message.TemplateMessage.FourRowTemplate;

                /**
                 * Verifies a FourRowTemplate 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 FourRowTemplate message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns FourRowTemplate
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.TemplateMessage.FourRowTemplate;

                /**
                 * Creates a plain object from a FourRowTemplate message. Also converts values to other types if specified.
                 * @param message FourRowTemplate
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.TemplateMessage.FourRowTemplate, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this FourRowTemplate to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a HydratedFourRowTemplate. */
            interface IHydratedFourRowTemplate {

                /** HydratedFourRowTemplate hydratedContentText */
                hydratedContentText?: (string|null);

                /** HydratedFourRowTemplate hydratedFooterText */
                hydratedFooterText?: (string|null);

                /** HydratedFourRowTemplate hydratedButtons */
                hydratedButtons?: (proto.IHydratedTemplateButton[]|null);

                /** HydratedFourRowTemplate templateId */
                templateId?: (string|null);

                /** HydratedFourRowTemplate maskLinkedDevices */
                maskLinkedDevices?: (boolean|null);

                /** HydratedFourRowTemplate documentMessage */
                documentMessage?: (proto.Message.IDocumentMessage|null);

                /** HydratedFourRowTemplate hydratedTitleText */
                hydratedTitleText?: (string|null);

                /** HydratedFourRowTemplate imageMessage */
                imageMessage?: (proto.Message.IImageMessage|null);

                /** HydratedFourRowTemplate videoMessage */
                videoMessage?: (proto.Message.IVideoMessage|null);

                /** HydratedFourRowTemplate locationMessage */
                locationMessage?: (proto.Message.ILocationMessage|null);
            }

            /** Represents a HydratedFourRowTemplate. */
            class HydratedFourRowTemplate implements IHydratedFourRowTemplate {

                /**
                 * Constructs a new HydratedFourRowTemplate.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.Message.TemplateMessage.IHydratedFourRowTemplate);

                /** HydratedFourRowTemplate hydratedContentText. */
                public hydratedContentText: string;

                /** HydratedFourRowTemplate hydratedFooterText. */
                public hydratedFooterText: string;

                /** HydratedFourRowTemplate hydratedButtons. */
                public hydratedButtons: proto.IHydratedTemplateButton[];

                /** HydratedFourRowTemplate templateId. */
                public templateId: string;

                /** HydratedFourRowTemplate maskLinkedDevices. */
                public maskLinkedDevices: boolean;

                /** HydratedFourRowTemplate documentMessage. */
                public documentMessage?: (proto.Message.IDocumentMessage|null);

                /** HydratedFourRowTemplate hydratedTitleText. */
                public hydratedTitleText?: (string|null);

                /** HydratedFourRowTemplate imageMessage. */
                public imageMessage?: (proto.Message.IImageMessage|null);

                /** HydratedFourRowTemplate videoMessage. */
                public videoMessage?: (proto.Message.IVideoMessage|null);

                /** HydratedFourRowTemplate locationMessage. */
                public locationMessage?: (proto.Message.ILocationMessage|null);

                /** HydratedFourRowTemplate title. */
                public title?: ("documentMessage"|"hydratedTitleText"|"imageMessage"|"videoMessage"|"locationMessage");

                /**
                 * Creates a new HydratedFourRowTemplate instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns HydratedFourRowTemplate instance
                 */
                public static create(properties?: proto.Message.TemplateMessage.IHydratedFourRowTemplate): proto.Message.TemplateMessage.HydratedFourRowTemplate;

                /**
                 * Encodes the specified HydratedFourRowTemplate message. Does not implicitly {@link proto.Message.TemplateMessage.HydratedFourRowTemplate.verify|verify} messages.
                 * @param message HydratedFourRowTemplate message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.Message.TemplateMessage.IHydratedFourRowTemplate, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified HydratedFourRowTemplate message, length delimited. Does not implicitly {@link proto.Message.TemplateMessage.HydratedFourRowTemplate.verify|verify} messages.
                 * @param message HydratedFourRowTemplate message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.Message.TemplateMessage.IHydratedFourRowTemplate, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a HydratedFourRowTemplate message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns HydratedFourRowTemplate
                 * @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): proto.Message.TemplateMessage.HydratedFourRowTemplate;

                /**
                 * Decodes a HydratedFourRowTemplate message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns HydratedFourRowTemplate
                 * @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)): proto.Message.TemplateMessage.HydratedFourRowTemplate;

                /**
                 * Verifies a HydratedFourRowTemplate 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 HydratedFourRowTemplate message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns HydratedFourRowTemplate
                 */
                public static fromObject(object: { [k: string]: any }): proto.Message.TemplateMessage.HydratedFourRowTemplate;

                /**
                 * Creates a plain object from a HydratedFourRowTemplate message. Also converts values to other types if specified.
                 * @param message HydratedFourRowTemplate
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.Message.TemplateMessage.HydratedFourRowTemplate, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this HydratedFourRowTemplate to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }
        }

        /** Properties of a VideoMessage. */
        interface IVideoMessage {

            /** VideoMessage url */
            url?: (string|null);

            /** VideoMessage mimetype */
            mimetype?: (string|null);

            /** VideoMessage fileSha256 */
            fileSha256?: (Uint8Array|null);

            /** VideoMessage fileLength */
            fileLength?: (number|Long|null);

            /** VideoMessage seconds */
            seconds?: (number|null);

            /** VideoMessage mediaKey */
            mediaKey?: (Uint8Array|null);

            /** VideoMessage caption */
            caption?: (string|null);

            /** VideoMessage gifPlayback */
            gifPlayback?: (boolean|null);

            /** VideoMessage height */
            height?: (number|null);

            /** VideoMessage width */
            width?: (number|null);

            /** VideoMessage fileEncSha256 */
            fileEncSha256?: (Uint8Array|null);

            /** VideoMessage interactiveAnnotations */
            interactiveAnnotations?: (proto.IInteractiveAnnotation[]|null);

            /** VideoMessage directPath */
            directPath?: (string|null);

            /** VideoMessage mediaKeyTimestamp */
            mediaKeyTimestamp?: (number|Long|null);

            /** VideoMessage jpegThumbnail */
            jpegThumbnail?: (Uint8Array|null);

            /** VideoMessage contextInfo */
            contextInfo?: (proto.IContextInfo|null);

            /** VideoMessage streamingSidecar */
            streamingSidecar?: (Uint8Array|null);

            /** VideoMessage gifAttribution */
            gifAttribution?: (proto.Message.VideoMessage.Attribution|null);

            /** VideoMessage viewOnce */
            viewOnce?: (boolean|null);

            /** VideoMessage thumbnailDirectPath */
            thumbnailDirectPath?: (string|null);

            /** VideoMessage thumbnailSha256 */
            thumbnailSha256?: (Uint8Array|null);

            /** VideoMessage thumbnailEncSha256 */
            thumbnailEncSha256?: (Uint8Array|null);

            /** VideoMessage staticUrl */
            staticUrl?: (string|null);

            /** VideoMessage annotations */
            annotations?: (proto.IInteractiveAnnotation[]|null);
        }

        /** Represents a VideoMessage. */
        class VideoMessage implements IVideoMessage {

            /**
             * Constructs a new VideoMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.Message.IVideoMessage);

            /** VideoMessage url. */
            public url: string;

            /** VideoMessage mimetype. */
            public mimetype: string;

            /** VideoMessage fileSha256. */
            public fileSha256: Uint8Array;

            /** VideoMessage fileLength. */
            public fileLength: (number|Long);

            /** VideoMessage seconds. */
            public seconds: number;

            /** VideoMessage mediaKey. */
            public mediaKey: Uint8Array;

            /** VideoMessage caption. */
            public caption: string;

            /** VideoMessage gifPlayback. */
            public gifPlayback: boolean;

            /** VideoMessage height. */
            public height: number;

            /** VideoMessage width. */
            public width: number;

            /** VideoMessage fileEncSha256. */
            public fileEncSha256: Uint8Array;

            /** VideoMessage interactiveAnnotations. */
            public interactiveAnnotations: proto.IInteractiveAnnotation[];

            /** VideoMessage directPath. */
            public directPath: string;

            /** VideoMessage mediaKeyTimestamp. */
            public mediaKeyTimestamp: (number|Long);

            /** VideoMessage jpegThumbnail. */
            public jpegThumbnail: Uint8Array;

            /** VideoMessage contextInfo. */
            public contextInfo?: (proto.IContextInfo|null);

            /** VideoMessage streamingSidecar. */
            public streamingSidecar: Uint8Array;

            /** VideoMessage gifAttribution. */
            public gifAttribution: proto.Message.VideoMessage.Attribution;

            /** VideoMessage viewOnce. */
            public viewOnce: boolean;

            /** VideoMessage thumbnailDirectPath. */
            public thumbnailDirectPath: string;

            /** VideoMessage thumbnailSha256. */
            public thumbnailSha256: Uint8Array;

            /** VideoMessage thumbnailEncSha256. */
            public thumbnailEncSha256: Uint8Array;

            /** VideoMessage staticUrl. */
            public staticUrl: string;

            /** VideoMessage annotations. */
            public annotations: proto.IInteractiveAnnotation[];

            /**
             * Creates a new VideoMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns VideoMessage instance
             */
            public static create(properties?: proto.Message.IVideoMessage): proto.Message.VideoMessage;

            /**
             * Encodes the specified VideoMessage message. Does not implicitly {@link proto.Message.VideoMessage.verify|verify} messages.
             * @param message VideoMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.Message.IVideoMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified VideoMessage message, length delimited. Does not implicitly {@link proto.Message.VideoMessage.verify|verify} messages.
             * @param message VideoMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.Message.IVideoMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a VideoMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns VideoMessage
             * @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): proto.Message.VideoMessage;

            /**
             * Decodes a VideoMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns VideoMessage
             * @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)): proto.Message.VideoMessage;

            /**
             * Verifies a VideoMessage 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 VideoMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns VideoMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.Message.VideoMessage;

            /**
             * Creates a plain object from a VideoMessage message. Also converts values to other types if specified.
             * @param message VideoMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.Message.VideoMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this VideoMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace VideoMessage {

            /** Attribution enum. */
            enum Attribution {
                NONE = 0,
                GIPHY = 1,
                TENOR = 2
            }
        }
    }

    /** Properties of a MessageAddOnContextInfo. */
    interface IMessageAddOnContextInfo {

        /** MessageAddOnContextInfo messageAddOnDurationInSecs */
        messageAddOnDurationInSecs?: (number|null);
    }

    /** Represents a MessageAddOnContextInfo. */
    class MessageAddOnContextInfo implements IMessageAddOnContextInfo {

        /**
         * Constructs a new MessageAddOnContextInfo.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IMessageAddOnContextInfo);

        /** MessageAddOnContextInfo messageAddOnDurationInSecs. */
        public messageAddOnDurationInSecs: number;

        /**
         * Creates a new MessageAddOnContextInfo instance using the specified properties.
         * @param [properties] Properties to set
         * @returns MessageAddOnContextInfo instance
         */
        public static create(properties?: proto.IMessageAddOnContextInfo): proto.MessageAddOnContextInfo;

        /**
         * Encodes the specified MessageAddOnContextInfo message. Does not implicitly {@link proto.MessageAddOnContextInfo.verify|verify} messages.
         * @param message MessageAddOnContextInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IMessageAddOnContextInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified MessageAddOnContextInfo message, length delimited. Does not implicitly {@link proto.MessageAddOnContextInfo.verify|verify} messages.
         * @param message MessageAddOnContextInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IMessageAddOnContextInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a MessageAddOnContextInfo message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns MessageAddOnContextInfo
         * @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): proto.MessageAddOnContextInfo;

        /**
         * Decodes a MessageAddOnContextInfo message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns MessageAddOnContextInfo
         * @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)): proto.MessageAddOnContextInfo;

        /**
         * Verifies a MessageAddOnContextInfo 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 MessageAddOnContextInfo message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns MessageAddOnContextInfo
         */
        public static fromObject(object: { [k: string]: any }): proto.MessageAddOnContextInfo;

        /**
         * Creates a plain object from a MessageAddOnContextInfo message. Also converts values to other types if specified.
         * @param message MessageAddOnContextInfo
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.MessageAddOnContextInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this MessageAddOnContextInfo to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a MessageContextInfo. */
    interface IMessageContextInfo {

        /** MessageContextInfo deviceListMetadata */
        deviceListMetadata?: (proto.IDeviceListMetadata|null);

        /** MessageContextInfo deviceListMetadataVersion */
        deviceListMetadataVersion?: (number|null);

        /** MessageContextInfo messageSecret */
        messageSecret?: (Uint8Array|null);

        /** MessageContextInfo paddingBytes */
        paddingBytes?: (Uint8Array|null);

        /** MessageContextInfo messageAddOnDurationInSecs */
        messageAddOnDurationInSecs?: (number|null);

        /** MessageContextInfo botMessageSecret */
        botMessageSecret?: (Uint8Array|null);

        /** MessageContextInfo botMetadata */
        botMetadata?: (proto.IBotMetadata|null);

        /** MessageContextInfo reportingTokenVersion */
        reportingTokenVersion?: (number|null);
    }

    /** Represents a MessageContextInfo. */
    class MessageContextInfo implements IMessageContextInfo {

        /**
         * Constructs a new MessageContextInfo.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IMessageContextInfo);

        /** MessageContextInfo deviceListMetadata. */
        public deviceListMetadata?: (proto.IDeviceListMetadata|null);

        /** MessageContextInfo deviceListMetadataVersion. */
        public deviceListMetadataVersion: number;

        /** MessageContextInfo messageSecret. */
        public messageSecret: Uint8Array;

        /** MessageContextInfo paddingBytes. */
        public paddingBytes: Uint8Array;

        /** MessageContextInfo messageAddOnDurationInSecs. */
        public messageAddOnDurationInSecs: number;

        /** MessageContextInfo botMessageSecret. */
        public botMessageSecret: Uint8Array;

        /** MessageContextInfo botMetadata. */
        public botMetadata?: (proto.IBotMetadata|null);

        /** MessageContextInfo reportingTokenVersion. */
        public reportingTokenVersion: number;

        /**
         * Creates a new MessageContextInfo instance using the specified properties.
         * @param [properties] Properties to set
         * @returns MessageContextInfo instance
         */
        public static create(properties?: proto.IMessageContextInfo): proto.MessageContextInfo;

        /**
         * Encodes the specified MessageContextInfo message. Does not implicitly {@link proto.MessageContextInfo.verify|verify} messages.
         * @param message MessageContextInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IMessageContextInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified MessageContextInfo message, length delimited. Does not implicitly {@link proto.MessageContextInfo.verify|verify} messages.
         * @param message MessageContextInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IMessageContextInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a MessageContextInfo message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns MessageContextInfo
         * @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): proto.MessageContextInfo;

        /**
         * Decodes a MessageContextInfo message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns MessageContextInfo
         * @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)): proto.MessageContextInfo;

        /**
         * Verifies a MessageContextInfo 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 MessageContextInfo message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns MessageContextInfo
         */
        public static fromObject(object: { [k: string]: any }): proto.MessageContextInfo;

        /**
         * Creates a plain object from a MessageContextInfo message. Also converts values to other types if specified.
         * @param message MessageContextInfo
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.MessageContextInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this MessageContextInfo to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a MessageKey. */
    interface IMessageKey {

        /** MessageKey remoteJid */
        remoteJid?: (string|null);

        /** MessageKey fromMe */
        fromMe?: (boolean|null);

        /** MessageKey id */
        id?: (string|null);

        /** MessageKey participant */
        participant?: (string|null);
    }

    /** Represents a MessageKey. */
    class MessageKey implements IMessageKey {

        /**
         * Constructs a new MessageKey.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IMessageKey);

        /** MessageKey remoteJid. */
        public remoteJid: string;

        /** MessageKey fromMe. */
        public fromMe: boolean;

        /** MessageKey id. */
        public id: string;

        /** MessageKey participant. */
        public participant: string;

        /**
         * Creates a new MessageKey instance using the specified properties.
         * @param [properties] Properties to set
         * @returns MessageKey instance
         */
        public static create(properties?: proto.IMessageKey): proto.MessageKey;

        /**
         * Encodes the specified MessageKey message. Does not implicitly {@link proto.MessageKey.verify|verify} messages.
         * @param message MessageKey message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IMessageKey, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified MessageKey message, length delimited. Does not implicitly {@link proto.MessageKey.verify|verify} messages.
         * @param message MessageKey message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IMessageKey, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a MessageKey message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns MessageKey
         * @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): proto.MessageKey;

        /**
         * Decodes a MessageKey message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns MessageKey
         * @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)): proto.MessageKey;

        /**
         * Verifies a MessageKey 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 MessageKey message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns MessageKey
         */
        public static fromObject(object: { [k: string]: any }): proto.MessageKey;

        /**
         * Creates a plain object from a MessageKey message. Also converts values to other types if specified.
         * @param message MessageKey
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.MessageKey, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this MessageKey to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a MessageSecretMessage. */
    interface IMessageSecretMessage {

        /** MessageSecretMessage version */
        version?: (number|null);

        /** MessageSecretMessage encIv */
        encIv?: (Uint8Array|null);

        /** MessageSecretMessage encPayload */
        encPayload?: (Uint8Array|null);
    }

    /** Represents a MessageSecretMessage. */
    class MessageSecretMessage implements IMessageSecretMessage {

        /**
         * Constructs a new MessageSecretMessage.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IMessageSecretMessage);

        /** MessageSecretMessage version. */
        public version: number;

        /** MessageSecretMessage encIv. */
        public encIv: Uint8Array;

        /** MessageSecretMessage encPayload. */
        public encPayload: Uint8Array;

        /**
         * Creates a new MessageSecretMessage instance using the specified properties.
         * @param [properties] Properties to set
         * @returns MessageSecretMessage instance
         */
        public static create(properties?: proto.IMessageSecretMessage): proto.MessageSecretMessage;

        /**
         * Encodes the specified MessageSecretMessage message. Does not implicitly {@link proto.MessageSecretMessage.verify|verify} messages.
         * @param message MessageSecretMessage message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IMessageSecretMessage, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified MessageSecretMessage message, length delimited. Does not implicitly {@link proto.MessageSecretMessage.verify|verify} messages.
         * @param message MessageSecretMessage message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IMessageSecretMessage, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a MessageSecretMessage message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns MessageSecretMessage
         * @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): proto.MessageSecretMessage;

        /**
         * Decodes a MessageSecretMessage message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns MessageSecretMessage
         * @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)): proto.MessageSecretMessage;

        /**
         * Verifies a MessageSecretMessage 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 MessageSecretMessage message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns MessageSecretMessage
         */
        public static fromObject(object: { [k: string]: any }): proto.MessageSecretMessage;

        /**
         * Creates a plain object from a MessageSecretMessage message. Also converts values to other types if specified.
         * @param message MessageSecretMessage
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.MessageSecretMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this MessageSecretMessage to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a Money. */
    interface IMoney {

        /** Money value */
        value?: (number|Long|null);

        /** Money offset */
        offset?: (number|null);

        /** Money currencyCode */
        currencyCode?: (string|null);
    }

    /** Represents a Money. */
    class Money implements IMoney {

        /**
         * Constructs a new Money.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IMoney);

        /** Money value. */
        public value: (number|Long);

        /** Money offset. */
        public offset: number;

        /** Money currencyCode. */
        public currencyCode: string;

        /**
         * Creates a new Money instance using the specified properties.
         * @param [properties] Properties to set
         * @returns Money instance
         */
        public static create(properties?: proto.IMoney): proto.Money;

        /**
         * Encodes the specified Money message. Does not implicitly {@link proto.Money.verify|verify} messages.
         * @param message Money message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IMoney, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified Money message, length delimited. Does not implicitly {@link proto.Money.verify|verify} messages.
         * @param message Money message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IMoney, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a Money message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns Money
         * @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): proto.Money;

        /**
         * Decodes a Money message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns Money
         * @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)): proto.Money;

        /**
         * Verifies a Money 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 Money message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns Money
         */
        public static fromObject(object: { [k: string]: any }): proto.Money;

        /**
         * Creates a plain object from a Money message. Also converts values to other types if specified.
         * @param message Money
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.Money, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this Money to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a MsgOpaqueData. */
    interface IMsgOpaqueData {

        /** MsgOpaqueData body */
        body?: (string|null);

        /** MsgOpaqueData caption */
        caption?: (string|null);

        /** MsgOpaqueData lng */
        lng?: (number|null);

        /** MsgOpaqueData isLive */
        isLive?: (boolean|null);

        /** MsgOpaqueData lat */
        lat?: (number|null);

        /** MsgOpaqueData paymentAmount1000 */
        paymentAmount1000?: (number|null);

        /** MsgOpaqueData paymentNoteMsgBody */
        paymentNoteMsgBody?: (string|null);

        /** MsgOpaqueData canonicalUrl */
        canonicalUrl?: (string|null);

        /** MsgOpaqueData matchedText */
        matchedText?: (string|null);

        /** MsgOpaqueData title */
        title?: (string|null);

        /** MsgOpaqueData description */
        description?: (string|null);

        /** MsgOpaqueData futureproofBuffer */
        futureproofBuffer?: (Uint8Array|null);

        /** MsgOpaqueData clientUrl */
        clientUrl?: (string|null);

        /** MsgOpaqueData loc */
        loc?: (string|null);

        /** MsgOpaqueData pollName */
        pollName?: (string|null);

        /** MsgOpaqueData pollOptions */
        pollOptions?: (proto.MsgOpaqueData.IPollOption[]|null);

        /** MsgOpaqueData pollSelectableOptionsCount */
        pollSelectableOptionsCount?: (number|null);

        /** MsgOpaqueData messageSecret */
        messageSecret?: (Uint8Array|null);

        /** MsgOpaqueData originalSelfAuthor */
        originalSelfAuthor?: (string|null);

        /** MsgOpaqueData senderTimestampMs */
        senderTimestampMs?: (number|Long|null);

        /** MsgOpaqueData pollUpdateParentKey */
        pollUpdateParentKey?: (string|null);

        /** MsgOpaqueData encPollVote */
        encPollVote?: (proto.IPollEncValue|null);

        /** MsgOpaqueData isSentCagPollCreation */
        isSentCagPollCreation?: (boolean|null);

        /** MsgOpaqueData encReactionTargetMessageKey */
        encReactionTargetMessageKey?: (string|null);

        /** MsgOpaqueData encReactionEncPayload */
        encReactionEncPayload?: (Uint8Array|null);

        /** MsgOpaqueData encReactionEncIv */
        encReactionEncIv?: (Uint8Array|null);

        /** MsgOpaqueData botMessageSecret */
        botMessageSecret?: (Uint8Array|null);

        /** MsgOpaqueData targetMessageKey */
        targetMessageKey?: (string|null);

        /** MsgOpaqueData encPayload */
        encPayload?: (Uint8Array|null);

        /** MsgOpaqueData encIv */
        encIv?: (Uint8Array|null);
    }

    /** Represents a MsgOpaqueData. */
    class MsgOpaqueData implements IMsgOpaqueData {

        /**
         * Constructs a new MsgOpaqueData.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IMsgOpaqueData);

        /** MsgOpaqueData body. */
        public body: string;

        /** MsgOpaqueData caption. */
        public caption: string;

        /** MsgOpaqueData lng. */
        public lng: number;

        /** MsgOpaqueData isLive. */
        public isLive: boolean;

        /** MsgOpaqueData lat. */
        public lat: number;

        /** MsgOpaqueData paymentAmount1000. */
        public paymentAmount1000: number;

        /** MsgOpaqueData paymentNoteMsgBody. */
        public paymentNoteMsgBody: string;

        /** MsgOpaqueData canonicalUrl. */
        public canonicalUrl: string;

        /** MsgOpaqueData matchedText. */
        public matchedText: string;

        /** MsgOpaqueData title. */
        public title: string;

        /** MsgOpaqueData description. */
        public description: string;

        /** MsgOpaqueData futureproofBuffer. */
        public futureproofBuffer: Uint8Array;

        /** MsgOpaqueData clientUrl. */
        public clientUrl: string;

        /** MsgOpaqueData loc. */
        public loc: string;

        /** MsgOpaqueData pollName. */
        public pollName: string;

        /** MsgOpaqueData pollOptions. */
        public pollOptions: proto.MsgOpaqueData.IPollOption[];

        /** MsgOpaqueData pollSelectableOptionsCount. */
        public pollSelectableOptionsCount: number;

        /** MsgOpaqueData messageSecret. */
        public messageSecret: Uint8Array;

        /** MsgOpaqueData originalSelfAuthor. */
        public originalSelfAuthor: string;

        /** MsgOpaqueData senderTimestampMs. */
        public senderTimestampMs: (number|Long);

        /** MsgOpaqueData pollUpdateParentKey. */
        public pollUpdateParentKey: string;

        /** MsgOpaqueData encPollVote. */
        public encPollVote?: (proto.IPollEncValue|null);

        /** MsgOpaqueData isSentCagPollCreation. */
        public isSentCagPollCreation: boolean;

        /** MsgOpaqueData encReactionTargetMessageKey. */
        public encReactionTargetMessageKey: string;

        /** MsgOpaqueData encReactionEncPayload. */
        public encReactionEncPayload: Uint8Array;

        /** MsgOpaqueData encReactionEncIv. */
        public encReactionEncIv: Uint8Array;

        /** MsgOpaqueData botMessageSecret. */
        public botMessageSecret: Uint8Array;

        /** MsgOpaqueData targetMessageKey. */
        public targetMessageKey: string;

        /** MsgOpaqueData encPayload. */
        public encPayload: Uint8Array;

        /** MsgOpaqueData encIv. */
        public encIv: Uint8Array;

        /**
         * Creates a new MsgOpaqueData instance using the specified properties.
         * @param [properties] Properties to set
         * @returns MsgOpaqueData instance
         */
        public static create(properties?: proto.IMsgOpaqueData): proto.MsgOpaqueData;

        /**
         * Encodes the specified MsgOpaqueData message. Does not implicitly {@link proto.MsgOpaqueData.verify|verify} messages.
         * @param message MsgOpaqueData message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IMsgOpaqueData, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified MsgOpaqueData message, length delimited. Does not implicitly {@link proto.MsgOpaqueData.verify|verify} messages.
         * @param message MsgOpaqueData message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IMsgOpaqueData, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a MsgOpaqueData message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns MsgOpaqueData
         * @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): proto.MsgOpaqueData;

        /**
         * Decodes a MsgOpaqueData message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns MsgOpaqueData
         * @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)): proto.MsgOpaqueData;

        /**
         * Verifies a MsgOpaqueData 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 MsgOpaqueData message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns MsgOpaqueData
         */
        public static fromObject(object: { [k: string]: any }): proto.MsgOpaqueData;

        /**
         * Creates a plain object from a MsgOpaqueData message. Also converts values to other types if specified.
         * @param message MsgOpaqueData
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.MsgOpaqueData, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this MsgOpaqueData to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace MsgOpaqueData {

        /** Properties of a PollOption. */
        interface IPollOption {

            /** PollOption name */
            name?: (string|null);
        }

        /** Represents a PollOption. */
        class PollOption implements IPollOption {

            /**
             * Constructs a new PollOption.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.MsgOpaqueData.IPollOption);

            /** PollOption name. */
            public name: string;

            /**
             * Creates a new PollOption instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PollOption instance
             */
            public static create(properties?: proto.MsgOpaqueData.IPollOption): proto.MsgOpaqueData.PollOption;

            /**
             * Encodes the specified PollOption message. Does not implicitly {@link proto.MsgOpaqueData.PollOption.verify|verify} messages.
             * @param message PollOption message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.MsgOpaqueData.IPollOption, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PollOption message, length delimited. Does not implicitly {@link proto.MsgOpaqueData.PollOption.verify|verify} messages.
             * @param message PollOption message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.MsgOpaqueData.IPollOption, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PollOption message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PollOption
             * @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): proto.MsgOpaqueData.PollOption;

            /**
             * Decodes a PollOption message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PollOption
             * @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)): proto.MsgOpaqueData.PollOption;

            /**
             * Verifies a PollOption 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 PollOption message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PollOption
             */
            public static fromObject(object: { [k: string]: any }): proto.MsgOpaqueData.PollOption;

            /**
             * Creates a plain object from a PollOption message. Also converts values to other types if specified.
             * @param message PollOption
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.MsgOpaqueData.PollOption, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PollOption to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }
    }

    /** Properties of a MsgRowOpaqueData. */
    interface IMsgRowOpaqueData {

        /** MsgRowOpaqueData currentMsg */
        currentMsg?: (proto.IMsgOpaqueData|null);

        /** MsgRowOpaqueData quotedMsg */
        quotedMsg?: (proto.IMsgOpaqueData|null);
    }

    /** Represents a MsgRowOpaqueData. */
    class MsgRowOpaqueData implements IMsgRowOpaqueData {

        /**
         * Constructs a new MsgRowOpaqueData.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IMsgRowOpaqueData);

        /** MsgRowOpaqueData currentMsg. */
        public currentMsg?: (proto.IMsgOpaqueData|null);

        /** MsgRowOpaqueData quotedMsg. */
        public quotedMsg?: (proto.IMsgOpaqueData|null);

        /**
         * Creates a new MsgRowOpaqueData instance using the specified properties.
         * @param [properties] Properties to set
         * @returns MsgRowOpaqueData instance
         */
        public static create(properties?: proto.IMsgRowOpaqueData): proto.MsgRowOpaqueData;

        /**
         * Encodes the specified MsgRowOpaqueData message. Does not implicitly {@link proto.MsgRowOpaqueData.verify|verify} messages.
         * @param message MsgRowOpaqueData message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IMsgRowOpaqueData, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified MsgRowOpaqueData message, length delimited. Does not implicitly {@link proto.MsgRowOpaqueData.verify|verify} messages.
         * @param message MsgRowOpaqueData message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IMsgRowOpaqueData, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a MsgRowOpaqueData message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns MsgRowOpaqueData
         * @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): proto.MsgRowOpaqueData;

        /**
         * Decodes a MsgRowOpaqueData message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns MsgRowOpaqueData
         * @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)): proto.MsgRowOpaqueData;

        /**
         * Verifies a MsgRowOpaqueData 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 MsgRowOpaqueData message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns MsgRowOpaqueData
         */
        public static fromObject(object: { [k: string]: any }): proto.MsgRowOpaqueData;

        /**
         * Creates a plain object from a MsgRowOpaqueData message. Also converts values to other types if specified.
         * @param message MsgRowOpaqueData
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.MsgRowOpaqueData, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this MsgRowOpaqueData to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a NoiseCertificate. */
    interface INoiseCertificate {

        /** NoiseCertificate details */
        details?: (Uint8Array|null);

        /** NoiseCertificate signature */
        signature?: (Uint8Array|null);
    }

    /** Represents a NoiseCertificate. */
    class NoiseCertificate implements INoiseCertificate {

        /**
         * Constructs a new NoiseCertificate.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.INoiseCertificate);

        /** NoiseCertificate details. */
        public details: Uint8Array;

        /** NoiseCertificate signature. */
        public signature: Uint8Array;

        /**
         * Creates a new NoiseCertificate instance using the specified properties.
         * @param [properties] Properties to set
         * @returns NoiseCertificate instance
         */
        public static create(properties?: proto.INoiseCertificate): proto.NoiseCertificate;

        /**
         * Encodes the specified NoiseCertificate message. Does not implicitly {@link proto.NoiseCertificate.verify|verify} messages.
         * @param message NoiseCertificate message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.INoiseCertificate, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified NoiseCertificate message, length delimited. Does not implicitly {@link proto.NoiseCertificate.verify|verify} messages.
         * @param message NoiseCertificate message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.INoiseCertificate, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a NoiseCertificate message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns NoiseCertificate
         * @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): proto.NoiseCertificate;

        /**
         * Decodes a NoiseCertificate message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns NoiseCertificate
         * @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)): proto.NoiseCertificate;

        /**
         * Verifies a NoiseCertificate 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 NoiseCertificate message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns NoiseCertificate
         */
        public static fromObject(object: { [k: string]: any }): proto.NoiseCertificate;

        /**
         * Creates a plain object from a NoiseCertificate message. Also converts values to other types if specified.
         * @param message NoiseCertificate
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.NoiseCertificate, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this NoiseCertificate to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace NoiseCertificate {

        /** Properties of a Details. */
        interface IDetails {

            /** Details serial */
            serial?: (number|null);

            /** Details issuer */
            issuer?: (string|null);

            /** Details expires */
            expires?: (number|Long|null);

            /** Details subject */
            subject?: (string|null);

            /** Details key */
            key?: (Uint8Array|null);
        }

        /** Represents a Details. */
        class Details implements IDetails {

            /**
             * Constructs a new Details.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.NoiseCertificate.IDetails);

            /** Details serial. */
            public serial: number;

            /** Details issuer. */
            public issuer: string;

            /** Details expires. */
            public expires: (number|Long);

            /** Details subject. */
            public subject: string;

            /** Details key. */
            public key: Uint8Array;

            /**
             * Creates a new Details instance using the specified properties.
             * @param [properties] Properties to set
             * @returns Details instance
             */
            public static create(properties?: proto.NoiseCertificate.IDetails): proto.NoiseCertificate.Details;

            /**
             * Encodes the specified Details message. Does not implicitly {@link proto.NoiseCertificate.Details.verify|verify} messages.
             * @param message Details message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.NoiseCertificate.IDetails, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified Details message, length delimited. Does not implicitly {@link proto.NoiseCertificate.Details.verify|verify} messages.
             * @param message Details message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.NoiseCertificate.IDetails, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a Details message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns Details
             * @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): proto.NoiseCertificate.Details;

            /**
             * Decodes a Details message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns Details
             * @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)): proto.NoiseCertificate.Details;

            /**
             * Verifies a Details 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 Details message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns Details
             */
            public static fromObject(object: { [k: string]: any }): proto.NoiseCertificate.Details;

            /**
             * Creates a plain object from a Details message. Also converts values to other types if specified.
             * @param message Details
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.NoiseCertificate.Details, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this Details to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }
    }

    /** Properties of a NotificationMessageInfo. */
    interface INotificationMessageInfo {

        /** NotificationMessageInfo key */
        key?: (proto.IMessageKey|null);

        /** NotificationMessageInfo message */
        message?: (proto.IMessage|null);

        /** NotificationMessageInfo messageTimestamp */
        messageTimestamp?: (number|Long|null);

        /** NotificationMessageInfo participant */
        participant?: (string|null);
    }

    /** Represents a NotificationMessageInfo. */
    class NotificationMessageInfo implements INotificationMessageInfo {

        /**
         * Constructs a new NotificationMessageInfo.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.INotificationMessageInfo);

        /** NotificationMessageInfo key. */
        public key?: (proto.IMessageKey|null);

        /** NotificationMessageInfo message. */
        public message?: (proto.IMessage|null);

        /** NotificationMessageInfo messageTimestamp. */
        public messageTimestamp: (number|Long);

        /** NotificationMessageInfo participant. */
        public participant: string;

        /**
         * Creates a new NotificationMessageInfo instance using the specified properties.
         * @param [properties] Properties to set
         * @returns NotificationMessageInfo instance
         */
        public static create(properties?: proto.INotificationMessageInfo): proto.NotificationMessageInfo;

        /**
         * Encodes the specified NotificationMessageInfo message. Does not implicitly {@link proto.NotificationMessageInfo.verify|verify} messages.
         * @param message NotificationMessageInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.INotificationMessageInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified NotificationMessageInfo message, length delimited. Does not implicitly {@link proto.NotificationMessageInfo.verify|verify} messages.
         * @param message NotificationMessageInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.INotificationMessageInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a NotificationMessageInfo message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns NotificationMessageInfo
         * @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): proto.NotificationMessageInfo;

        /**
         * Decodes a NotificationMessageInfo message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns NotificationMessageInfo
         * @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)): proto.NotificationMessageInfo;

        /**
         * Verifies a NotificationMessageInfo 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 NotificationMessageInfo message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns NotificationMessageInfo
         */
        public static fromObject(object: { [k: string]: any }): proto.NotificationMessageInfo;

        /**
         * Creates a plain object from a NotificationMessageInfo message. Also converts values to other types if specified.
         * @param message NotificationMessageInfo
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.NotificationMessageInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this NotificationMessageInfo to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a NotificationSettings. */
    interface INotificationSettings {

        /** NotificationSettings messageVibrate */
        messageVibrate?: (string|null);

        /** NotificationSettings messagePopup */
        messagePopup?: (string|null);

        /** NotificationSettings messageLight */
        messageLight?: (string|null);

        /** NotificationSettings lowPriorityNotifications */
        lowPriorityNotifications?: (boolean|null);

        /** NotificationSettings reactionsMuted */
        reactionsMuted?: (boolean|null);

        /** NotificationSettings callVibrate */
        callVibrate?: (string|null);
    }

    /** Represents a NotificationSettings. */
    class NotificationSettings implements INotificationSettings {

        /**
         * Constructs a new NotificationSettings.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.INotificationSettings);

        /** NotificationSettings messageVibrate. */
        public messageVibrate: string;

        /** NotificationSettings messagePopup. */
        public messagePopup: string;

        /** NotificationSettings messageLight. */
        public messageLight: string;

        /** NotificationSettings lowPriorityNotifications. */
        public lowPriorityNotifications: boolean;

        /** NotificationSettings reactionsMuted. */
        public reactionsMuted: boolean;

        /** NotificationSettings callVibrate. */
        public callVibrate: string;

        /**
         * Creates a new NotificationSettings instance using the specified properties.
         * @param [properties] Properties to set
         * @returns NotificationSettings instance
         */
        public static create(properties?: proto.INotificationSettings): proto.NotificationSettings;

        /**
         * Encodes the specified NotificationSettings message. Does not implicitly {@link proto.NotificationSettings.verify|verify} messages.
         * @param message NotificationSettings message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.INotificationSettings, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified NotificationSettings message, length delimited. Does not implicitly {@link proto.NotificationSettings.verify|verify} messages.
         * @param message NotificationSettings message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.INotificationSettings, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a NotificationSettings message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns NotificationSettings
         * @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): proto.NotificationSettings;

        /**
         * Decodes a NotificationSettings message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns NotificationSettings
         * @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)): proto.NotificationSettings;

        /**
         * Verifies a NotificationSettings 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 NotificationSettings message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns NotificationSettings
         */
        public static fromObject(object: { [k: string]: any }): proto.NotificationSettings;

        /**
         * Creates a plain object from a NotificationSettings message. Also converts values to other types if specified.
         * @param message NotificationSettings
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.NotificationSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this NotificationSettings to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a PastParticipant. */
    interface IPastParticipant {

        /** PastParticipant userJid */
        userJid?: (string|null);

        /** PastParticipant leaveReason */
        leaveReason?: (proto.PastParticipant.LeaveReason|null);

        /** PastParticipant leaveTs */
        leaveTs?: (number|Long|null);
    }

    /** Represents a PastParticipant. */
    class PastParticipant implements IPastParticipant {

        /**
         * Constructs a new PastParticipant.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPastParticipant);

        /** PastParticipant userJid. */
        public userJid: string;

        /** PastParticipant leaveReason. */
        public leaveReason: proto.PastParticipant.LeaveReason;

        /** PastParticipant leaveTs. */
        public leaveTs: (number|Long);

        /**
         * Creates a new PastParticipant instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PastParticipant instance
         */
        public static create(properties?: proto.IPastParticipant): proto.PastParticipant;

        /**
         * Encodes the specified PastParticipant message. Does not implicitly {@link proto.PastParticipant.verify|verify} messages.
         * @param message PastParticipant message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPastParticipant, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PastParticipant message, length delimited. Does not implicitly {@link proto.PastParticipant.verify|verify} messages.
         * @param message PastParticipant message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPastParticipant, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PastParticipant message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PastParticipant
         * @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): proto.PastParticipant;

        /**
         * Decodes a PastParticipant message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PastParticipant
         * @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)): proto.PastParticipant;

        /**
         * Verifies a PastParticipant 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 PastParticipant message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PastParticipant
         */
        public static fromObject(object: { [k: string]: any }): proto.PastParticipant;

        /**
         * Creates a plain object from a PastParticipant message. Also converts values to other types if specified.
         * @param message PastParticipant
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PastParticipant, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PastParticipant to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace PastParticipant {

        /** LeaveReason enum. */
        enum LeaveReason {
            LEFT = 0,
            REMOVED = 1
        }
    }

    /** Properties of a PastParticipants. */
    interface IPastParticipants {

        /** PastParticipants groupJid */
        groupJid?: (string|null);

        /** PastParticipants pastParticipants */
        pastParticipants?: (proto.IPastParticipant[]|null);
    }

    /** Represents a PastParticipants. */
    class PastParticipants implements IPastParticipants {

        /**
         * Constructs a new PastParticipants.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPastParticipants);

        /** PastParticipants groupJid. */
        public groupJid: string;

        /** PastParticipants pastParticipants. */
        public pastParticipants: proto.IPastParticipant[];

        /**
         * Creates a new PastParticipants instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PastParticipants instance
         */
        public static create(properties?: proto.IPastParticipants): proto.PastParticipants;

        /**
         * Encodes the specified PastParticipants message. Does not implicitly {@link proto.PastParticipants.verify|verify} messages.
         * @param message PastParticipants message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPastParticipants, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PastParticipants message, length delimited. Does not implicitly {@link proto.PastParticipants.verify|verify} messages.
         * @param message PastParticipants message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPastParticipants, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PastParticipants message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PastParticipants
         * @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): proto.PastParticipants;

        /**
         * Decodes a PastParticipants message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PastParticipants
         * @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)): proto.PastParticipants;

        /**
         * Verifies a PastParticipants 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 PastParticipants message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PastParticipants
         */
        public static fromObject(object: { [k: string]: any }): proto.PastParticipants;

        /**
         * Creates a plain object from a PastParticipants message. Also converts values to other types if specified.
         * @param message PastParticipants
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PastParticipants, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PastParticipants to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a PatchDebugData. */
    interface IPatchDebugData {

        /** PatchDebugData currentLthash */
        currentLthash?: (Uint8Array|null);

        /** PatchDebugData newLthash */
        newLthash?: (Uint8Array|null);

        /** PatchDebugData patchVersion */
        patchVersion?: (Uint8Array|null);

        /** PatchDebugData collectionName */
        collectionName?: (Uint8Array|null);

        /** PatchDebugData firstFourBytesFromAHashOfSnapshotMacKey */
        firstFourBytesFromAHashOfSnapshotMacKey?: (Uint8Array|null);

        /** PatchDebugData newLthashSubtract */
        newLthashSubtract?: (Uint8Array|null);

        /** PatchDebugData numberAdd */
        numberAdd?: (number|null);

        /** PatchDebugData numberRemove */
        numberRemove?: (number|null);

        /** PatchDebugData numberOverride */
        numberOverride?: (number|null);

        /** PatchDebugData senderPlatform */
        senderPlatform?: (proto.PatchDebugData.Platform|null);

        /** PatchDebugData isSenderPrimary */
        isSenderPrimary?: (boolean|null);
    }

    /** Represents a PatchDebugData. */
    class PatchDebugData implements IPatchDebugData {

        /**
         * Constructs a new PatchDebugData.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPatchDebugData);

        /** PatchDebugData currentLthash. */
        public currentLthash: Uint8Array;

        /** PatchDebugData newLthash. */
        public newLthash: Uint8Array;

        /** PatchDebugData patchVersion. */
        public patchVersion: Uint8Array;

        /** PatchDebugData collectionName. */
        public collectionName: Uint8Array;

        /** PatchDebugData firstFourBytesFromAHashOfSnapshotMacKey. */
        public firstFourBytesFromAHashOfSnapshotMacKey: Uint8Array;

        /** PatchDebugData newLthashSubtract. */
        public newLthashSubtract: Uint8Array;

        /** PatchDebugData numberAdd. */
        public numberAdd: number;

        /** PatchDebugData numberRemove. */
        public numberRemove: number;

        /** PatchDebugData numberOverride. */
        public numberOverride: number;

        /** PatchDebugData senderPlatform. */
        public senderPlatform: proto.PatchDebugData.Platform;

        /** PatchDebugData isSenderPrimary. */
        public isSenderPrimary: boolean;

        /**
         * Creates a new PatchDebugData instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PatchDebugData instance
         */
        public static create(properties?: proto.IPatchDebugData): proto.PatchDebugData;

        /**
         * Encodes the specified PatchDebugData message. Does not implicitly {@link proto.PatchDebugData.verify|verify} messages.
         * @param message PatchDebugData message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPatchDebugData, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PatchDebugData message, length delimited. Does not implicitly {@link proto.PatchDebugData.verify|verify} messages.
         * @param message PatchDebugData message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPatchDebugData, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PatchDebugData message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PatchDebugData
         * @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): proto.PatchDebugData;

        /**
         * Decodes a PatchDebugData message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PatchDebugData
         * @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)): proto.PatchDebugData;

        /**
         * Verifies a PatchDebugData 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 PatchDebugData message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PatchDebugData
         */
        public static fromObject(object: { [k: string]: any }): proto.PatchDebugData;

        /**
         * Creates a plain object from a PatchDebugData message. Also converts values to other types if specified.
         * @param message PatchDebugData
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PatchDebugData, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PatchDebugData to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace PatchDebugData {

        /** Platform enum. */
        enum Platform {
            ANDROID = 0,
            SMBA = 1,
            IPHONE = 2,
            SMBI = 3,
            WEB = 4,
            UWP = 5,
            DARWIN = 6
        }
    }

    /** Properties of a PaymentBackground. */
    interface IPaymentBackground {

        /** PaymentBackground id */
        id?: (string|null);

        /** PaymentBackground fileLength */
        fileLength?: (number|Long|null);

        /** PaymentBackground width */
        width?: (number|null);

        /** PaymentBackground height */
        height?: (number|null);

        /** PaymentBackground mimetype */
        mimetype?: (string|null);

        /** PaymentBackground placeholderArgb */
        placeholderArgb?: (number|null);

        /** PaymentBackground textArgb */
        textArgb?: (number|null);

        /** PaymentBackground subtextArgb */
        subtextArgb?: (number|null);

        /** PaymentBackground mediaData */
        mediaData?: (proto.PaymentBackground.IMediaData|null);

        /** PaymentBackground type */
        type?: (proto.PaymentBackground.Type|null);
    }

    /** Represents a PaymentBackground. */
    class PaymentBackground implements IPaymentBackground {

        /**
         * Constructs a new PaymentBackground.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPaymentBackground);

        /** PaymentBackground id. */
        public id: string;

        /** PaymentBackground fileLength. */
        public fileLength: (number|Long);

        /** PaymentBackground width. */
        public width: number;

        /** PaymentBackground height. */
        public height: number;

        /** PaymentBackground mimetype. */
        public mimetype: string;

        /** PaymentBackground placeholderArgb. */
        public placeholderArgb: number;

        /** PaymentBackground textArgb. */
        public textArgb: number;

        /** PaymentBackground subtextArgb. */
        public subtextArgb: number;

        /** PaymentBackground mediaData. */
        public mediaData?: (proto.PaymentBackground.IMediaData|null);

        /** PaymentBackground type. */
        public type: proto.PaymentBackground.Type;

        /**
         * Creates a new PaymentBackground instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PaymentBackground instance
         */
        public static create(properties?: proto.IPaymentBackground): proto.PaymentBackground;

        /**
         * Encodes the specified PaymentBackground message. Does not implicitly {@link proto.PaymentBackground.verify|verify} messages.
         * @param message PaymentBackground message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPaymentBackground, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PaymentBackground message, length delimited. Does not implicitly {@link proto.PaymentBackground.verify|verify} messages.
         * @param message PaymentBackground message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPaymentBackground, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PaymentBackground message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PaymentBackground
         * @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): proto.PaymentBackground;

        /**
         * Decodes a PaymentBackground message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PaymentBackground
         * @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)): proto.PaymentBackground;

        /**
         * Verifies a PaymentBackground 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 PaymentBackground message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PaymentBackground
         */
        public static fromObject(object: { [k: string]: any }): proto.PaymentBackground;

        /**
         * Creates a plain object from a PaymentBackground message. Also converts values to other types if specified.
         * @param message PaymentBackground
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PaymentBackground, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PaymentBackground to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace PaymentBackground {

        /** Properties of a MediaData. */
        interface IMediaData {

            /** MediaData mediaKey */
            mediaKey?: (Uint8Array|null);

            /** MediaData mediaKeyTimestamp */
            mediaKeyTimestamp?: (number|Long|null);

            /** MediaData fileSha256 */
            fileSha256?: (Uint8Array|null);

            /** MediaData fileEncSha256 */
            fileEncSha256?: (Uint8Array|null);

            /** MediaData directPath */
            directPath?: (string|null);
        }

        /** Represents a MediaData. */
        class MediaData implements IMediaData {

            /**
             * Constructs a new MediaData.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.PaymentBackground.IMediaData);

            /** MediaData mediaKey. */
            public mediaKey: Uint8Array;

            /** MediaData mediaKeyTimestamp. */
            public mediaKeyTimestamp: (number|Long);

            /** MediaData fileSha256. */
            public fileSha256: Uint8Array;

            /** MediaData fileEncSha256. */
            public fileEncSha256: Uint8Array;

            /** MediaData directPath. */
            public directPath: string;

            /**
             * Creates a new MediaData instance using the specified properties.
             * @param [properties] Properties to set
             * @returns MediaData instance
             */
            public static create(properties?: proto.PaymentBackground.IMediaData): proto.PaymentBackground.MediaData;

            /**
             * Encodes the specified MediaData message. Does not implicitly {@link proto.PaymentBackground.MediaData.verify|verify} messages.
             * @param message MediaData message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.PaymentBackground.IMediaData, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified MediaData message, length delimited. Does not implicitly {@link proto.PaymentBackground.MediaData.verify|verify} messages.
             * @param message MediaData message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.PaymentBackground.IMediaData, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a MediaData message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns MediaData
             * @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): proto.PaymentBackground.MediaData;

            /**
             * Decodes a MediaData message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns MediaData
             * @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)): proto.PaymentBackground.MediaData;

            /**
             * Verifies a MediaData 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 MediaData message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns MediaData
             */
            public static fromObject(object: { [k: string]: any }): proto.PaymentBackground.MediaData;

            /**
             * Creates a plain object from a MediaData message. Also converts values to other types if specified.
             * @param message MediaData
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.PaymentBackground.MediaData, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this MediaData to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Type enum. */
        enum Type {
            UNKNOWN = 0,
            DEFAULT = 1
        }
    }

    /** Properties of a PaymentInfo. */
    interface IPaymentInfo {

        /** PaymentInfo currencyDeprecated */
        currencyDeprecated?: (proto.PaymentInfo.Currency|null);

        /** PaymentInfo amount1000 */
        amount1000?: (number|Long|null);

        /** PaymentInfo receiverJid */
        receiverJid?: (string|null);

        /** PaymentInfo status */
        status?: (proto.PaymentInfo.Status|null);

        /** PaymentInfo transactionTimestamp */
        transactionTimestamp?: (number|Long|null);

        /** PaymentInfo requestMessageKey */
        requestMessageKey?: (proto.IMessageKey|null);

        /** PaymentInfo expiryTimestamp */
        expiryTimestamp?: (number|Long|null);

        /** PaymentInfo futureproofed */
        futureproofed?: (boolean|null);

        /** PaymentInfo currency */
        currency?: (string|null);

        /** PaymentInfo txnStatus */
        txnStatus?: (proto.PaymentInfo.TxnStatus|null);

        /** PaymentInfo useNoviFiatFormat */
        useNoviFiatFormat?: (boolean|null);

        /** PaymentInfo primaryAmount */
        primaryAmount?: (proto.IMoney|null);

        /** PaymentInfo exchangeAmount */
        exchangeAmount?: (proto.IMoney|null);
    }

    /** Represents a PaymentInfo. */
    class PaymentInfo implements IPaymentInfo {

        /**
         * Constructs a new PaymentInfo.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPaymentInfo);

        /** PaymentInfo currencyDeprecated. */
        public currencyDeprecated: proto.PaymentInfo.Currency;

        /** PaymentInfo amount1000. */
        public amount1000: (number|Long);

        /** PaymentInfo receiverJid. */
        public receiverJid: string;

        /** PaymentInfo status. */
        public status: proto.PaymentInfo.Status;

        /** PaymentInfo transactionTimestamp. */
        public transactionTimestamp: (number|Long);

        /** PaymentInfo requestMessageKey. */
        public requestMessageKey?: (proto.IMessageKey|null);

        /** PaymentInfo expiryTimestamp. */
        public expiryTimestamp: (number|Long);

        /** PaymentInfo futureproofed. */
        public futureproofed: boolean;

        /** PaymentInfo currency. */
        public currency: string;

        /** PaymentInfo txnStatus. */
        public txnStatus: proto.PaymentInfo.TxnStatus;

        /** PaymentInfo useNoviFiatFormat. */
        public useNoviFiatFormat: boolean;

        /** PaymentInfo primaryAmount. */
        public primaryAmount?: (proto.IMoney|null);

        /** PaymentInfo exchangeAmount. */
        public exchangeAmount?: (proto.IMoney|null);

        /**
         * Creates a new PaymentInfo instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PaymentInfo instance
         */
        public static create(properties?: proto.IPaymentInfo): proto.PaymentInfo;

        /**
         * Encodes the specified PaymentInfo message. Does not implicitly {@link proto.PaymentInfo.verify|verify} messages.
         * @param message PaymentInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPaymentInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PaymentInfo message, length delimited. Does not implicitly {@link proto.PaymentInfo.verify|verify} messages.
         * @param message PaymentInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPaymentInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PaymentInfo message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PaymentInfo
         * @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): proto.PaymentInfo;

        /**
         * Decodes a PaymentInfo message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PaymentInfo
         * @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)): proto.PaymentInfo;

        /**
         * Verifies a PaymentInfo 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 PaymentInfo message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PaymentInfo
         */
        public static fromObject(object: { [k: string]: any }): proto.PaymentInfo;

        /**
         * Creates a plain object from a PaymentInfo message. Also converts values to other types if specified.
         * @param message PaymentInfo
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PaymentInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PaymentInfo to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace PaymentInfo {

        /** Currency enum. */
        enum Currency {
            UNKNOWN_CURRENCY = 0,
            INR = 1
        }

        /** Status enum. */
        enum Status {
            UNKNOWN_STATUS = 0,
            PROCESSING = 1,
            SENT = 2,
            NEED_TO_ACCEPT = 3,
            COMPLETE = 4,
            COULD_NOT_COMPLETE = 5,
            REFUNDED = 6,
            EXPIRED = 7,
            REJECTED = 8,
            CANCELLED = 9,
            WAITING_FOR_PAYER = 10,
            WAITING = 11
        }

        /** TxnStatus enum. */
        enum TxnStatus {
            UNKNOWN = 0,
            PENDING_SETUP = 1,
            PENDING_RECEIVER_SETUP = 2,
            INIT = 3,
            SUCCESS = 4,
            COMPLETED = 5,
            FAILED = 6,
            FAILED_RISK = 7,
            FAILED_PROCESSING = 8,
            FAILED_RECEIVER_PROCESSING = 9,
            FAILED_DA = 10,
            FAILED_DA_FINAL = 11,
            REFUNDED_TXN = 12,
            REFUND_FAILED = 13,
            REFUND_FAILED_PROCESSING = 14,
            REFUND_FAILED_DA = 15,
            EXPIRED_TXN = 16,
            AUTH_CANCELED = 17,
            AUTH_CANCEL_FAILED_PROCESSING = 18,
            AUTH_CANCEL_FAILED = 19,
            COLLECT_INIT = 20,
            COLLECT_SUCCESS = 21,
            COLLECT_FAILED = 22,
            COLLECT_FAILED_RISK = 23,
            COLLECT_REJECTED = 24,
            COLLECT_EXPIRED = 25,
            COLLECT_CANCELED = 26,
            COLLECT_CANCELLING = 27,
            IN_REVIEW = 28,
            REVERSAL_SUCCESS = 29,
            REVERSAL_PENDING = 30,
            REFUND_PENDING = 31
        }
    }

    /** Properties of a PhoneNumberToLIDMapping. */
    interface IPhoneNumberToLIDMapping {

        /** PhoneNumberToLIDMapping pnJid */
        pnJid?: (string|null);

        /** PhoneNumberToLIDMapping lidJid */
        lidJid?: (string|null);
    }

    /** Represents a PhoneNumberToLIDMapping. */
    class PhoneNumberToLIDMapping implements IPhoneNumberToLIDMapping {

        /**
         * Constructs a new PhoneNumberToLIDMapping.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPhoneNumberToLIDMapping);

        /** PhoneNumberToLIDMapping pnJid. */
        public pnJid: string;

        /** PhoneNumberToLIDMapping lidJid. */
        public lidJid: string;

        /**
         * Creates a new PhoneNumberToLIDMapping instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PhoneNumberToLIDMapping instance
         */
        public static create(properties?: proto.IPhoneNumberToLIDMapping): proto.PhoneNumberToLIDMapping;

        /**
         * Encodes the specified PhoneNumberToLIDMapping message. Does not implicitly {@link proto.PhoneNumberToLIDMapping.verify|verify} messages.
         * @param message PhoneNumberToLIDMapping message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPhoneNumberToLIDMapping, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PhoneNumberToLIDMapping message, length delimited. Does not implicitly {@link proto.PhoneNumberToLIDMapping.verify|verify} messages.
         * @param message PhoneNumberToLIDMapping message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPhoneNumberToLIDMapping, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PhoneNumberToLIDMapping message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PhoneNumberToLIDMapping
         * @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): proto.PhoneNumberToLIDMapping;

        /**
         * Decodes a PhoneNumberToLIDMapping message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PhoneNumberToLIDMapping
         * @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)): proto.PhoneNumberToLIDMapping;

        /**
         * Verifies a PhoneNumberToLIDMapping 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 PhoneNumberToLIDMapping message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PhoneNumberToLIDMapping
         */
        public static fromObject(object: { [k: string]: any }): proto.PhoneNumberToLIDMapping;

        /**
         * Creates a plain object from a PhoneNumberToLIDMapping message. Also converts values to other types if specified.
         * @param message PhoneNumberToLIDMapping
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PhoneNumberToLIDMapping, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PhoneNumberToLIDMapping to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a PhotoChange. */
    interface IPhotoChange {

        /** PhotoChange oldPhoto */
        oldPhoto?: (Uint8Array|null);

        /** PhotoChange newPhoto */
        newPhoto?: (Uint8Array|null);

        /** PhotoChange newPhotoId */
        newPhotoId?: (number|null);
    }

    /** Represents a PhotoChange. */
    class PhotoChange implements IPhotoChange {

        /**
         * Constructs a new PhotoChange.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPhotoChange);

        /** PhotoChange oldPhoto. */
        public oldPhoto: Uint8Array;

        /** PhotoChange newPhoto. */
        public newPhoto: Uint8Array;

        /** PhotoChange newPhotoId. */
        public newPhotoId: number;

        /**
         * Creates a new PhotoChange instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PhotoChange instance
         */
        public static create(properties?: proto.IPhotoChange): proto.PhotoChange;

        /**
         * Encodes the specified PhotoChange message. Does not implicitly {@link proto.PhotoChange.verify|verify} messages.
         * @param message PhotoChange message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPhotoChange, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PhotoChange message, length delimited. Does not implicitly {@link proto.PhotoChange.verify|verify} messages.
         * @param message PhotoChange message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPhotoChange, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PhotoChange message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PhotoChange
         * @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): proto.PhotoChange;

        /**
         * Decodes a PhotoChange message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PhotoChange
         * @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)): proto.PhotoChange;

        /**
         * Verifies a PhotoChange 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 PhotoChange message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PhotoChange
         */
        public static fromObject(object: { [k: string]: any }): proto.PhotoChange;

        /**
         * Creates a plain object from a PhotoChange message. Also converts values to other types if specified.
         * @param message PhotoChange
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PhotoChange, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PhotoChange to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a PinInChat. */
    interface IPinInChat {

        /** PinInChat type */
        type?: (proto.PinInChat.Type|null);

        /** PinInChat key */
        key?: (proto.IMessageKey|null);

        /** PinInChat senderTimestampMs */
        senderTimestampMs?: (number|Long|null);

        /** PinInChat serverTimestampMs */
        serverTimestampMs?: (number|Long|null);

        /** PinInChat messageAddOnContextInfo */
        messageAddOnContextInfo?: (proto.IMessageAddOnContextInfo|null);
    }

    /** Represents a PinInChat. */
    class PinInChat implements IPinInChat {

        /**
         * Constructs a new PinInChat.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPinInChat);

        /** PinInChat type. */
        public type: proto.PinInChat.Type;

        /** PinInChat key. */
        public key?: (proto.IMessageKey|null);

        /** PinInChat senderTimestampMs. */
        public senderTimestampMs: (number|Long);

        /** PinInChat serverTimestampMs. */
        public serverTimestampMs: (number|Long);

        /** PinInChat messageAddOnContextInfo. */
        public messageAddOnContextInfo?: (proto.IMessageAddOnContextInfo|null);

        /**
         * Creates a new PinInChat instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PinInChat instance
         */
        public static create(properties?: proto.IPinInChat): proto.PinInChat;

        /**
         * Encodes the specified PinInChat message. Does not implicitly {@link proto.PinInChat.verify|verify} messages.
         * @param message PinInChat message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPinInChat, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PinInChat message, length delimited. Does not implicitly {@link proto.PinInChat.verify|verify} messages.
         * @param message PinInChat message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPinInChat, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PinInChat message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PinInChat
         * @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): proto.PinInChat;

        /**
         * Decodes a PinInChat message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PinInChat
         * @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)): proto.PinInChat;

        /**
         * Verifies a PinInChat 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 PinInChat message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PinInChat
         */
        public static fromObject(object: { [k: string]: any }): proto.PinInChat;

        /**
         * Creates a plain object from a PinInChat message. Also converts values to other types if specified.
         * @param message PinInChat
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PinInChat, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PinInChat to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace PinInChat {

        /** Type enum. */
        enum Type {
            UNKNOWN_TYPE = 0,
            PIN_FOR_ALL = 1,
            UNPIN_FOR_ALL = 2
        }
    }

    /** Properties of a Point. */
    interface IPoint {

        /** Point xDeprecated */
        xDeprecated?: (number|null);

        /** Point yDeprecated */
        yDeprecated?: (number|null);

        /** Point x */
        x?: (number|null);

        /** Point y */
        y?: (number|null);
    }

    /** Represents a Point. */
    class Point implements IPoint {

        /**
         * Constructs a new Point.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPoint);

        /** Point xDeprecated. */
        public xDeprecated: number;

        /** Point yDeprecated. */
        public yDeprecated: number;

        /** Point x. */
        public x: number;

        /** Point y. */
        public y: number;

        /**
         * Creates a new Point instance using the specified properties.
         * @param [properties] Properties to set
         * @returns Point instance
         */
        public static create(properties?: proto.IPoint): proto.Point;

        /**
         * Encodes the specified Point message. Does not implicitly {@link proto.Point.verify|verify} messages.
         * @param message Point message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPoint, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified Point message, length delimited. Does not implicitly {@link proto.Point.verify|verify} messages.
         * @param message Point message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPoint, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a Point message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns Point
         * @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): proto.Point;

        /**
         * Decodes a Point message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns Point
         * @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)): proto.Point;

        /**
         * Verifies a Point 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 Point message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns Point
         */
        public static fromObject(object: { [k: string]: any }): proto.Point;

        /**
         * Creates a plain object from a Point message. Also converts values to other types if specified.
         * @param message Point
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.Point, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this Point to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a PollAdditionalMetadata. */
    interface IPollAdditionalMetadata {

        /** PollAdditionalMetadata pollInvalidated */
        pollInvalidated?: (boolean|null);
    }

    /** Represents a PollAdditionalMetadata. */
    class PollAdditionalMetadata implements IPollAdditionalMetadata {

        /**
         * Constructs a new PollAdditionalMetadata.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPollAdditionalMetadata);

        /** PollAdditionalMetadata pollInvalidated. */
        public pollInvalidated: boolean;

        /**
         * Creates a new PollAdditionalMetadata instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PollAdditionalMetadata instance
         */
        public static create(properties?: proto.IPollAdditionalMetadata): proto.PollAdditionalMetadata;

        /**
         * Encodes the specified PollAdditionalMetadata message. Does not implicitly {@link proto.PollAdditionalMetadata.verify|verify} messages.
         * @param message PollAdditionalMetadata message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPollAdditionalMetadata, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PollAdditionalMetadata message, length delimited. Does not implicitly {@link proto.PollAdditionalMetadata.verify|verify} messages.
         * @param message PollAdditionalMetadata message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPollAdditionalMetadata, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PollAdditionalMetadata message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PollAdditionalMetadata
         * @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): proto.PollAdditionalMetadata;

        /**
         * Decodes a PollAdditionalMetadata message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PollAdditionalMetadata
         * @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)): proto.PollAdditionalMetadata;

        /**
         * Verifies a PollAdditionalMetadata 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 PollAdditionalMetadata message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PollAdditionalMetadata
         */
        public static fromObject(object: { [k: string]: any }): proto.PollAdditionalMetadata;

        /**
         * Creates a plain object from a PollAdditionalMetadata message. Also converts values to other types if specified.
         * @param message PollAdditionalMetadata
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PollAdditionalMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PollAdditionalMetadata to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a PollEncValue. */
    interface IPollEncValue {

        /** PollEncValue encPayload */
        encPayload?: (Uint8Array|null);

        /** PollEncValue encIv */
        encIv?: (Uint8Array|null);
    }

    /** Represents a PollEncValue. */
    class PollEncValue implements IPollEncValue {

        /**
         * Constructs a new PollEncValue.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPollEncValue);

        /** PollEncValue encPayload. */
        public encPayload: Uint8Array;

        /** PollEncValue encIv. */
        public encIv: Uint8Array;

        /**
         * Creates a new PollEncValue instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PollEncValue instance
         */
        public static create(properties?: proto.IPollEncValue): proto.PollEncValue;

        /**
         * Encodes the specified PollEncValue message. Does not implicitly {@link proto.PollEncValue.verify|verify} messages.
         * @param message PollEncValue message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPollEncValue, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PollEncValue message, length delimited. Does not implicitly {@link proto.PollEncValue.verify|verify} messages.
         * @param message PollEncValue message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPollEncValue, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PollEncValue message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PollEncValue
         * @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): proto.PollEncValue;

        /**
         * Decodes a PollEncValue message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PollEncValue
         * @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)): proto.PollEncValue;

        /**
         * Verifies a PollEncValue 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 PollEncValue message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PollEncValue
         */
        public static fromObject(object: { [k: string]: any }): proto.PollEncValue;

        /**
         * Creates a plain object from a PollEncValue message. Also converts values to other types if specified.
         * @param message PollEncValue
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PollEncValue, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PollEncValue to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a PollUpdate. */
    interface IPollUpdate {

        /** PollUpdate pollUpdateMessageKey */
        pollUpdateMessageKey?: (proto.IMessageKey|null);

        /** PollUpdate vote */
        vote?: (proto.Message.IPollVoteMessage|null);

        /** PollUpdate senderTimestampMs */
        senderTimestampMs?: (number|Long|null);

        /** PollUpdate serverTimestampMs */
        serverTimestampMs?: (number|Long|null);

        /** PollUpdate unread */
        unread?: (boolean|null);
    }

    /** Represents a PollUpdate. */
    class PollUpdate implements IPollUpdate {

        /**
         * Constructs a new PollUpdate.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPollUpdate);

        /** PollUpdate pollUpdateMessageKey. */
        public pollUpdateMessageKey?: (proto.IMessageKey|null);

        /** PollUpdate vote. */
        public vote?: (proto.Message.IPollVoteMessage|null);

        /** PollUpdate senderTimestampMs. */
        public senderTimestampMs: (number|Long);

        /** PollUpdate serverTimestampMs. */
        public serverTimestampMs: (number|Long);

        /** PollUpdate unread. */
        public unread: boolean;

        /**
         * Creates a new PollUpdate instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PollUpdate instance
         */
        public static create(properties?: proto.IPollUpdate): proto.PollUpdate;

        /**
         * Encodes the specified PollUpdate message. Does not implicitly {@link proto.PollUpdate.verify|verify} messages.
         * @param message PollUpdate message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPollUpdate, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PollUpdate message, length delimited. Does not implicitly {@link proto.PollUpdate.verify|verify} messages.
         * @param message PollUpdate message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPollUpdate, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PollUpdate message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PollUpdate
         * @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): proto.PollUpdate;

        /**
         * Decodes a PollUpdate message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PollUpdate
         * @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)): proto.PollUpdate;

        /**
         * Verifies a PollUpdate 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 PollUpdate message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PollUpdate
         */
        public static fromObject(object: { [k: string]: any }): proto.PollUpdate;

        /**
         * Creates a plain object from a PollUpdate message. Also converts values to other types if specified.
         * @param message PollUpdate
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PollUpdate, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PollUpdate to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a PreKeyRecordStructure. */
    interface IPreKeyRecordStructure {

        /** PreKeyRecordStructure id */
        id?: (number|null);

        /** PreKeyRecordStructure publicKey */
        publicKey?: (Uint8Array|null);

        /** PreKeyRecordStructure privateKey */
        privateKey?: (Uint8Array|null);
    }

    /** Represents a PreKeyRecordStructure. */
    class PreKeyRecordStructure implements IPreKeyRecordStructure {

        /**
         * Constructs a new PreKeyRecordStructure.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPreKeyRecordStructure);

        /** PreKeyRecordStructure id. */
        public id: number;

        /** PreKeyRecordStructure publicKey. */
        public publicKey: Uint8Array;

        /** PreKeyRecordStructure privateKey. */
        public privateKey: Uint8Array;

        /**
         * Creates a new PreKeyRecordStructure instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PreKeyRecordStructure instance
         */
        public static create(properties?: proto.IPreKeyRecordStructure): proto.PreKeyRecordStructure;

        /**
         * Encodes the specified PreKeyRecordStructure message. Does not implicitly {@link proto.PreKeyRecordStructure.verify|verify} messages.
         * @param message PreKeyRecordStructure message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPreKeyRecordStructure, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PreKeyRecordStructure message, length delimited. Does not implicitly {@link proto.PreKeyRecordStructure.verify|verify} messages.
         * @param message PreKeyRecordStructure message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPreKeyRecordStructure, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PreKeyRecordStructure message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PreKeyRecordStructure
         * @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): proto.PreKeyRecordStructure;

        /**
         * Decodes a PreKeyRecordStructure message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PreKeyRecordStructure
         * @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)): proto.PreKeyRecordStructure;

        /**
         * Verifies a PreKeyRecordStructure 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 PreKeyRecordStructure message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PreKeyRecordStructure
         */
        public static fromObject(object: { [k: string]: any }): proto.PreKeyRecordStructure;

        /**
         * Creates a plain object from a PreKeyRecordStructure message. Also converts values to other types if specified.
         * @param message PreKeyRecordStructure
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PreKeyRecordStructure, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PreKeyRecordStructure to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a PreKeySignalMessage. */
    interface IPreKeySignalMessage {

        /** PreKeySignalMessage registrationId */
        registrationId?: (number|null);

        /** PreKeySignalMessage preKeyId */
        preKeyId?: (number|null);

        /** PreKeySignalMessage signedPreKeyId */
        signedPreKeyId?: (number|null);

        /** PreKeySignalMessage baseKey */
        baseKey?: (Uint8Array|null);

        /** PreKeySignalMessage identityKey */
        identityKey?: (Uint8Array|null);

        /** PreKeySignalMessage message */
        message?: (Uint8Array|null);
    }

    /** Represents a PreKeySignalMessage. */
    class PreKeySignalMessage implements IPreKeySignalMessage {

        /**
         * Constructs a new PreKeySignalMessage.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPreKeySignalMessage);

        /** PreKeySignalMessage registrationId. */
        public registrationId: number;

        /** PreKeySignalMessage preKeyId. */
        public preKeyId: number;

        /** PreKeySignalMessage signedPreKeyId. */
        public signedPreKeyId: number;

        /** PreKeySignalMessage baseKey. */
        public baseKey: Uint8Array;

        /** PreKeySignalMessage identityKey. */
        public identityKey: Uint8Array;

        /** PreKeySignalMessage message. */
        public message: Uint8Array;

        /**
         * Creates a new PreKeySignalMessage instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PreKeySignalMessage instance
         */
        public static create(properties?: proto.IPreKeySignalMessage): proto.PreKeySignalMessage;

        /**
         * Encodes the specified PreKeySignalMessage message. Does not implicitly {@link proto.PreKeySignalMessage.verify|verify} messages.
         * @param message PreKeySignalMessage message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPreKeySignalMessage, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PreKeySignalMessage message, length delimited. Does not implicitly {@link proto.PreKeySignalMessage.verify|verify} messages.
         * @param message PreKeySignalMessage message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPreKeySignalMessage, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PreKeySignalMessage message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PreKeySignalMessage
         * @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): proto.PreKeySignalMessage;

        /**
         * Decodes a PreKeySignalMessage message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PreKeySignalMessage
         * @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)): proto.PreKeySignalMessage;

        /**
         * Verifies a PreKeySignalMessage 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 PreKeySignalMessage message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PreKeySignalMessage
         */
        public static fromObject(object: { [k: string]: any }): proto.PreKeySignalMessage;

        /**
         * Creates a plain object from a PreKeySignalMessage message. Also converts values to other types if specified.
         * @param message PreKeySignalMessage
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PreKeySignalMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PreKeySignalMessage to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a PremiumMessageInfo. */
    interface IPremiumMessageInfo {

        /** PremiumMessageInfo serverCampaignId */
        serverCampaignId?: (string|null);
    }

    /** Represents a PremiumMessageInfo. */
    class PremiumMessageInfo implements IPremiumMessageInfo {

        /**
         * Constructs a new PremiumMessageInfo.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPremiumMessageInfo);

        /** PremiumMessageInfo serverCampaignId. */
        public serverCampaignId: string;

        /**
         * Creates a new PremiumMessageInfo instance using the specified properties.
         * @param [properties] Properties to set
         * @returns PremiumMessageInfo instance
         */
        public static create(properties?: proto.IPremiumMessageInfo): proto.PremiumMessageInfo;

        /**
         * Encodes the specified PremiumMessageInfo message. Does not implicitly {@link proto.PremiumMessageInfo.verify|verify} messages.
         * @param message PremiumMessageInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPremiumMessageInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified PremiumMessageInfo message, length delimited. Does not implicitly {@link proto.PremiumMessageInfo.verify|verify} messages.
         * @param message PremiumMessageInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPremiumMessageInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a PremiumMessageInfo message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns PremiumMessageInfo
         * @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): proto.PremiumMessageInfo;

        /**
         * Decodes a PremiumMessageInfo message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns PremiumMessageInfo
         * @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)): proto.PremiumMessageInfo;

        /**
         * Verifies a PremiumMessageInfo 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 PremiumMessageInfo message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns PremiumMessageInfo
         */
        public static fromObject(object: { [k: string]: any }): proto.PremiumMessageInfo;

        /**
         * Creates a plain object from a PremiumMessageInfo message. Also converts values to other types if specified.
         * @param message PremiumMessageInfo
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.PremiumMessageInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this PremiumMessageInfo to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a Pushname. */
    interface IPushname {

        /** Pushname id */
        id?: (string|null);

        /** Pushname pushname */
        pushname?: (string|null);
    }

    /** Represents a Pushname. */
    class Pushname implements IPushname {

        /**
         * Constructs a new Pushname.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IPushname);

        /** Pushname id. */
        public id: string;

        /** Pushname pushname. */
        public pushname: string;

        /**
         * Creates a new Pushname instance using the specified properties.
         * @param [properties] Properties to set
         * @returns Pushname instance
         */
        public static create(properties?: proto.IPushname): proto.Pushname;

        /**
         * Encodes the specified Pushname message. Does not implicitly {@link proto.Pushname.verify|verify} messages.
         * @param message Pushname message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IPushname, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified Pushname message, length delimited. Does not implicitly {@link proto.Pushname.verify|verify} messages.
         * @param message Pushname message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IPushname, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a Pushname message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns Pushname
         * @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): proto.Pushname;

        /**
         * Decodes a Pushname message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns Pushname
         * @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)): proto.Pushname;

        /**
         * Verifies a Pushname 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 Pushname message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns Pushname
         */
        public static fromObject(object: { [k: string]: any }): proto.Pushname;

        /**
         * Creates a plain object from a Pushname message. Also converts values to other types if specified.
         * @param message Pushname
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.Pushname, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this Pushname to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a QP. */
    interface IQP {
    }

    /** Represents a QP. */
    class QP implements IQP {

        /**
         * Constructs a new QP.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IQP);

        /**
         * Creates a new QP instance using the specified properties.
         * @param [properties] Properties to set
         * @returns QP instance
         */
        public static create(properties?: proto.IQP): proto.QP;

        /**
         * Encodes the specified QP message. Does not implicitly {@link proto.QP.verify|verify} messages.
         * @param message QP message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IQP, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified QP message, length delimited. Does not implicitly {@link proto.QP.verify|verify} messages.
         * @param message QP message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IQP, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a QP message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns QP
         * @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): proto.QP;

        /**
         * Decodes a QP message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns QP
         * @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)): proto.QP;

        /**
         * Verifies a QP 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 QP message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns QP
         */
        public static fromObject(object: { [k: string]: any }): proto.QP;

        /**
         * Creates a plain object from a QP message. Also converts values to other types if specified.
         * @param message QP
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.QP, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this QP to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace QP {

        /** ClauseType enum. */
        enum ClauseType {
            AND = 1,
            OR = 2,
            NOR = 3
        }

        /** Properties of a Filter. */
        interface IFilter {

            /** Filter filterName */
            filterName: string;

            /** Filter parameters */
            parameters?: (proto.QP.IFilterParameters[]|null);

            /** Filter filterResult */
            filterResult?: (proto.QP.FilterResult|null);

            /** Filter clientNotSupportedConfig */
            clientNotSupportedConfig: proto.QP.FilterClientNotSupportedConfig;
        }

        /** Represents a Filter. */
        class Filter implements IFilter {

            /**
             * Constructs a new Filter.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.QP.IFilter);

            /** Filter filterName. */
            public filterName: string;

            /** Filter parameters. */
            public parameters: proto.QP.IFilterParameters[];

            /** Filter filterResult. */
            public filterResult: proto.QP.FilterResult;

            /** Filter clientNotSupportedConfig. */
            public clientNotSupportedConfig: proto.QP.FilterClientNotSupportedConfig;

            /**
             * Creates a new Filter instance using the specified properties.
             * @param [properties] Properties to set
             * @returns Filter instance
             */
            public static create(properties?: proto.QP.IFilter): proto.QP.Filter;

            /**
             * Encodes the specified Filter message. Does not implicitly {@link proto.QP.Filter.verify|verify} messages.
             * @param message Filter message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.QP.IFilter, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified Filter message, length delimited. Does not implicitly {@link proto.QP.Filter.verify|verify} messages.
             * @param message Filter message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.QP.IFilter, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a Filter message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns Filter
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proto.QP.Filter;

            /**
             * Decodes a Filter message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns Filter
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proto.QP.Filter;

            /**
             * Verifies a Filter message.
             * @param message Plain object to verify
             * @returns `null` if valid, otherwise the reason why it is not
             */
            public static verify(message: { [k: string]: any }): (string|null);

            /**
             * Creates a Filter message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns Filter
             */
            public static fromObject(object: { [k: string]: any }): proto.QP.Filter;

            /**
             * Creates a plain object from a Filter message. Also converts values to other types if specified.
             * @param message Filter
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.QP.Filter, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this Filter to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a FilterClause. */
        interface IFilterClause {

            /** FilterClause clauseType */
            clauseType: proto.QP.ClauseType;

            /** FilterClause clauses */
            clauses?: (proto.QP.IFilterClause[]|null);

            /** FilterClause filters */
            filters?: (proto.QP.IFilter[]|null);
        }

        /** Represents a FilterClause. */
        class FilterClause implements IFilterClause {

            /**
             * Constructs a new FilterClause.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.QP.IFilterClause);

            /** FilterClause clauseType. */
            public clauseType: proto.QP.ClauseType;

            /** FilterClause clauses. */
            public clauses: proto.QP.IFilterClause[];

            /** FilterClause filters. */
            public filters: proto.QP.IFilter[];

            /**
             * Creates a new FilterClause instance using the specified properties.
             * @param [properties] Properties to set
             * @returns FilterClause instance
             */
            public static create(properties?: proto.QP.IFilterClause): proto.QP.FilterClause;

            /**
             * Encodes the specified FilterClause message. Does not implicitly {@link proto.QP.FilterClause.verify|verify} messages.
             * @param message FilterClause message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.QP.IFilterClause, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified FilterClause message, length delimited. Does not implicitly {@link proto.QP.FilterClause.verify|verify} messages.
             * @param message FilterClause message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.QP.IFilterClause, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a FilterClause message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns FilterClause
             * @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): proto.QP.FilterClause;

            /**
             * Decodes a FilterClause message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns FilterClause
             * @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)): proto.QP.FilterClause;

            /**
             * Verifies a FilterClause 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 FilterClause message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns FilterClause
             */
            public static fromObject(object: { [k: string]: any }): proto.QP.FilterClause;

            /**
             * Creates a plain object from a FilterClause message. Also converts values to other types if specified.
             * @param message FilterClause
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.QP.FilterClause, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this FilterClause to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** FilterClientNotSupportedConfig enum. */
        enum FilterClientNotSupportedConfig {
            PASS_BY_DEFAULT = 1,
            FAIL_BY_DEFAULT = 2
        }

        /** Properties of a FilterParameters. */
        interface IFilterParameters {

            /** FilterParameters key */
            key?: (string|null);

            /** FilterParameters value */
            value?: (string|null);
        }

        /** Represents a FilterParameters. */
        class FilterParameters implements IFilterParameters {

            /**
             * Constructs a new FilterParameters.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.QP.IFilterParameters);

            /** FilterParameters key. */
            public key: string;

            /** FilterParameters value. */
            public value: string;

            /**
             * Creates a new FilterParameters instance using the specified properties.
             * @param [properties] Properties to set
             * @returns FilterParameters instance
             */
            public static create(properties?: proto.QP.IFilterParameters): proto.QP.FilterParameters;

            /**
             * Encodes the specified FilterParameters message. Does not implicitly {@link proto.QP.FilterParameters.verify|verify} messages.
             * @param message FilterParameters message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.QP.IFilterParameters, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified FilterParameters message, length delimited. Does not implicitly {@link proto.QP.FilterParameters.verify|verify} messages.
             * @param message FilterParameters message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.QP.IFilterParameters, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a FilterParameters message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns FilterParameters
             * @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): proto.QP.FilterParameters;

            /**
             * Decodes a FilterParameters message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns FilterParameters
             * @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)): proto.QP.FilterParameters;

            /**
             * Verifies a FilterParameters 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 FilterParameters message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns FilterParameters
             */
            public static fromObject(object: { [k: string]: any }): proto.QP.FilterParameters;

            /**
             * Creates a plain object from a FilterParameters message. Also converts values to other types if specified.
             * @param message FilterParameters
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.QP.FilterParameters, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this FilterParameters to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** FilterResult enum. */
        enum FilterResult {
            TRUE = 1,
            FALSE = 2,
            UNKNOWN = 3
        }
    }

    /** Properties of a Reaction. */
    interface IReaction {

        /** Reaction key */
        key?: (proto.IMessageKey|null);

        /** Reaction text */
        text?: (string|null);

        /** Reaction groupingKey */
        groupingKey?: (string|null);

        /** Reaction senderTimestampMs */
        senderTimestampMs?: (number|Long|null);

        /** Reaction unread */
        unread?: (boolean|null);
    }

    /** Represents a Reaction. */
    class Reaction implements IReaction {

        /**
         * Constructs a new Reaction.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IReaction);

        /** Reaction key. */
        public key?: (proto.IMessageKey|null);

        /** Reaction text. */
        public text: string;

        /** Reaction groupingKey. */
        public groupingKey: string;

        /** Reaction senderTimestampMs. */
        public senderTimestampMs: (number|Long);

        /** Reaction unread. */
        public unread: boolean;

        /**
         * Creates a new Reaction instance using the specified properties.
         * @param [properties] Properties to set
         * @returns Reaction instance
         */
        public static create(properties?: proto.IReaction): proto.Reaction;

        /**
         * Encodes the specified Reaction message. Does not implicitly {@link proto.Reaction.verify|verify} messages.
         * @param message Reaction message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IReaction, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified Reaction message, length delimited. Does not implicitly {@link proto.Reaction.verify|verify} messages.
         * @param message Reaction message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IReaction, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a Reaction message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns Reaction
         * @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): proto.Reaction;

        /**
         * Decodes a Reaction message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns Reaction
         * @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)): proto.Reaction;

        /**
         * Verifies a Reaction 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 Reaction message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns Reaction
         */
        public static fromObject(object: { [k: string]: any }): proto.Reaction;

        /**
         * Creates a plain object from a Reaction message. Also converts values to other types if specified.
         * @param message Reaction
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.Reaction, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this Reaction to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a RecentEmojiWeight. */
    interface IRecentEmojiWeight {

        /** RecentEmojiWeight emoji */
        emoji?: (string|null);

        /** RecentEmojiWeight weight */
        weight?: (number|null);
    }

    /** Represents a RecentEmojiWeight. */
    class RecentEmojiWeight implements IRecentEmojiWeight {

        /**
         * Constructs a new RecentEmojiWeight.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IRecentEmojiWeight);

        /** RecentEmojiWeight emoji. */
        public emoji: string;

        /** RecentEmojiWeight weight. */
        public weight: number;

        /**
         * Creates a new RecentEmojiWeight instance using the specified properties.
         * @param [properties] Properties to set
         * @returns RecentEmojiWeight instance
         */
        public static create(properties?: proto.IRecentEmojiWeight): proto.RecentEmojiWeight;

        /**
         * Encodes the specified RecentEmojiWeight message. Does not implicitly {@link proto.RecentEmojiWeight.verify|verify} messages.
         * @param message RecentEmojiWeight message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IRecentEmojiWeight, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified RecentEmojiWeight message, length delimited. Does not implicitly {@link proto.RecentEmojiWeight.verify|verify} messages.
         * @param message RecentEmojiWeight message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IRecentEmojiWeight, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a RecentEmojiWeight message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns RecentEmojiWeight
         * @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): proto.RecentEmojiWeight;

        /**
         * Decodes a RecentEmojiWeight message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns RecentEmojiWeight
         * @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)): proto.RecentEmojiWeight;

        /**
         * Verifies a RecentEmojiWeight 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 RecentEmojiWeight message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns RecentEmojiWeight
         */
        public static fromObject(object: { [k: string]: any }): proto.RecentEmojiWeight;

        /**
         * Creates a plain object from a RecentEmojiWeight message. Also converts values to other types if specified.
         * @param message RecentEmojiWeight
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.RecentEmojiWeight, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this RecentEmojiWeight to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a RecordStructure. */
    interface IRecordStructure {

        /** RecordStructure currentSession */
        currentSession?: (proto.ISessionStructure|null);

        /** RecordStructure previousSessions */
        previousSessions?: (proto.ISessionStructure[]|null);
    }

    /** Represents a RecordStructure. */
    class RecordStructure implements IRecordStructure {

        /**
         * Constructs a new RecordStructure.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IRecordStructure);

        /** RecordStructure currentSession. */
        public currentSession?: (proto.ISessionStructure|null);

        /** RecordStructure previousSessions. */
        public previousSessions: proto.ISessionStructure[];

        /**
         * Creates a new RecordStructure instance using the specified properties.
         * @param [properties] Properties to set
         * @returns RecordStructure instance
         */
        public static create(properties?: proto.IRecordStructure): proto.RecordStructure;

        /**
         * Encodes the specified RecordStructure message. Does not implicitly {@link proto.RecordStructure.verify|verify} messages.
         * @param message RecordStructure message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IRecordStructure, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified RecordStructure message, length delimited. Does not implicitly {@link proto.RecordStructure.verify|verify} messages.
         * @param message RecordStructure message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IRecordStructure, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a RecordStructure message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns RecordStructure
         * @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): proto.RecordStructure;

        /**
         * Decodes a RecordStructure message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns RecordStructure
         * @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)): proto.RecordStructure;

        /**
         * Verifies a RecordStructure 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 RecordStructure message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns RecordStructure
         */
        public static fromObject(object: { [k: string]: any }): proto.RecordStructure;

        /**
         * Creates a plain object from a RecordStructure message. Also converts values to other types if specified.
         * @param message RecordStructure
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.RecordStructure, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this RecordStructure to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a ReportingTokenInfo. */
    interface IReportingTokenInfo {

        /** ReportingTokenInfo reportingTag */
        reportingTag?: (Uint8Array|null);
    }

    /** Represents a ReportingTokenInfo. */
    class ReportingTokenInfo implements IReportingTokenInfo {

        /**
         * Constructs a new ReportingTokenInfo.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IReportingTokenInfo);

        /** ReportingTokenInfo reportingTag. */
        public reportingTag: Uint8Array;

        /**
         * Creates a new ReportingTokenInfo instance using the specified properties.
         * @param [properties] Properties to set
         * @returns ReportingTokenInfo instance
         */
        public static create(properties?: proto.IReportingTokenInfo): proto.ReportingTokenInfo;

        /**
         * Encodes the specified ReportingTokenInfo message. Does not implicitly {@link proto.ReportingTokenInfo.verify|verify} messages.
         * @param message ReportingTokenInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IReportingTokenInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified ReportingTokenInfo message, length delimited. Does not implicitly {@link proto.ReportingTokenInfo.verify|verify} messages.
         * @param message ReportingTokenInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IReportingTokenInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a ReportingTokenInfo message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns ReportingTokenInfo
         * @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): proto.ReportingTokenInfo;

        /**
         * Decodes a ReportingTokenInfo message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns ReportingTokenInfo
         * @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)): proto.ReportingTokenInfo;

        /**
         * Verifies a ReportingTokenInfo 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 ReportingTokenInfo message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns ReportingTokenInfo
         */
        public static fromObject(object: { [k: string]: any }): proto.ReportingTokenInfo;

        /**
         * Creates a plain object from a ReportingTokenInfo message. Also converts values to other types if specified.
         * @param message ReportingTokenInfo
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.ReportingTokenInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this ReportingTokenInfo to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SenderKeyDistributionMessage. */
    interface ISenderKeyDistributionMessage {

        /** SenderKeyDistributionMessage id */
        id?: (number|null);

        /** SenderKeyDistributionMessage iteration */
        iteration?: (number|null);

        /** SenderKeyDistributionMessage chainKey */
        chainKey?: (Uint8Array|null);

        /** SenderKeyDistributionMessage signingKey */
        signingKey?: (Uint8Array|null);
    }

    /** Represents a SenderKeyDistributionMessage. */
    class SenderKeyDistributionMessage implements ISenderKeyDistributionMessage {

        /**
         * Constructs a new SenderKeyDistributionMessage.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISenderKeyDistributionMessage);

        /** SenderKeyDistributionMessage id. */
        public id: number;

        /** SenderKeyDistributionMessage iteration. */
        public iteration: number;

        /** SenderKeyDistributionMessage chainKey. */
        public chainKey: Uint8Array;

        /** SenderKeyDistributionMessage signingKey. */
        public signingKey: Uint8Array;

        /**
         * Creates a new SenderKeyDistributionMessage instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SenderKeyDistributionMessage instance
         */
        public static create(properties?: proto.ISenderKeyDistributionMessage): proto.SenderKeyDistributionMessage;

        /**
         * Encodes the specified SenderKeyDistributionMessage message. Does not implicitly {@link proto.SenderKeyDistributionMessage.verify|verify} messages.
         * @param message SenderKeyDistributionMessage message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISenderKeyDistributionMessage, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SenderKeyDistributionMessage message, length delimited. Does not implicitly {@link proto.SenderKeyDistributionMessage.verify|verify} messages.
         * @param message SenderKeyDistributionMessage message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISenderKeyDistributionMessage, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SenderKeyDistributionMessage message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SenderKeyDistributionMessage
         * @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): proto.SenderKeyDistributionMessage;

        /**
         * Decodes a SenderKeyDistributionMessage message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SenderKeyDistributionMessage
         * @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)): proto.SenderKeyDistributionMessage;

        /**
         * Verifies a SenderKeyDistributionMessage 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 SenderKeyDistributionMessage message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SenderKeyDistributionMessage
         */
        public static fromObject(object: { [k: string]: any }): proto.SenderKeyDistributionMessage;

        /**
         * Creates a plain object from a SenderKeyDistributionMessage message. Also converts values to other types if specified.
         * @param message SenderKeyDistributionMessage
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SenderKeyDistributionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SenderKeyDistributionMessage to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SenderKeyMessage. */
    interface ISenderKeyMessage {

        /** SenderKeyMessage id */
        id?: (number|null);

        /** SenderKeyMessage iteration */
        iteration?: (number|null);

        /** SenderKeyMessage ciphertext */
        ciphertext?: (Uint8Array|null);
    }

    /** Represents a SenderKeyMessage. */
    class SenderKeyMessage implements ISenderKeyMessage {

        /**
         * Constructs a new SenderKeyMessage.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISenderKeyMessage);

        /** SenderKeyMessage id. */
        public id: number;

        /** SenderKeyMessage iteration. */
        public iteration: number;

        /** SenderKeyMessage ciphertext. */
        public ciphertext: Uint8Array;

        /**
         * Creates a new SenderKeyMessage instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SenderKeyMessage instance
         */
        public static create(properties?: proto.ISenderKeyMessage): proto.SenderKeyMessage;

        /**
         * Encodes the specified SenderKeyMessage message. Does not implicitly {@link proto.SenderKeyMessage.verify|verify} messages.
         * @param message SenderKeyMessage message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISenderKeyMessage, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SenderKeyMessage message, length delimited. Does not implicitly {@link proto.SenderKeyMessage.verify|verify} messages.
         * @param message SenderKeyMessage message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISenderKeyMessage, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SenderKeyMessage message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SenderKeyMessage
         * @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): proto.SenderKeyMessage;

        /**
         * Decodes a SenderKeyMessage message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SenderKeyMessage
         * @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)): proto.SenderKeyMessage;

        /**
         * Verifies a SenderKeyMessage 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 SenderKeyMessage message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SenderKeyMessage
         */
        public static fromObject(object: { [k: string]: any }): proto.SenderKeyMessage;

        /**
         * Creates a plain object from a SenderKeyMessage message. Also converts values to other types if specified.
         * @param message SenderKeyMessage
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SenderKeyMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SenderKeyMessage to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SenderKeyRecordStructure. */
    interface ISenderKeyRecordStructure {

        /** SenderKeyRecordStructure senderKeyStates */
        senderKeyStates?: (proto.ISenderKeyStateStructure[]|null);
    }

    /** Represents a SenderKeyRecordStructure. */
    class SenderKeyRecordStructure implements ISenderKeyRecordStructure {

        /**
         * Constructs a new SenderKeyRecordStructure.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISenderKeyRecordStructure);

        /** SenderKeyRecordStructure senderKeyStates. */
        public senderKeyStates: proto.ISenderKeyStateStructure[];

        /**
         * Creates a new SenderKeyRecordStructure instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SenderKeyRecordStructure instance
         */
        public static create(properties?: proto.ISenderKeyRecordStructure): proto.SenderKeyRecordStructure;

        /**
         * Encodes the specified SenderKeyRecordStructure message. Does not implicitly {@link proto.SenderKeyRecordStructure.verify|verify} messages.
         * @param message SenderKeyRecordStructure message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISenderKeyRecordStructure, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SenderKeyRecordStructure message, length delimited. Does not implicitly {@link proto.SenderKeyRecordStructure.verify|verify} messages.
         * @param message SenderKeyRecordStructure message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISenderKeyRecordStructure, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SenderKeyRecordStructure message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SenderKeyRecordStructure
         * @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): proto.SenderKeyRecordStructure;

        /**
         * Decodes a SenderKeyRecordStructure message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SenderKeyRecordStructure
         * @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)): proto.SenderKeyRecordStructure;

        /**
         * Verifies a SenderKeyRecordStructure 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 SenderKeyRecordStructure message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SenderKeyRecordStructure
         */
        public static fromObject(object: { [k: string]: any }): proto.SenderKeyRecordStructure;

        /**
         * Creates a plain object from a SenderKeyRecordStructure message. Also converts values to other types if specified.
         * @param message SenderKeyRecordStructure
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SenderKeyRecordStructure, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SenderKeyRecordStructure to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SenderKeyStateStructure. */
    interface ISenderKeyStateStructure {

        /** SenderKeyStateStructure senderKeyId */
        senderKeyId?: (number|null);

        /** SenderKeyStateStructure senderChainKey */
        senderChainKey?: (proto.SenderKeyStateStructure.ISenderChainKey|null);

        /** SenderKeyStateStructure senderSigningKey */
        senderSigningKey?: (proto.SenderKeyStateStructure.ISenderSigningKey|null);

        /** SenderKeyStateStructure senderMessageKeys */
        senderMessageKeys?: (proto.SenderKeyStateStructure.ISenderMessageKey[]|null);
    }

    /** Represents a SenderKeyStateStructure. */
    class SenderKeyStateStructure implements ISenderKeyStateStructure {

        /**
         * Constructs a new SenderKeyStateStructure.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISenderKeyStateStructure);

        /** SenderKeyStateStructure senderKeyId. */
        public senderKeyId: number;

        /** SenderKeyStateStructure senderChainKey. */
        public senderChainKey?: (proto.SenderKeyStateStructure.ISenderChainKey|null);

        /** SenderKeyStateStructure senderSigningKey. */
        public senderSigningKey?: (proto.SenderKeyStateStructure.ISenderSigningKey|null);

        /** SenderKeyStateStructure senderMessageKeys. */
        public senderMessageKeys: proto.SenderKeyStateStructure.ISenderMessageKey[];

        /**
         * Creates a new SenderKeyStateStructure instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SenderKeyStateStructure instance
         */
        public static create(properties?: proto.ISenderKeyStateStructure): proto.SenderKeyStateStructure;

        /**
         * Encodes the specified SenderKeyStateStructure message. Does not implicitly {@link proto.SenderKeyStateStructure.verify|verify} messages.
         * @param message SenderKeyStateStructure message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISenderKeyStateStructure, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SenderKeyStateStructure message, length delimited. Does not implicitly {@link proto.SenderKeyStateStructure.verify|verify} messages.
         * @param message SenderKeyStateStructure message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISenderKeyStateStructure, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SenderKeyStateStructure message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SenderKeyStateStructure
         * @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): proto.SenderKeyStateStructure;

        /**
         * Decodes a SenderKeyStateStructure message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SenderKeyStateStructure
         * @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)): proto.SenderKeyStateStructure;

        /**
         * Verifies a SenderKeyStateStructure 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 SenderKeyStateStructure message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SenderKeyStateStructure
         */
        public static fromObject(object: { [k: string]: any }): proto.SenderKeyStateStructure;

        /**
         * Creates a plain object from a SenderKeyStateStructure message. Also converts values to other types if specified.
         * @param message SenderKeyStateStructure
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SenderKeyStateStructure, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SenderKeyStateStructure to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace SenderKeyStateStructure {

        /** Properties of a SenderChainKey. */
        interface ISenderChainKey {

            /** SenderChainKey iteration */
            iteration?: (number|null);

            /** SenderChainKey seed */
            seed?: (Uint8Array|null);
        }

        /** Represents a SenderChainKey. */
        class SenderChainKey implements ISenderChainKey {

            /**
             * Constructs a new SenderChainKey.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SenderKeyStateStructure.ISenderChainKey);

            /** SenderChainKey iteration. */
            public iteration: number;

            /** SenderChainKey seed. */
            public seed: Uint8Array;

            /**
             * Creates a new SenderChainKey instance using the specified properties.
             * @param [properties] Properties to set
             * @returns SenderChainKey instance
             */
            public static create(properties?: proto.SenderKeyStateStructure.ISenderChainKey): proto.SenderKeyStateStructure.SenderChainKey;

            /**
             * Encodes the specified SenderChainKey message. Does not implicitly {@link proto.SenderKeyStateStructure.SenderChainKey.verify|verify} messages.
             * @param message SenderChainKey message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SenderKeyStateStructure.ISenderChainKey, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified SenderChainKey message, length delimited. Does not implicitly {@link proto.SenderKeyStateStructure.SenderChainKey.verify|verify} messages.
             * @param message SenderChainKey message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SenderKeyStateStructure.ISenderChainKey, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a SenderChainKey message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns SenderChainKey
             * @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): proto.SenderKeyStateStructure.SenderChainKey;

            /**
             * Decodes a SenderChainKey message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns SenderChainKey
             * @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)): proto.SenderKeyStateStructure.SenderChainKey;

            /**
             * Verifies a SenderChainKey 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 SenderChainKey message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns SenderChainKey
             */
            public static fromObject(object: { [k: string]: any }): proto.SenderKeyStateStructure.SenderChainKey;

            /**
             * Creates a plain object from a SenderChainKey message. Also converts values to other types if specified.
             * @param message SenderChainKey
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SenderKeyStateStructure.SenderChainKey, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this SenderChainKey to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a SenderMessageKey. */
        interface ISenderMessageKey {

            /** SenderMessageKey iteration */
            iteration?: (number|null);

            /** SenderMessageKey seed */
            seed?: (Uint8Array|null);
        }

        /** Represents a SenderMessageKey. */
        class SenderMessageKey implements ISenderMessageKey {

            /**
             * Constructs a new SenderMessageKey.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SenderKeyStateStructure.ISenderMessageKey);

            /** SenderMessageKey iteration. */
            public iteration: number;

            /** SenderMessageKey seed. */
            public seed: Uint8Array;

            /**
             * Creates a new SenderMessageKey instance using the specified properties.
             * @param [properties] Properties to set
             * @returns SenderMessageKey instance
             */
            public static create(properties?: proto.SenderKeyStateStructure.ISenderMessageKey): proto.SenderKeyStateStructure.SenderMessageKey;

            /**
             * Encodes the specified SenderMessageKey message. Does not implicitly {@link proto.SenderKeyStateStructure.SenderMessageKey.verify|verify} messages.
             * @param message SenderMessageKey message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SenderKeyStateStructure.ISenderMessageKey, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified SenderMessageKey message, length delimited. Does not implicitly {@link proto.SenderKeyStateStructure.SenderMessageKey.verify|verify} messages.
             * @param message SenderMessageKey message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SenderKeyStateStructure.ISenderMessageKey, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a SenderMessageKey message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns SenderMessageKey
             * @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): proto.SenderKeyStateStructure.SenderMessageKey;

            /**
             * Decodes a SenderMessageKey message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns SenderMessageKey
             * @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)): proto.SenderKeyStateStructure.SenderMessageKey;

            /**
             * Verifies a SenderMessageKey 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 SenderMessageKey message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns SenderMessageKey
             */
            public static fromObject(object: { [k: string]: any }): proto.SenderKeyStateStructure.SenderMessageKey;

            /**
             * Creates a plain object from a SenderMessageKey message. Also converts values to other types if specified.
             * @param message SenderMessageKey
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SenderKeyStateStructure.SenderMessageKey, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this SenderMessageKey to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a SenderSigningKey. */
        interface ISenderSigningKey {

            /** SenderSigningKey public */
            "public"?: (Uint8Array|null);

            /** SenderSigningKey private */
            "private"?: (Uint8Array|null);
        }

        /** Represents a SenderSigningKey. */
        class SenderSigningKey implements ISenderSigningKey {

            /**
             * Constructs a new SenderSigningKey.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SenderKeyStateStructure.ISenderSigningKey);

            /** SenderSigningKey public. */
            public public: Uint8Array;

            /** SenderSigningKey private. */
            public private: Uint8Array;

            /**
             * Creates a new SenderSigningKey instance using the specified properties.
             * @param [properties] Properties to set
             * @returns SenderSigningKey instance
             */
            public static create(properties?: proto.SenderKeyStateStructure.ISenderSigningKey): proto.SenderKeyStateStructure.SenderSigningKey;

            /**
             * Encodes the specified SenderSigningKey message. Does not implicitly {@link proto.SenderKeyStateStructure.SenderSigningKey.verify|verify} messages.
             * @param message SenderSigningKey message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SenderKeyStateStructure.ISenderSigningKey, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified SenderSigningKey message, length delimited. Does not implicitly {@link proto.SenderKeyStateStructure.SenderSigningKey.verify|verify} messages.
             * @param message SenderSigningKey message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SenderKeyStateStructure.ISenderSigningKey, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a SenderSigningKey message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns SenderSigningKey
             * @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): proto.SenderKeyStateStructure.SenderSigningKey;

            /**
             * Decodes a SenderSigningKey message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns SenderSigningKey
             * @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)): proto.SenderKeyStateStructure.SenderSigningKey;

            /**
             * Verifies a SenderSigningKey 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 SenderSigningKey message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns SenderSigningKey
             */
            public static fromObject(object: { [k: string]: any }): proto.SenderKeyStateStructure.SenderSigningKey;

            /**
             * Creates a plain object from a SenderSigningKey message. Also converts values to other types if specified.
             * @param message SenderSigningKey
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SenderKeyStateStructure.SenderSigningKey, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this SenderSigningKey to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }
    }

    /** Properties of a ServerErrorReceipt. */
    interface IServerErrorReceipt {

        /** ServerErrorReceipt stanzaId */
        stanzaId?: (string|null);
    }

    /** Represents a ServerErrorReceipt. */
    class ServerErrorReceipt implements IServerErrorReceipt {

        /**
         * Constructs a new ServerErrorReceipt.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IServerErrorReceipt);

        /** ServerErrorReceipt stanzaId. */
        public stanzaId: string;

        /**
         * Creates a new ServerErrorReceipt instance using the specified properties.
         * @param [properties] Properties to set
         * @returns ServerErrorReceipt instance
         */
        public static create(properties?: proto.IServerErrorReceipt): proto.ServerErrorReceipt;

        /**
         * Encodes the specified ServerErrorReceipt message. Does not implicitly {@link proto.ServerErrorReceipt.verify|verify} messages.
         * @param message ServerErrorReceipt message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IServerErrorReceipt, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified ServerErrorReceipt message, length delimited. Does not implicitly {@link proto.ServerErrorReceipt.verify|verify} messages.
         * @param message ServerErrorReceipt message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IServerErrorReceipt, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a ServerErrorReceipt message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns ServerErrorReceipt
         * @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): proto.ServerErrorReceipt;

        /**
         * Decodes a ServerErrorReceipt message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns ServerErrorReceipt
         * @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)): proto.ServerErrorReceipt;

        /**
         * Verifies a ServerErrorReceipt 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 ServerErrorReceipt message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns ServerErrorReceipt
         */
        public static fromObject(object: { [k: string]: any }): proto.ServerErrorReceipt;

        /**
         * Creates a plain object from a ServerErrorReceipt message. Also converts values to other types if specified.
         * @param message ServerErrorReceipt
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.ServerErrorReceipt, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this ServerErrorReceipt to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SessionStructure. */
    interface ISessionStructure {

        /** SessionStructure sessionVersion */
        sessionVersion?: (number|null);

        /** SessionStructure localIdentityPublic */
        localIdentityPublic?: (Uint8Array|null);

        /** SessionStructure remoteIdentityPublic */
        remoteIdentityPublic?: (Uint8Array|null);

        /** SessionStructure rootKey */
        rootKey?: (Uint8Array|null);

        /** SessionStructure previousCounter */
        previousCounter?: (number|null);

        /** SessionStructure senderChain */
        senderChain?: (proto.SessionStructure.IChain|null);

        /** SessionStructure receiverChains */
        receiverChains?: (proto.SessionStructure.IChain[]|null);

        /** SessionStructure pendingKeyExchange */
        pendingKeyExchange?: (proto.SessionStructure.IPendingKeyExchange|null);

        /** SessionStructure pendingPreKey */
        pendingPreKey?: (proto.SessionStructure.IPendingPreKey|null);

        /** SessionStructure remoteRegistrationId */
        remoteRegistrationId?: (number|null);

        /** SessionStructure localRegistrationId */
        localRegistrationId?: (number|null);

        /** SessionStructure needsRefresh */
        needsRefresh?: (boolean|null);

        /** SessionStructure aliceBaseKey */
        aliceBaseKey?: (Uint8Array|null);
    }

    /** Represents a SessionStructure. */
    class SessionStructure implements ISessionStructure {

        /**
         * Constructs a new SessionStructure.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISessionStructure);

        /** SessionStructure sessionVersion. */
        public sessionVersion: number;

        /** SessionStructure localIdentityPublic. */
        public localIdentityPublic: Uint8Array;

        /** SessionStructure remoteIdentityPublic. */
        public remoteIdentityPublic: Uint8Array;

        /** SessionStructure rootKey. */
        public rootKey: Uint8Array;

        /** SessionStructure previousCounter. */
        public previousCounter: number;

        /** SessionStructure senderChain. */
        public senderChain?: (proto.SessionStructure.IChain|null);

        /** SessionStructure receiverChains. */
        public receiverChains: proto.SessionStructure.IChain[];

        /** SessionStructure pendingKeyExchange. */
        public pendingKeyExchange?: (proto.SessionStructure.IPendingKeyExchange|null);

        /** SessionStructure pendingPreKey. */
        public pendingPreKey?: (proto.SessionStructure.IPendingPreKey|null);

        /** SessionStructure remoteRegistrationId. */
        public remoteRegistrationId: number;

        /** SessionStructure localRegistrationId. */
        public localRegistrationId: number;

        /** SessionStructure needsRefresh. */
        public needsRefresh: boolean;

        /** SessionStructure aliceBaseKey. */
        public aliceBaseKey: Uint8Array;

        /**
         * Creates a new SessionStructure instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SessionStructure instance
         */
        public static create(properties?: proto.ISessionStructure): proto.SessionStructure;

        /**
         * Encodes the specified SessionStructure message. Does not implicitly {@link proto.SessionStructure.verify|verify} messages.
         * @param message SessionStructure message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISessionStructure, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SessionStructure message, length delimited. Does not implicitly {@link proto.SessionStructure.verify|verify} messages.
         * @param message SessionStructure message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISessionStructure, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SessionStructure message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SessionStructure
         * @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): proto.SessionStructure;

        /**
         * Decodes a SessionStructure message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SessionStructure
         * @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)): proto.SessionStructure;

        /**
         * Verifies a SessionStructure 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 SessionStructure message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SessionStructure
         */
        public static fromObject(object: { [k: string]: any }): proto.SessionStructure;

        /**
         * Creates a plain object from a SessionStructure message. Also converts values to other types if specified.
         * @param message SessionStructure
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SessionStructure, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SessionStructure to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace SessionStructure {

        /** Properties of a Chain. */
        interface IChain {

            /** Chain senderRatchetKey */
            senderRatchetKey?: (Uint8Array|null);

            /** Chain senderRatchetKeyPrivate */
            senderRatchetKeyPrivate?: (Uint8Array|null);

            /** Chain chainKey */
            chainKey?: (proto.SessionStructure.Chain.IChainKey|null);

            /** Chain messageKeys */
            messageKeys?: (proto.SessionStructure.Chain.IMessageKey[]|null);
        }

        /** Represents a Chain. */
        class Chain implements IChain {

            /**
             * Constructs a new Chain.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SessionStructure.IChain);

            /** Chain senderRatchetKey. */
            public senderRatchetKey: Uint8Array;

            /** Chain senderRatchetKeyPrivate. */
            public senderRatchetKeyPrivate: Uint8Array;

            /** Chain chainKey. */
            public chainKey?: (proto.SessionStructure.Chain.IChainKey|null);

            /** Chain messageKeys. */
            public messageKeys: proto.SessionStructure.Chain.IMessageKey[];

            /**
             * Creates a new Chain instance using the specified properties.
             * @param [properties] Properties to set
             * @returns Chain instance
             */
            public static create(properties?: proto.SessionStructure.IChain): proto.SessionStructure.Chain;

            /**
             * Encodes the specified Chain message. Does not implicitly {@link proto.SessionStructure.Chain.verify|verify} messages.
             * @param message Chain message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SessionStructure.IChain, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified Chain message, length delimited. Does not implicitly {@link proto.SessionStructure.Chain.verify|verify} messages.
             * @param message Chain message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SessionStructure.IChain, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a Chain message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns Chain
             * @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): proto.SessionStructure.Chain;

            /**
             * Decodes a Chain message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns Chain
             * @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)): proto.SessionStructure.Chain;

            /**
             * Verifies a Chain 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 Chain message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns Chain
             */
            public static fromObject(object: { [k: string]: any }): proto.SessionStructure.Chain;

            /**
             * Creates a plain object from a Chain message. Also converts values to other types if specified.
             * @param message Chain
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SessionStructure.Chain, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this Chain to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace Chain {

            /** Properties of a ChainKey. */
            interface IChainKey {

                /** ChainKey index */
                index?: (number|null);

                /** ChainKey key */
                key?: (Uint8Array|null);
            }

            /** Represents a ChainKey. */
            class ChainKey implements IChainKey {

                /**
                 * Constructs a new ChainKey.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.SessionStructure.Chain.IChainKey);

                /** ChainKey index. */
                public index: number;

                /** ChainKey key. */
                public key: Uint8Array;

                /**
                 * Creates a new ChainKey instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns ChainKey instance
                 */
                public static create(properties?: proto.SessionStructure.Chain.IChainKey): proto.SessionStructure.Chain.ChainKey;

                /**
                 * Encodes the specified ChainKey message. Does not implicitly {@link proto.SessionStructure.Chain.ChainKey.verify|verify} messages.
                 * @param message ChainKey message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.SessionStructure.Chain.IChainKey, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified ChainKey message, length delimited. Does not implicitly {@link proto.SessionStructure.Chain.ChainKey.verify|verify} messages.
                 * @param message ChainKey message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.SessionStructure.Chain.IChainKey, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a ChainKey message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns ChainKey
                 * @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): proto.SessionStructure.Chain.ChainKey;

                /**
                 * Decodes a ChainKey message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns ChainKey
                 * @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)): proto.SessionStructure.Chain.ChainKey;

                /**
                 * Verifies a ChainKey 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 ChainKey message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns ChainKey
                 */
                public static fromObject(object: { [k: string]: any }): proto.SessionStructure.Chain.ChainKey;

                /**
                 * Creates a plain object from a ChainKey message. Also converts values to other types if specified.
                 * @param message ChainKey
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.SessionStructure.Chain.ChainKey, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this ChainKey to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }

            /** Properties of a MessageKey. */
            interface IMessageKey {

                /** MessageKey index */
                index?: (number|null);

                /** MessageKey cipherKey */
                cipherKey?: (Uint8Array|null);

                /** MessageKey macKey */
                macKey?: (Uint8Array|null);

                /** MessageKey iv */
                iv?: (Uint8Array|null);
            }

            /** Represents a MessageKey. */
            class MessageKey implements IMessageKey {

                /**
                 * Constructs a new MessageKey.
                 * @param [properties] Properties to set
                 */
                constructor(properties?: proto.SessionStructure.Chain.IMessageKey);

                /** MessageKey index. */
                public index: number;

                /** MessageKey cipherKey. */
                public cipherKey: Uint8Array;

                /** MessageKey macKey. */
                public macKey: Uint8Array;

                /** MessageKey iv. */
                public iv: Uint8Array;

                /**
                 * Creates a new MessageKey instance using the specified properties.
                 * @param [properties] Properties to set
                 * @returns MessageKey instance
                 */
                public static create(properties?: proto.SessionStructure.Chain.IMessageKey): proto.SessionStructure.Chain.MessageKey;

                /**
                 * Encodes the specified MessageKey message. Does not implicitly {@link proto.SessionStructure.Chain.MessageKey.verify|verify} messages.
                 * @param message MessageKey message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encode(message: proto.SessionStructure.Chain.IMessageKey, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Encodes the specified MessageKey message, length delimited. Does not implicitly {@link proto.SessionStructure.Chain.MessageKey.verify|verify} messages.
                 * @param message MessageKey message or plain object to encode
                 * @param [writer] Writer to encode to
                 * @returns Writer
                 */
                public static encodeDelimited(message: proto.SessionStructure.Chain.IMessageKey, writer?: $protobuf.Writer): $protobuf.Writer;

                /**
                 * Decodes a MessageKey message from the specified reader or buffer.
                 * @param reader Reader or buffer to decode from
                 * @param [length] Message length if known beforehand
                 * @returns MessageKey
                 * @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): proto.SessionStructure.Chain.MessageKey;

                /**
                 * Decodes a MessageKey message from the specified reader or buffer, length delimited.
                 * @param reader Reader or buffer to decode from
                 * @returns MessageKey
                 * @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)): proto.SessionStructure.Chain.MessageKey;

                /**
                 * Verifies a MessageKey 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 MessageKey message from a plain object. Also converts values to their respective internal types.
                 * @param object Plain object
                 * @returns MessageKey
                 */
                public static fromObject(object: { [k: string]: any }): proto.SessionStructure.Chain.MessageKey;

                /**
                 * Creates a plain object from a MessageKey message. Also converts values to other types if specified.
                 * @param message MessageKey
                 * @param [options] Conversion options
                 * @returns Plain object
                 */
                public static toObject(message: proto.SessionStructure.Chain.MessageKey, options?: $protobuf.IConversionOptions): { [k: string]: any };

                /**
                 * Converts this MessageKey to JSON.
                 * @returns JSON object
                 */
                public toJSON(): { [k: string]: any };
            }
        }

        /** Properties of a PendingKeyExchange. */
        interface IPendingKeyExchange {

            /** PendingKeyExchange sequence */
            sequence?: (number|null);

            /** PendingKeyExchange localBaseKey */
            localBaseKey?: (Uint8Array|null);

            /** PendingKeyExchange localBaseKeyPrivate */
            localBaseKeyPrivate?: (Uint8Array|null);

            /** PendingKeyExchange localRatchetKey */
            localRatchetKey?: (Uint8Array|null);

            /** PendingKeyExchange localRatchetKeyPrivate */
            localRatchetKeyPrivate?: (Uint8Array|null);

            /** PendingKeyExchange localIdentityKey */
            localIdentityKey?: (Uint8Array|null);

            /** PendingKeyExchange localIdentityKeyPrivate */
            localIdentityKeyPrivate?: (Uint8Array|null);
        }

        /** Represents a PendingKeyExchange. */
        class PendingKeyExchange implements IPendingKeyExchange {

            /**
             * Constructs a new PendingKeyExchange.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SessionStructure.IPendingKeyExchange);

            /** PendingKeyExchange sequence. */
            public sequence: number;

            /** PendingKeyExchange localBaseKey. */
            public localBaseKey: Uint8Array;

            /** PendingKeyExchange localBaseKeyPrivate. */
            public localBaseKeyPrivate: Uint8Array;

            /** PendingKeyExchange localRatchetKey. */
            public localRatchetKey: Uint8Array;

            /** PendingKeyExchange localRatchetKeyPrivate. */
            public localRatchetKeyPrivate: Uint8Array;

            /** PendingKeyExchange localIdentityKey. */
            public localIdentityKey: Uint8Array;

            /** PendingKeyExchange localIdentityKeyPrivate. */
            public localIdentityKeyPrivate: Uint8Array;

            /**
             * Creates a new PendingKeyExchange instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PendingKeyExchange instance
             */
            public static create(properties?: proto.SessionStructure.IPendingKeyExchange): proto.SessionStructure.PendingKeyExchange;

            /**
             * Encodes the specified PendingKeyExchange message. Does not implicitly {@link proto.SessionStructure.PendingKeyExchange.verify|verify} messages.
             * @param message PendingKeyExchange message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SessionStructure.IPendingKeyExchange, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PendingKeyExchange message, length delimited. Does not implicitly {@link proto.SessionStructure.PendingKeyExchange.verify|verify} messages.
             * @param message PendingKeyExchange message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SessionStructure.IPendingKeyExchange, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PendingKeyExchange message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PendingKeyExchange
             * @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): proto.SessionStructure.PendingKeyExchange;

            /**
             * Decodes a PendingKeyExchange message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PendingKeyExchange
             * @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)): proto.SessionStructure.PendingKeyExchange;

            /**
             * Verifies a PendingKeyExchange 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 PendingKeyExchange message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PendingKeyExchange
             */
            public static fromObject(object: { [k: string]: any }): proto.SessionStructure.PendingKeyExchange;

            /**
             * Creates a plain object from a PendingKeyExchange message. Also converts values to other types if specified.
             * @param message PendingKeyExchange
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SessionStructure.PendingKeyExchange, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PendingKeyExchange to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a PendingPreKey. */
        interface IPendingPreKey {

            /** PendingPreKey preKeyId */
            preKeyId?: (number|null);

            /** PendingPreKey signedPreKeyId */
            signedPreKeyId?: (number|null);

            /** PendingPreKey baseKey */
            baseKey?: (Uint8Array|null);
        }

        /** Represents a PendingPreKey. */
        class PendingPreKey implements IPendingPreKey {

            /**
             * Constructs a new PendingPreKey.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SessionStructure.IPendingPreKey);

            /** PendingPreKey preKeyId. */
            public preKeyId: number;

            /** PendingPreKey signedPreKeyId. */
            public signedPreKeyId: number;

            /** PendingPreKey baseKey. */
            public baseKey: Uint8Array;

            /**
             * Creates a new PendingPreKey instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PendingPreKey instance
             */
            public static create(properties?: proto.SessionStructure.IPendingPreKey): proto.SessionStructure.PendingPreKey;

            /**
             * Encodes the specified PendingPreKey message. Does not implicitly {@link proto.SessionStructure.PendingPreKey.verify|verify} messages.
             * @param message PendingPreKey message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SessionStructure.IPendingPreKey, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PendingPreKey message, length delimited. Does not implicitly {@link proto.SessionStructure.PendingPreKey.verify|verify} messages.
             * @param message PendingPreKey message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SessionStructure.IPendingPreKey, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PendingPreKey message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PendingPreKey
             * @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): proto.SessionStructure.PendingPreKey;

            /**
             * Decodes a PendingPreKey message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PendingPreKey
             * @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)): proto.SessionStructure.PendingPreKey;

            /**
             * Verifies a PendingPreKey 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 PendingPreKey message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PendingPreKey
             */
            public static fromObject(object: { [k: string]: any }): proto.SessionStructure.PendingPreKey;

            /**
             * Creates a plain object from a PendingPreKey message. Also converts values to other types if specified.
             * @param message PendingPreKey
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SessionStructure.PendingPreKey, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PendingPreKey to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }
    }

    /** Properties of a SignalMessage. */
    interface ISignalMessage {

        /** SignalMessage ratchetKey */
        ratchetKey?: (Uint8Array|null);

        /** SignalMessage counter */
        counter?: (number|null);

        /** SignalMessage previousCounter */
        previousCounter?: (number|null);

        /** SignalMessage ciphertext */
        ciphertext?: (Uint8Array|null);
    }

    /** Represents a SignalMessage. */
    class SignalMessage implements ISignalMessage {

        /**
         * Constructs a new SignalMessage.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISignalMessage);

        /** SignalMessage ratchetKey. */
        public ratchetKey: Uint8Array;

        /** SignalMessage counter. */
        public counter: number;

        /** SignalMessage previousCounter. */
        public previousCounter: number;

        /** SignalMessage ciphertext. */
        public ciphertext: Uint8Array;

        /**
         * Creates a new SignalMessage instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SignalMessage instance
         */
        public static create(properties?: proto.ISignalMessage): proto.SignalMessage;

        /**
         * Encodes the specified SignalMessage message. Does not implicitly {@link proto.SignalMessage.verify|verify} messages.
         * @param message SignalMessage message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISignalMessage, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SignalMessage message, length delimited. Does not implicitly {@link proto.SignalMessage.verify|verify} messages.
         * @param message SignalMessage message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISignalMessage, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SignalMessage message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SignalMessage
         * @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): proto.SignalMessage;

        /**
         * Decodes a SignalMessage message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SignalMessage
         * @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)): proto.SignalMessage;

        /**
         * Verifies a SignalMessage 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 SignalMessage message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SignalMessage
         */
        public static fromObject(object: { [k: string]: any }): proto.SignalMessage;

        /**
         * Creates a plain object from a SignalMessage message. Also converts values to other types if specified.
         * @param message SignalMessage
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SignalMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SignalMessage to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SignedPreKeyRecordStructure. */
    interface ISignedPreKeyRecordStructure {

        /** SignedPreKeyRecordStructure id */
        id?: (number|null);

        /** SignedPreKeyRecordStructure publicKey */
        publicKey?: (Uint8Array|null);

        /** SignedPreKeyRecordStructure privateKey */
        privateKey?: (Uint8Array|null);

        /** SignedPreKeyRecordStructure signature */
        signature?: (Uint8Array|null);

        /** SignedPreKeyRecordStructure timestamp */
        timestamp?: (number|Long|null);
    }

    /** Represents a SignedPreKeyRecordStructure. */
    class SignedPreKeyRecordStructure implements ISignedPreKeyRecordStructure {

        /**
         * Constructs a new SignedPreKeyRecordStructure.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISignedPreKeyRecordStructure);

        /** SignedPreKeyRecordStructure id. */
        public id: number;

        /** SignedPreKeyRecordStructure publicKey. */
        public publicKey: Uint8Array;

        /** SignedPreKeyRecordStructure privateKey. */
        public privateKey: Uint8Array;

        /** SignedPreKeyRecordStructure signature. */
        public signature: Uint8Array;

        /** SignedPreKeyRecordStructure timestamp. */
        public timestamp: (number|Long);

        /**
         * Creates a new SignedPreKeyRecordStructure instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SignedPreKeyRecordStructure instance
         */
        public static create(properties?: proto.ISignedPreKeyRecordStructure): proto.SignedPreKeyRecordStructure;

        /**
         * Encodes the specified SignedPreKeyRecordStructure message. Does not implicitly {@link proto.SignedPreKeyRecordStructure.verify|verify} messages.
         * @param message SignedPreKeyRecordStructure message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISignedPreKeyRecordStructure, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SignedPreKeyRecordStructure message, length delimited. Does not implicitly {@link proto.SignedPreKeyRecordStructure.verify|verify} messages.
         * @param message SignedPreKeyRecordStructure message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISignedPreKeyRecordStructure, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SignedPreKeyRecordStructure message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SignedPreKeyRecordStructure
         * @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): proto.SignedPreKeyRecordStructure;

        /**
         * Decodes a SignedPreKeyRecordStructure message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SignedPreKeyRecordStructure
         * @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)): proto.SignedPreKeyRecordStructure;

        /**
         * Verifies a SignedPreKeyRecordStructure 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 SignedPreKeyRecordStructure message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SignedPreKeyRecordStructure
         */
        public static fromObject(object: { [k: string]: any }): proto.SignedPreKeyRecordStructure;

        /**
         * Creates a plain object from a SignedPreKeyRecordStructure message. Also converts values to other types if specified.
         * @param message SignedPreKeyRecordStructure
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SignedPreKeyRecordStructure, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SignedPreKeyRecordStructure to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a StatusPSA. */
    interface IStatusPSA {

        /** StatusPSA campaignId */
        campaignId: (number|Long);

        /** StatusPSA campaignExpirationTimestamp */
        campaignExpirationTimestamp?: (number|Long|null);
    }

    /** Represents a StatusPSA. */
    class StatusPSA implements IStatusPSA {

        /**
         * Constructs a new StatusPSA.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IStatusPSA);

        /** StatusPSA campaignId. */
        public campaignId: (number|Long);

        /** StatusPSA campaignExpirationTimestamp. */
        public campaignExpirationTimestamp: (number|Long);

        /**
         * Creates a new StatusPSA instance using the specified properties.
         * @param [properties] Properties to set
         * @returns StatusPSA instance
         */
        public static create(properties?: proto.IStatusPSA): proto.StatusPSA;

        /**
         * Encodes the specified StatusPSA message. Does not implicitly {@link proto.StatusPSA.verify|verify} messages.
         * @param message StatusPSA message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IStatusPSA, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified StatusPSA message, length delimited. Does not implicitly {@link proto.StatusPSA.verify|verify} messages.
         * @param message StatusPSA message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IStatusPSA, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a StatusPSA message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns StatusPSA
         * @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): proto.StatusPSA;

        /**
         * Decodes a StatusPSA message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns StatusPSA
         * @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)): proto.StatusPSA;

        /**
         * Verifies a StatusPSA 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 StatusPSA message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns StatusPSA
         */
        public static fromObject(object: { [k: string]: any }): proto.StatusPSA;

        /**
         * Creates a plain object from a StatusPSA message. Also converts values to other types if specified.
         * @param message StatusPSA
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.StatusPSA, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this StatusPSA to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a StickerMetadata. */
    interface IStickerMetadata {

        /** StickerMetadata url */
        url?: (string|null);

        /** StickerMetadata fileSha256 */
        fileSha256?: (Uint8Array|null);

        /** StickerMetadata fileEncSha256 */
        fileEncSha256?: (Uint8Array|null);

        /** StickerMetadata mediaKey */
        mediaKey?: (Uint8Array|null);

        /** StickerMetadata mimetype */
        mimetype?: (string|null);

        /** StickerMetadata height */
        height?: (number|null);

        /** StickerMetadata width */
        width?: (number|null);

        /** StickerMetadata directPath */
        directPath?: (string|null);

        /** StickerMetadata fileLength */
        fileLength?: (number|Long|null);

        /** StickerMetadata weight */
        weight?: (number|null);

        /** StickerMetadata lastStickerSentTs */
        lastStickerSentTs?: (number|Long|null);
    }

    /** Represents a StickerMetadata. */
    class StickerMetadata implements IStickerMetadata {

        /**
         * Constructs a new StickerMetadata.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IStickerMetadata);

        /** StickerMetadata url. */
        public url: string;

        /** StickerMetadata fileSha256. */
        public fileSha256: Uint8Array;

        /** StickerMetadata fileEncSha256. */
        public fileEncSha256: Uint8Array;

        /** StickerMetadata mediaKey. */
        public mediaKey: Uint8Array;

        /** StickerMetadata mimetype. */
        public mimetype: string;

        /** StickerMetadata height. */
        public height: number;

        /** StickerMetadata width. */
        public width: number;

        /** StickerMetadata directPath. */
        public directPath: string;

        /** StickerMetadata fileLength. */
        public fileLength: (number|Long);

        /** StickerMetadata weight. */
        public weight: number;

        /** StickerMetadata lastStickerSentTs. */
        public lastStickerSentTs: (number|Long);

        /**
         * Creates a new StickerMetadata instance using the specified properties.
         * @param [properties] Properties to set
         * @returns StickerMetadata instance
         */
        public static create(properties?: proto.IStickerMetadata): proto.StickerMetadata;

        /**
         * Encodes the specified StickerMetadata message. Does not implicitly {@link proto.StickerMetadata.verify|verify} messages.
         * @param message StickerMetadata message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IStickerMetadata, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified StickerMetadata message, length delimited. Does not implicitly {@link proto.StickerMetadata.verify|verify} messages.
         * @param message StickerMetadata message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IStickerMetadata, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a StickerMetadata message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns StickerMetadata
         * @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): proto.StickerMetadata;

        /**
         * Decodes a StickerMetadata message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns StickerMetadata
         * @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)): proto.StickerMetadata;

        /**
         * Verifies a StickerMetadata 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 StickerMetadata message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns StickerMetadata
         */
        public static fromObject(object: { [k: string]: any }): proto.StickerMetadata;

        /**
         * Creates a plain object from a StickerMetadata message. Also converts values to other types if specified.
         * @param message StickerMetadata
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.StickerMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this StickerMetadata to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SyncActionData. */
    interface ISyncActionData {

        /** SyncActionData index */
        index?: (Uint8Array|null);

        /** SyncActionData value */
        value?: (proto.ISyncActionValue|null);

        /** SyncActionData padding */
        padding?: (Uint8Array|null);

        /** SyncActionData version */
        version?: (number|null);
    }

    /** Represents a SyncActionData. */
    class SyncActionData implements ISyncActionData {

        /**
         * Constructs a new SyncActionData.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISyncActionData);

        /** SyncActionData index. */
        public index: Uint8Array;

        /** SyncActionData value. */
        public value?: (proto.ISyncActionValue|null);

        /** SyncActionData padding. */
        public padding: Uint8Array;

        /** SyncActionData version. */
        public version: number;

        /**
         * Creates a new SyncActionData instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SyncActionData instance
         */
        public static create(properties?: proto.ISyncActionData): proto.SyncActionData;

        /**
         * Encodes the specified SyncActionData message. Does not implicitly {@link proto.SyncActionData.verify|verify} messages.
         * @param message SyncActionData message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISyncActionData, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SyncActionData message, length delimited. Does not implicitly {@link proto.SyncActionData.verify|verify} messages.
         * @param message SyncActionData message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISyncActionData, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SyncActionData message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SyncActionData
         * @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): proto.SyncActionData;

        /**
         * Decodes a SyncActionData message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SyncActionData
         * @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)): proto.SyncActionData;

        /**
         * Verifies a SyncActionData 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 SyncActionData message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SyncActionData
         */
        public static fromObject(object: { [k: string]: any }): proto.SyncActionData;

        /**
         * Creates a plain object from a SyncActionData message. Also converts values to other types if specified.
         * @param message SyncActionData
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SyncActionData, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SyncActionData to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SyncActionValue. */
    interface ISyncActionValue {

        /** SyncActionValue timestamp */
        timestamp?: (number|Long|null);

        /** SyncActionValue starAction */
        starAction?: (proto.SyncActionValue.IStarAction|null);

        /** SyncActionValue contactAction */
        contactAction?: (proto.SyncActionValue.IContactAction|null);

        /** SyncActionValue muteAction */
        muteAction?: (proto.SyncActionValue.IMuteAction|null);

        /** SyncActionValue pinAction */
        pinAction?: (proto.SyncActionValue.IPinAction|null);

        /** SyncActionValue securityNotificationSetting */
        securityNotificationSetting?: (proto.SyncActionValue.ISecurityNotificationSetting|null);

        /** SyncActionValue pushNameSetting */
        pushNameSetting?: (proto.SyncActionValue.IPushNameSetting|null);

        /** SyncActionValue quickReplyAction */
        quickReplyAction?: (proto.SyncActionValue.IQuickReplyAction|null);

        /** SyncActionValue recentEmojiWeightsAction */
        recentEmojiWeightsAction?: (proto.SyncActionValue.IRecentEmojiWeightsAction|null);

        /** SyncActionValue labelEditAction */
        labelEditAction?: (proto.SyncActionValue.ILabelEditAction|null);

        /** SyncActionValue labelAssociationAction */
        labelAssociationAction?: (proto.SyncActionValue.ILabelAssociationAction|null);

        /** SyncActionValue localeSetting */
        localeSetting?: (proto.SyncActionValue.ILocaleSetting|null);

        /** SyncActionValue archiveChatAction */
        archiveChatAction?: (proto.SyncActionValue.IArchiveChatAction|null);

        /** SyncActionValue deleteMessageForMeAction */
        deleteMessageForMeAction?: (proto.SyncActionValue.IDeleteMessageForMeAction|null);

        /** SyncActionValue keyExpiration */
        keyExpiration?: (proto.SyncActionValue.IKeyExpiration|null);

        /** SyncActionValue markChatAsReadAction */
        markChatAsReadAction?: (proto.SyncActionValue.IMarkChatAsReadAction|null);

        /** SyncActionValue clearChatAction */
        clearChatAction?: (proto.SyncActionValue.IClearChatAction|null);

        /** SyncActionValue deleteChatAction */
        deleteChatAction?: (proto.SyncActionValue.IDeleteChatAction|null);

        /** SyncActionValue unarchiveChatsSetting */
        unarchiveChatsSetting?: (proto.SyncActionValue.IUnarchiveChatsSetting|null);

        /** SyncActionValue primaryFeature */
        primaryFeature?: (proto.SyncActionValue.IPrimaryFeature|null);

        /** SyncActionValue androidUnsupportedActions */
        androidUnsupportedActions?: (proto.SyncActionValue.IAndroidUnsupportedActions|null);

        /** SyncActionValue agentAction */
        agentAction?: (proto.SyncActionValue.IAgentAction|null);

        /** SyncActionValue subscriptionAction */
        subscriptionAction?: (proto.SyncActionValue.ISubscriptionAction|null);

        /** SyncActionValue userStatusMuteAction */
        userStatusMuteAction?: (proto.SyncActionValue.IUserStatusMuteAction|null);

        /** SyncActionValue timeFormatAction */
        timeFormatAction?: (proto.SyncActionValue.ITimeFormatAction|null);

        /** SyncActionValue nuxAction */
        nuxAction?: (proto.SyncActionValue.INuxAction|null);

        /** SyncActionValue primaryVersionAction */
        primaryVersionAction?: (proto.SyncActionValue.IPrimaryVersionAction|null);

        /** SyncActionValue stickerAction */
        stickerAction?: (proto.SyncActionValue.IStickerAction|null);

        /** SyncActionValue removeRecentStickerAction */
        removeRecentStickerAction?: (proto.SyncActionValue.IRemoveRecentStickerAction|null);

        /** SyncActionValue chatAssignment */
        chatAssignment?: (proto.SyncActionValue.IChatAssignmentAction|null);

        /** SyncActionValue chatAssignmentOpenedStatus */
        chatAssignmentOpenedStatus?: (proto.SyncActionValue.IChatAssignmentOpenedStatusAction|null);

        /** SyncActionValue pnForLidChatAction */
        pnForLidChatAction?: (proto.SyncActionValue.IPnForLidChatAction|null);

        /** SyncActionValue marketingMessageAction */
        marketingMessageAction?: (proto.SyncActionValue.IMarketingMessageAction|null);

        /** SyncActionValue marketingMessageBroadcastAction */
        marketingMessageBroadcastAction?: (proto.SyncActionValue.IMarketingMessageBroadcastAction|null);

        /** SyncActionValue externalWebBetaAction */
        externalWebBetaAction?: (proto.SyncActionValue.IExternalWebBetaAction|null);

        /** SyncActionValue privacySettingRelayAllCalls */
        privacySettingRelayAllCalls?: (proto.SyncActionValue.IPrivacySettingRelayAllCalls|null);

        /** SyncActionValue callLogAction */
        callLogAction?: (proto.SyncActionValue.ICallLogAction|null);

        /** SyncActionValue statusPrivacy */
        statusPrivacy?: (proto.SyncActionValue.IStatusPrivacyAction|null);

        /** SyncActionValue botWelcomeRequestAction */
        botWelcomeRequestAction?: (proto.SyncActionValue.IBotWelcomeRequestAction|null);

        /** SyncActionValue deleteIndividualCallLog */
        deleteIndividualCallLog?: (proto.SyncActionValue.IDeleteIndividualCallLogAction|null);

        /** SyncActionValue labelReorderingAction */
        labelReorderingAction?: (proto.SyncActionValue.ILabelReorderingAction|null);

        /** SyncActionValue paymentInfoAction */
        paymentInfoAction?: (proto.SyncActionValue.IPaymentInfoAction|null);

        /** SyncActionValue customPaymentMethodsAction */
        customPaymentMethodsAction?: (proto.SyncActionValue.ICustomPaymentMethodsAction|null);
    }

    /** Represents a SyncActionValue. */
    class SyncActionValue implements ISyncActionValue {

        /**
         * Constructs a new SyncActionValue.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISyncActionValue);

        /** SyncActionValue timestamp. */
        public timestamp: (number|Long);

        /** SyncActionValue starAction. */
        public starAction?: (proto.SyncActionValue.IStarAction|null);

        /** SyncActionValue contactAction. */
        public contactAction?: (proto.SyncActionValue.IContactAction|null);

        /** SyncActionValue muteAction. */
        public muteAction?: (proto.SyncActionValue.IMuteAction|null);

        /** SyncActionValue pinAction. */
        public pinAction?: (proto.SyncActionValue.IPinAction|null);

        /** SyncActionValue securityNotificationSetting. */
        public securityNotificationSetting?: (proto.SyncActionValue.ISecurityNotificationSetting|null);

        /** SyncActionValue pushNameSetting. */
        public pushNameSetting?: (proto.SyncActionValue.IPushNameSetting|null);

        /** SyncActionValue quickReplyAction. */
        public quickReplyAction?: (proto.SyncActionValue.IQuickReplyAction|null);

        /** SyncActionValue recentEmojiWeightsAction. */
        public recentEmojiWeightsAction?: (proto.SyncActionValue.IRecentEmojiWeightsAction|null);

        /** SyncActionValue labelEditAction. */
        public labelEditAction?: (proto.SyncActionValue.ILabelEditAction|null);

        /** SyncActionValue labelAssociationAction. */
        public labelAssociationAction?: (proto.SyncActionValue.ILabelAssociationAction|null);

        /** SyncActionValue localeSetting. */
        public localeSetting?: (proto.SyncActionValue.ILocaleSetting|null);

        /** SyncActionValue archiveChatAction. */
        public archiveChatAction?: (proto.SyncActionValue.IArchiveChatAction|null);

        /** SyncActionValue deleteMessageForMeAction. */
        public deleteMessageForMeAction?: (proto.SyncActionValue.IDeleteMessageForMeAction|null);

        /** SyncActionValue keyExpiration. */
        public keyExpiration?: (proto.SyncActionValue.IKeyExpiration|null);

        /** SyncActionValue markChatAsReadAction. */
        public markChatAsReadAction?: (proto.SyncActionValue.IMarkChatAsReadAction|null);

        /** SyncActionValue clearChatAction. */
        public clearChatAction?: (proto.SyncActionValue.IClearChatAction|null);

        /** SyncActionValue deleteChatAction. */
        public deleteChatAction?: (proto.SyncActionValue.IDeleteChatAction|null);

        /** SyncActionValue unarchiveChatsSetting. */
        public unarchiveChatsSetting?: (proto.SyncActionValue.IUnarchiveChatsSetting|null);

        /** SyncActionValue primaryFeature. */
        public primaryFeature?: (proto.SyncActionValue.IPrimaryFeature|null);

        /** SyncActionValue androidUnsupportedActions. */
        public androidUnsupportedActions?: (proto.SyncActionValue.IAndroidUnsupportedActions|null);

        /** SyncActionValue agentAction. */
        public agentAction?: (proto.SyncActionValue.IAgentAction|null);

        /** SyncActionValue subscriptionAction. */
        public subscriptionAction?: (proto.SyncActionValue.ISubscriptionAction|null);

        /** SyncActionValue userStatusMuteAction. */
        public userStatusMuteAction?: (proto.SyncActionValue.IUserStatusMuteAction|null);

        /** SyncActionValue timeFormatAction. */
        public timeFormatAction?: (proto.SyncActionValue.ITimeFormatAction|null);

        /** SyncActionValue nuxAction. */
        public nuxAction?: (proto.SyncActionValue.INuxAction|null);

        /** SyncActionValue primaryVersionAction. */
        public primaryVersionAction?: (proto.SyncActionValue.IPrimaryVersionAction|null);

        /** SyncActionValue stickerAction. */
        public stickerAction?: (proto.SyncActionValue.IStickerAction|null);

        /** SyncActionValue removeRecentStickerAction. */
        public removeRecentStickerAction?: (proto.SyncActionValue.IRemoveRecentStickerAction|null);

        /** SyncActionValue chatAssignment. */
        public chatAssignment?: (proto.SyncActionValue.IChatAssignmentAction|null);

        /** SyncActionValue chatAssignmentOpenedStatus. */
        public chatAssignmentOpenedStatus?: (proto.SyncActionValue.IChatAssignmentOpenedStatusAction|null);

        /** SyncActionValue pnForLidChatAction. */
        public pnForLidChatAction?: (proto.SyncActionValue.IPnForLidChatAction|null);

        /** SyncActionValue marketingMessageAction. */
        public marketingMessageAction?: (proto.SyncActionValue.IMarketingMessageAction|null);

        /** SyncActionValue marketingMessageBroadcastAction. */
        public marketingMessageBroadcastAction?: (proto.SyncActionValue.IMarketingMessageBroadcastAction|null);

        /** SyncActionValue externalWebBetaAction. */
        public externalWebBetaAction?: (proto.SyncActionValue.IExternalWebBetaAction|null);

        /** SyncActionValue privacySettingRelayAllCalls. */
        public privacySettingRelayAllCalls?: (proto.SyncActionValue.IPrivacySettingRelayAllCalls|null);

        /** SyncActionValue callLogAction. */
        public callLogAction?: (proto.SyncActionValue.ICallLogAction|null);

        /** SyncActionValue statusPrivacy. */
        public statusPrivacy?: (proto.SyncActionValue.IStatusPrivacyAction|null);

        /** SyncActionValue botWelcomeRequestAction. */
        public botWelcomeRequestAction?: (proto.SyncActionValue.IBotWelcomeRequestAction|null);

        /** SyncActionValue deleteIndividualCallLog. */
        public deleteIndividualCallLog?: (proto.SyncActionValue.IDeleteIndividualCallLogAction|null);

        /** SyncActionValue labelReorderingAction. */
        public labelReorderingAction?: (proto.SyncActionValue.ILabelReorderingAction|null);

        /** SyncActionValue paymentInfoAction. */
        public paymentInfoAction?: (proto.SyncActionValue.IPaymentInfoAction|null);

        /** SyncActionValue customPaymentMethodsAction. */
        public customPaymentMethodsAction?: (proto.SyncActionValue.ICustomPaymentMethodsAction|null);

        /**
         * Creates a new SyncActionValue instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SyncActionValue instance
         */
        public static create(properties?: proto.ISyncActionValue): proto.SyncActionValue;

        /**
         * Encodes the specified SyncActionValue message. Does not implicitly {@link proto.SyncActionValue.verify|verify} messages.
         * @param message SyncActionValue message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISyncActionValue, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SyncActionValue message, length delimited. Does not implicitly {@link proto.SyncActionValue.verify|verify} messages.
         * @param message SyncActionValue message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISyncActionValue, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SyncActionValue message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SyncActionValue
         * @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): proto.SyncActionValue;

        /**
         * Decodes a SyncActionValue message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SyncActionValue
         * @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)): proto.SyncActionValue;

        /**
         * Verifies a SyncActionValue 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 SyncActionValue message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SyncActionValue
         */
        public static fromObject(object: { [k: string]: any }): proto.SyncActionValue;

        /**
         * Creates a plain object from a SyncActionValue message. Also converts values to other types if specified.
         * @param message SyncActionValue
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SyncActionValue, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SyncActionValue to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace SyncActionValue {

        /** Properties of an AgentAction. */
        interface IAgentAction {

            /** AgentAction name */
            name?: (string|null);

            /** AgentAction deviceID */
            deviceID?: (number|null);

            /** AgentAction isDeleted */
            isDeleted?: (boolean|null);
        }

        /** Represents an AgentAction. */
        class AgentAction implements IAgentAction {

            /**
             * Constructs a new AgentAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IAgentAction);

            /** AgentAction name. */
            public name: string;

            /** AgentAction deviceID. */
            public deviceID: number;

            /** AgentAction isDeleted. */
            public isDeleted: boolean;

            /**
             * Creates a new AgentAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns AgentAction instance
             */
            public static create(properties?: proto.SyncActionValue.IAgentAction): proto.SyncActionValue.AgentAction;

            /**
             * Encodes the specified AgentAction message. Does not implicitly {@link proto.SyncActionValue.AgentAction.verify|verify} messages.
             * @param message AgentAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IAgentAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified AgentAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.AgentAction.verify|verify} messages.
             * @param message AgentAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IAgentAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an AgentAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns AgentAction
             * @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): proto.SyncActionValue.AgentAction;

            /**
             * Decodes an AgentAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns AgentAction
             * @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)): proto.SyncActionValue.AgentAction;

            /**
             * Verifies an AgentAction 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 AgentAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns AgentAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.AgentAction;

            /**
             * Creates a plain object from an AgentAction message. Also converts values to other types if specified.
             * @param message AgentAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.AgentAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this AgentAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an AndroidUnsupportedActions. */
        interface IAndroidUnsupportedActions {

            /** AndroidUnsupportedActions allowed */
            allowed?: (boolean|null);
        }

        /** Represents an AndroidUnsupportedActions. */
        class AndroidUnsupportedActions implements IAndroidUnsupportedActions {

            /**
             * Constructs a new AndroidUnsupportedActions.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IAndroidUnsupportedActions);

            /** AndroidUnsupportedActions allowed. */
            public allowed: boolean;

            /**
             * Creates a new AndroidUnsupportedActions instance using the specified properties.
             * @param [properties] Properties to set
             * @returns AndroidUnsupportedActions instance
             */
            public static create(properties?: proto.SyncActionValue.IAndroidUnsupportedActions): proto.SyncActionValue.AndroidUnsupportedActions;

            /**
             * Encodes the specified AndroidUnsupportedActions message. Does not implicitly {@link proto.SyncActionValue.AndroidUnsupportedActions.verify|verify} messages.
             * @param message AndroidUnsupportedActions message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IAndroidUnsupportedActions, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified AndroidUnsupportedActions message, length delimited. Does not implicitly {@link proto.SyncActionValue.AndroidUnsupportedActions.verify|verify} messages.
             * @param message AndroidUnsupportedActions message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IAndroidUnsupportedActions, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an AndroidUnsupportedActions message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns AndroidUnsupportedActions
             * @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): proto.SyncActionValue.AndroidUnsupportedActions;

            /**
             * Decodes an AndroidUnsupportedActions message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns AndroidUnsupportedActions
             * @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)): proto.SyncActionValue.AndroidUnsupportedActions;

            /**
             * Verifies an AndroidUnsupportedActions 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 AndroidUnsupportedActions message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns AndroidUnsupportedActions
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.AndroidUnsupportedActions;

            /**
             * Creates a plain object from an AndroidUnsupportedActions message. Also converts values to other types if specified.
             * @param message AndroidUnsupportedActions
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.AndroidUnsupportedActions, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this AndroidUnsupportedActions to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an ArchiveChatAction. */
        interface IArchiveChatAction {

            /** ArchiveChatAction archived */
            archived?: (boolean|null);

            /** ArchiveChatAction messageRange */
            messageRange?: (proto.SyncActionValue.ISyncActionMessageRange|null);
        }

        /** Represents an ArchiveChatAction. */
        class ArchiveChatAction implements IArchiveChatAction {

            /**
             * Constructs a new ArchiveChatAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IArchiveChatAction);

            /** ArchiveChatAction archived. */
            public archived: boolean;

            /** ArchiveChatAction messageRange. */
            public messageRange?: (proto.SyncActionValue.ISyncActionMessageRange|null);

            /**
             * Creates a new ArchiveChatAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ArchiveChatAction instance
             */
            public static create(properties?: proto.SyncActionValue.IArchiveChatAction): proto.SyncActionValue.ArchiveChatAction;

            /**
             * Encodes the specified ArchiveChatAction message. Does not implicitly {@link proto.SyncActionValue.ArchiveChatAction.verify|verify} messages.
             * @param message ArchiveChatAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IArchiveChatAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ArchiveChatAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.ArchiveChatAction.verify|verify} messages.
             * @param message ArchiveChatAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IArchiveChatAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an ArchiveChatAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ArchiveChatAction
             * @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): proto.SyncActionValue.ArchiveChatAction;

            /**
             * Decodes an ArchiveChatAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ArchiveChatAction
             * @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)): proto.SyncActionValue.ArchiveChatAction;

            /**
             * Verifies an ArchiveChatAction 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 ArchiveChatAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ArchiveChatAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.ArchiveChatAction;

            /**
             * Creates a plain object from an ArchiveChatAction message. Also converts values to other types if specified.
             * @param message ArchiveChatAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.ArchiveChatAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ArchiveChatAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a BotWelcomeRequestAction. */
        interface IBotWelcomeRequestAction {

            /** BotWelcomeRequestAction isSent */
            isSent?: (boolean|null);
        }

        /** Represents a BotWelcomeRequestAction. */
        class BotWelcomeRequestAction implements IBotWelcomeRequestAction {

            /**
             * Constructs a new BotWelcomeRequestAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IBotWelcomeRequestAction);

            /** BotWelcomeRequestAction isSent. */
            public isSent: boolean;

            /**
             * Creates a new BotWelcomeRequestAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns BotWelcomeRequestAction instance
             */
            public static create(properties?: proto.SyncActionValue.IBotWelcomeRequestAction): proto.SyncActionValue.BotWelcomeRequestAction;

            /**
             * Encodes the specified BotWelcomeRequestAction message. Does not implicitly {@link proto.SyncActionValue.BotWelcomeRequestAction.verify|verify} messages.
             * @param message BotWelcomeRequestAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IBotWelcomeRequestAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified BotWelcomeRequestAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.BotWelcomeRequestAction.verify|verify} messages.
             * @param message BotWelcomeRequestAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IBotWelcomeRequestAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a BotWelcomeRequestAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns BotWelcomeRequestAction
             * @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): proto.SyncActionValue.BotWelcomeRequestAction;

            /**
             * Decodes a BotWelcomeRequestAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns BotWelcomeRequestAction
             * @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)): proto.SyncActionValue.BotWelcomeRequestAction;

            /**
             * Verifies a BotWelcomeRequestAction 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 BotWelcomeRequestAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns BotWelcomeRequestAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.BotWelcomeRequestAction;

            /**
             * Creates a plain object from a BotWelcomeRequestAction message. Also converts values to other types if specified.
             * @param message BotWelcomeRequestAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.BotWelcomeRequestAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this BotWelcomeRequestAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a CallLogAction. */
        interface ICallLogAction {

            /** CallLogAction callLogRecord */
            callLogRecord?: (proto.ICallLogRecord|null);
        }

        /** Represents a CallLogAction. */
        class CallLogAction implements ICallLogAction {

            /**
             * Constructs a new CallLogAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ICallLogAction);

            /** CallLogAction callLogRecord. */
            public callLogRecord?: (proto.ICallLogRecord|null);

            /**
             * Creates a new CallLogAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns CallLogAction instance
             */
            public static create(properties?: proto.SyncActionValue.ICallLogAction): proto.SyncActionValue.CallLogAction;

            /**
             * Encodes the specified CallLogAction message. Does not implicitly {@link proto.SyncActionValue.CallLogAction.verify|verify} messages.
             * @param message CallLogAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ICallLogAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified CallLogAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.CallLogAction.verify|verify} messages.
             * @param message CallLogAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ICallLogAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a CallLogAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns CallLogAction
             * @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): proto.SyncActionValue.CallLogAction;

            /**
             * Decodes a CallLogAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns CallLogAction
             * @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)): proto.SyncActionValue.CallLogAction;

            /**
             * Verifies a CallLogAction 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 CallLogAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns CallLogAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.CallLogAction;

            /**
             * Creates a plain object from a CallLogAction message. Also converts values to other types if specified.
             * @param message CallLogAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.CallLogAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this CallLogAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a ChatAssignmentAction. */
        interface IChatAssignmentAction {

            /** ChatAssignmentAction deviceAgentID */
            deviceAgentID?: (string|null);
        }

        /** Represents a ChatAssignmentAction. */
        class ChatAssignmentAction implements IChatAssignmentAction {

            /**
             * Constructs a new ChatAssignmentAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IChatAssignmentAction);

            /** ChatAssignmentAction deviceAgentID. */
            public deviceAgentID: string;

            /**
             * Creates a new ChatAssignmentAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ChatAssignmentAction instance
             */
            public static create(properties?: proto.SyncActionValue.IChatAssignmentAction): proto.SyncActionValue.ChatAssignmentAction;

            /**
             * Encodes the specified ChatAssignmentAction message. Does not implicitly {@link proto.SyncActionValue.ChatAssignmentAction.verify|verify} messages.
             * @param message ChatAssignmentAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IChatAssignmentAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ChatAssignmentAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.ChatAssignmentAction.verify|verify} messages.
             * @param message ChatAssignmentAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IChatAssignmentAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ChatAssignmentAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ChatAssignmentAction
             * @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): proto.SyncActionValue.ChatAssignmentAction;

            /**
             * Decodes a ChatAssignmentAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ChatAssignmentAction
             * @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)): proto.SyncActionValue.ChatAssignmentAction;

            /**
             * Verifies a ChatAssignmentAction 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 ChatAssignmentAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ChatAssignmentAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.ChatAssignmentAction;

            /**
             * Creates a plain object from a ChatAssignmentAction message. Also converts values to other types if specified.
             * @param message ChatAssignmentAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.ChatAssignmentAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ChatAssignmentAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a ChatAssignmentOpenedStatusAction. */
        interface IChatAssignmentOpenedStatusAction {

            /** ChatAssignmentOpenedStatusAction chatOpened */
            chatOpened?: (boolean|null);
        }

        /** Represents a ChatAssignmentOpenedStatusAction. */
        class ChatAssignmentOpenedStatusAction implements IChatAssignmentOpenedStatusAction {

            /**
             * Constructs a new ChatAssignmentOpenedStatusAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IChatAssignmentOpenedStatusAction);

            /** ChatAssignmentOpenedStatusAction chatOpened. */
            public chatOpened: boolean;

            /**
             * Creates a new ChatAssignmentOpenedStatusAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ChatAssignmentOpenedStatusAction instance
             */
            public static create(properties?: proto.SyncActionValue.IChatAssignmentOpenedStatusAction): proto.SyncActionValue.ChatAssignmentOpenedStatusAction;

            /**
             * Encodes the specified ChatAssignmentOpenedStatusAction message. Does not implicitly {@link proto.SyncActionValue.ChatAssignmentOpenedStatusAction.verify|verify} messages.
             * @param message ChatAssignmentOpenedStatusAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IChatAssignmentOpenedStatusAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ChatAssignmentOpenedStatusAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.ChatAssignmentOpenedStatusAction.verify|verify} messages.
             * @param message ChatAssignmentOpenedStatusAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IChatAssignmentOpenedStatusAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ChatAssignmentOpenedStatusAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ChatAssignmentOpenedStatusAction
             * @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): proto.SyncActionValue.ChatAssignmentOpenedStatusAction;

            /**
             * Decodes a ChatAssignmentOpenedStatusAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ChatAssignmentOpenedStatusAction
             * @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)): proto.SyncActionValue.ChatAssignmentOpenedStatusAction;

            /**
             * Verifies a ChatAssignmentOpenedStatusAction 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 ChatAssignmentOpenedStatusAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ChatAssignmentOpenedStatusAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.ChatAssignmentOpenedStatusAction;

            /**
             * Creates a plain object from a ChatAssignmentOpenedStatusAction message. Also converts values to other types if specified.
             * @param message ChatAssignmentOpenedStatusAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.ChatAssignmentOpenedStatusAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ChatAssignmentOpenedStatusAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a ClearChatAction. */
        interface IClearChatAction {

            /** ClearChatAction messageRange */
            messageRange?: (proto.SyncActionValue.ISyncActionMessageRange|null);
        }

        /** Represents a ClearChatAction. */
        class ClearChatAction implements IClearChatAction {

            /**
             * Constructs a new ClearChatAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IClearChatAction);

            /** ClearChatAction messageRange. */
            public messageRange?: (proto.SyncActionValue.ISyncActionMessageRange|null);

            /**
             * Creates a new ClearChatAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ClearChatAction instance
             */
            public static create(properties?: proto.SyncActionValue.IClearChatAction): proto.SyncActionValue.ClearChatAction;

            /**
             * Encodes the specified ClearChatAction message. Does not implicitly {@link proto.SyncActionValue.ClearChatAction.verify|verify} messages.
             * @param message ClearChatAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IClearChatAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ClearChatAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.ClearChatAction.verify|verify} messages.
             * @param message ClearChatAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IClearChatAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ClearChatAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ClearChatAction
             * @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): proto.SyncActionValue.ClearChatAction;

            /**
             * Decodes a ClearChatAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ClearChatAction
             * @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)): proto.SyncActionValue.ClearChatAction;

            /**
             * Verifies a ClearChatAction 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 ClearChatAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ClearChatAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.ClearChatAction;

            /**
             * Creates a plain object from a ClearChatAction message. Also converts values to other types if specified.
             * @param message ClearChatAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.ClearChatAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ClearChatAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a ContactAction. */
        interface IContactAction {

            /** ContactAction fullName */
            fullName?: (string|null);

            /** ContactAction firstName */
            firstName?: (string|null);

            /** ContactAction lidJid */
            lidJid?: (string|null);

            /** ContactAction saveOnPrimaryAddressbook */
            saveOnPrimaryAddressbook?: (boolean|null);
        }

        /** Represents a ContactAction. */
        class ContactAction implements IContactAction {

            /**
             * Constructs a new ContactAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IContactAction);

            /** ContactAction fullName. */
            public fullName: string;

            /** ContactAction firstName. */
            public firstName: string;

            /** ContactAction lidJid. */
            public lidJid: string;

            /** ContactAction saveOnPrimaryAddressbook. */
            public saveOnPrimaryAddressbook: boolean;

            /**
             * Creates a new ContactAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ContactAction instance
             */
            public static create(properties?: proto.SyncActionValue.IContactAction): proto.SyncActionValue.ContactAction;

            /**
             * Encodes the specified ContactAction message. Does not implicitly {@link proto.SyncActionValue.ContactAction.verify|verify} messages.
             * @param message ContactAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IContactAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ContactAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.ContactAction.verify|verify} messages.
             * @param message ContactAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IContactAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a ContactAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ContactAction
             * @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): proto.SyncActionValue.ContactAction;

            /**
             * Decodes a ContactAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ContactAction
             * @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)): proto.SyncActionValue.ContactAction;

            /**
             * Verifies a ContactAction 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 ContactAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ContactAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.ContactAction;

            /**
             * Creates a plain object from a ContactAction message. Also converts values to other types if specified.
             * @param message ContactAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.ContactAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ContactAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a CustomPaymentMethod. */
        interface ICustomPaymentMethod {

            /** CustomPaymentMethod credentialId */
            credentialId: string;

            /** CustomPaymentMethod country */
            country: string;

            /** CustomPaymentMethod type */
            type: string;

            /** CustomPaymentMethod metadata */
            metadata?: (proto.SyncActionValue.ICustomPaymentMethodMetadata[]|null);
        }

        /** Represents a CustomPaymentMethod. */
        class CustomPaymentMethod implements ICustomPaymentMethod {

            /**
             * Constructs a new CustomPaymentMethod.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ICustomPaymentMethod);

            /** CustomPaymentMethod credentialId. */
            public credentialId: string;

            /** CustomPaymentMethod country. */
            public country: string;

            /** CustomPaymentMethod type. */
            public type: string;

            /** CustomPaymentMethod metadata. */
            public metadata: proto.SyncActionValue.ICustomPaymentMethodMetadata[];

            /**
             * Creates a new CustomPaymentMethod instance using the specified properties.
             * @param [properties] Properties to set
             * @returns CustomPaymentMethod instance
             */
            public static create(properties?: proto.SyncActionValue.ICustomPaymentMethod): proto.SyncActionValue.CustomPaymentMethod;

            /**
             * Encodes the specified CustomPaymentMethod message. Does not implicitly {@link proto.SyncActionValue.CustomPaymentMethod.verify|verify} messages.
             * @param message CustomPaymentMethod message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ICustomPaymentMethod, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified CustomPaymentMethod message, length delimited. Does not implicitly {@link proto.SyncActionValue.CustomPaymentMethod.verify|verify} messages.
             * @param message CustomPaymentMethod message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ICustomPaymentMethod, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a CustomPaymentMethod message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns CustomPaymentMethod
             * @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): proto.SyncActionValue.CustomPaymentMethod;

            /**
             * Decodes a CustomPaymentMethod message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns CustomPaymentMethod
             * @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)): proto.SyncActionValue.CustomPaymentMethod;

            /**
             * Verifies a CustomPaymentMethod 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 CustomPaymentMethod message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns CustomPaymentMethod
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.CustomPaymentMethod;

            /**
             * Creates a plain object from a CustomPaymentMethod message. Also converts values to other types if specified.
             * @param message CustomPaymentMethod
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.CustomPaymentMethod, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this CustomPaymentMethod to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a CustomPaymentMethodMetadata. */
        interface ICustomPaymentMethodMetadata {

            /** CustomPaymentMethodMetadata key */
            key: string;

            /** CustomPaymentMethodMetadata value */
            value: string;
        }

        /** Represents a CustomPaymentMethodMetadata. */
        class CustomPaymentMethodMetadata implements ICustomPaymentMethodMetadata {

            /**
             * Constructs a new CustomPaymentMethodMetadata.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ICustomPaymentMethodMetadata);

            /** CustomPaymentMethodMetadata key. */
            public key: string;

            /** CustomPaymentMethodMetadata value. */
            public value: string;

            /**
             * Creates a new CustomPaymentMethodMetadata instance using the specified properties.
             * @param [properties] Properties to set
             * @returns CustomPaymentMethodMetadata instance
             */
            public static create(properties?: proto.SyncActionValue.ICustomPaymentMethodMetadata): proto.SyncActionValue.CustomPaymentMethodMetadata;

            /**
             * Encodes the specified CustomPaymentMethodMetadata message. Does not implicitly {@link proto.SyncActionValue.CustomPaymentMethodMetadata.verify|verify} messages.
             * @param message CustomPaymentMethodMetadata message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ICustomPaymentMethodMetadata, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified CustomPaymentMethodMetadata message, length delimited. Does not implicitly {@link proto.SyncActionValue.CustomPaymentMethodMetadata.verify|verify} messages.
             * @param message CustomPaymentMethodMetadata message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ICustomPaymentMethodMetadata, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a CustomPaymentMethodMetadata message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns CustomPaymentMethodMetadata
             * @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): proto.SyncActionValue.CustomPaymentMethodMetadata;

            /**
             * Decodes a CustomPaymentMethodMetadata message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns CustomPaymentMethodMetadata
             * @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)): proto.SyncActionValue.CustomPaymentMethodMetadata;

            /**
             * Verifies a CustomPaymentMethodMetadata 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 CustomPaymentMethodMetadata message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns CustomPaymentMethodMetadata
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.CustomPaymentMethodMetadata;

            /**
             * Creates a plain object from a CustomPaymentMethodMetadata message. Also converts values to other types if specified.
             * @param message CustomPaymentMethodMetadata
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.CustomPaymentMethodMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this CustomPaymentMethodMetadata to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a CustomPaymentMethodsAction. */
        interface ICustomPaymentMethodsAction {

            /** CustomPaymentMethodsAction customPaymentMethods */
            customPaymentMethods?: (proto.SyncActionValue.ICustomPaymentMethod[]|null);
        }

        /** Represents a CustomPaymentMethodsAction. */
        class CustomPaymentMethodsAction implements ICustomPaymentMethodsAction {

            /**
             * Constructs a new CustomPaymentMethodsAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ICustomPaymentMethodsAction);

            /** CustomPaymentMethodsAction customPaymentMethods. */
            public customPaymentMethods: proto.SyncActionValue.ICustomPaymentMethod[];

            /**
             * Creates a new CustomPaymentMethodsAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns CustomPaymentMethodsAction instance
             */
            public static create(properties?: proto.SyncActionValue.ICustomPaymentMethodsAction): proto.SyncActionValue.CustomPaymentMethodsAction;

            /**
             * Encodes the specified CustomPaymentMethodsAction message. Does not implicitly {@link proto.SyncActionValue.CustomPaymentMethodsAction.verify|verify} messages.
             * @param message CustomPaymentMethodsAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ICustomPaymentMethodsAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified CustomPaymentMethodsAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.CustomPaymentMethodsAction.verify|verify} messages.
             * @param message CustomPaymentMethodsAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ICustomPaymentMethodsAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a CustomPaymentMethodsAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns CustomPaymentMethodsAction
             * @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): proto.SyncActionValue.CustomPaymentMethodsAction;

            /**
             * Decodes a CustomPaymentMethodsAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns CustomPaymentMethodsAction
             * @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)): proto.SyncActionValue.CustomPaymentMethodsAction;

            /**
             * Verifies a CustomPaymentMethodsAction 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 CustomPaymentMethodsAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns CustomPaymentMethodsAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.CustomPaymentMethodsAction;

            /**
             * Creates a plain object from a CustomPaymentMethodsAction message. Also converts values to other types if specified.
             * @param message CustomPaymentMethodsAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.CustomPaymentMethodsAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this CustomPaymentMethodsAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a DeleteChatAction. */
        interface IDeleteChatAction {

            /** DeleteChatAction messageRange */
            messageRange?: (proto.SyncActionValue.ISyncActionMessageRange|null);
        }

        /** Represents a DeleteChatAction. */
        class DeleteChatAction implements IDeleteChatAction {

            /**
             * Constructs a new DeleteChatAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IDeleteChatAction);

            /** DeleteChatAction messageRange. */
            public messageRange?: (proto.SyncActionValue.ISyncActionMessageRange|null);

            /**
             * Creates a new DeleteChatAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns DeleteChatAction instance
             */
            public static create(properties?: proto.SyncActionValue.IDeleteChatAction): proto.SyncActionValue.DeleteChatAction;

            /**
             * Encodes the specified DeleteChatAction message. Does not implicitly {@link proto.SyncActionValue.DeleteChatAction.verify|verify} messages.
             * @param message DeleteChatAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IDeleteChatAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified DeleteChatAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.DeleteChatAction.verify|verify} messages.
             * @param message DeleteChatAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IDeleteChatAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a DeleteChatAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns DeleteChatAction
             * @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): proto.SyncActionValue.DeleteChatAction;

            /**
             * Decodes a DeleteChatAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns DeleteChatAction
             * @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)): proto.SyncActionValue.DeleteChatAction;

            /**
             * Verifies a DeleteChatAction 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 DeleteChatAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns DeleteChatAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.DeleteChatAction;

            /**
             * Creates a plain object from a DeleteChatAction message. Also converts values to other types if specified.
             * @param message DeleteChatAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.DeleteChatAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this DeleteChatAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a DeleteIndividualCallLogAction. */
        interface IDeleteIndividualCallLogAction {

            /** DeleteIndividualCallLogAction peerJid */
            peerJid?: (string|null);

            /** DeleteIndividualCallLogAction isIncoming */
            isIncoming?: (boolean|null);
        }

        /** Represents a DeleteIndividualCallLogAction. */
        class DeleteIndividualCallLogAction implements IDeleteIndividualCallLogAction {

            /**
             * Constructs a new DeleteIndividualCallLogAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IDeleteIndividualCallLogAction);

            /** DeleteIndividualCallLogAction peerJid. */
            public peerJid: string;

            /** DeleteIndividualCallLogAction isIncoming. */
            public isIncoming: boolean;

            /**
             * Creates a new DeleteIndividualCallLogAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns DeleteIndividualCallLogAction instance
             */
            public static create(properties?: proto.SyncActionValue.IDeleteIndividualCallLogAction): proto.SyncActionValue.DeleteIndividualCallLogAction;

            /**
             * Encodes the specified DeleteIndividualCallLogAction message. Does not implicitly {@link proto.SyncActionValue.DeleteIndividualCallLogAction.verify|verify} messages.
             * @param message DeleteIndividualCallLogAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IDeleteIndividualCallLogAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified DeleteIndividualCallLogAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.DeleteIndividualCallLogAction.verify|verify} messages.
             * @param message DeleteIndividualCallLogAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IDeleteIndividualCallLogAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a DeleteIndividualCallLogAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns DeleteIndividualCallLogAction
             * @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): proto.SyncActionValue.DeleteIndividualCallLogAction;

            /**
             * Decodes a DeleteIndividualCallLogAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns DeleteIndividualCallLogAction
             * @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)): proto.SyncActionValue.DeleteIndividualCallLogAction;

            /**
             * Verifies a DeleteIndividualCallLogAction 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 DeleteIndividualCallLogAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns DeleteIndividualCallLogAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.DeleteIndividualCallLogAction;

            /**
             * Creates a plain object from a DeleteIndividualCallLogAction message. Also converts values to other types if specified.
             * @param message DeleteIndividualCallLogAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.DeleteIndividualCallLogAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this DeleteIndividualCallLogAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a DeleteMessageForMeAction. */
        interface IDeleteMessageForMeAction {

            /** DeleteMessageForMeAction deleteMedia */
            deleteMedia?: (boolean|null);

            /** DeleteMessageForMeAction messageTimestamp */
            messageTimestamp?: (number|Long|null);
        }

        /** Represents a DeleteMessageForMeAction. */
        class DeleteMessageForMeAction implements IDeleteMessageForMeAction {

            /**
             * Constructs a new DeleteMessageForMeAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IDeleteMessageForMeAction);

            /** DeleteMessageForMeAction deleteMedia. */
            public deleteMedia: boolean;

            /** DeleteMessageForMeAction messageTimestamp. */
            public messageTimestamp: (number|Long);

            /**
             * Creates a new DeleteMessageForMeAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns DeleteMessageForMeAction instance
             */
            public static create(properties?: proto.SyncActionValue.IDeleteMessageForMeAction): proto.SyncActionValue.DeleteMessageForMeAction;

            /**
             * Encodes the specified DeleteMessageForMeAction message. Does not implicitly {@link proto.SyncActionValue.DeleteMessageForMeAction.verify|verify} messages.
             * @param message DeleteMessageForMeAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IDeleteMessageForMeAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified DeleteMessageForMeAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.DeleteMessageForMeAction.verify|verify} messages.
             * @param message DeleteMessageForMeAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IDeleteMessageForMeAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a DeleteMessageForMeAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns DeleteMessageForMeAction
             * @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): proto.SyncActionValue.DeleteMessageForMeAction;

            /**
             * Decodes a DeleteMessageForMeAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns DeleteMessageForMeAction
             * @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)): proto.SyncActionValue.DeleteMessageForMeAction;

            /**
             * Verifies a DeleteMessageForMeAction 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 DeleteMessageForMeAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns DeleteMessageForMeAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.DeleteMessageForMeAction;

            /**
             * Creates a plain object from a DeleteMessageForMeAction message. Also converts values to other types if specified.
             * @param message DeleteMessageForMeAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.DeleteMessageForMeAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this DeleteMessageForMeAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an ExternalWebBetaAction. */
        interface IExternalWebBetaAction {

            /** ExternalWebBetaAction isOptIn */
            isOptIn?: (boolean|null);
        }

        /** Represents an ExternalWebBetaAction. */
        class ExternalWebBetaAction implements IExternalWebBetaAction {

            /**
             * Constructs a new ExternalWebBetaAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IExternalWebBetaAction);

            /** ExternalWebBetaAction isOptIn. */
            public isOptIn: boolean;

            /**
             * Creates a new ExternalWebBetaAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns ExternalWebBetaAction instance
             */
            public static create(properties?: proto.SyncActionValue.IExternalWebBetaAction): proto.SyncActionValue.ExternalWebBetaAction;

            /**
             * Encodes the specified ExternalWebBetaAction message. Does not implicitly {@link proto.SyncActionValue.ExternalWebBetaAction.verify|verify} messages.
             * @param message ExternalWebBetaAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IExternalWebBetaAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified ExternalWebBetaAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.ExternalWebBetaAction.verify|verify} messages.
             * @param message ExternalWebBetaAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IExternalWebBetaAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an ExternalWebBetaAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns ExternalWebBetaAction
             * @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): proto.SyncActionValue.ExternalWebBetaAction;

            /**
             * Decodes an ExternalWebBetaAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns ExternalWebBetaAction
             * @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)): proto.SyncActionValue.ExternalWebBetaAction;

            /**
             * Verifies an ExternalWebBetaAction 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 ExternalWebBetaAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns ExternalWebBetaAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.ExternalWebBetaAction;

            /**
             * Creates a plain object from an ExternalWebBetaAction message. Also converts values to other types if specified.
             * @param message ExternalWebBetaAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.ExternalWebBetaAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this ExternalWebBetaAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a KeyExpiration. */
        interface IKeyExpiration {

            /** KeyExpiration expiredKeyEpoch */
            expiredKeyEpoch?: (number|null);
        }

        /** Represents a KeyExpiration. */
        class KeyExpiration implements IKeyExpiration {

            /**
             * Constructs a new KeyExpiration.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IKeyExpiration);

            /** KeyExpiration expiredKeyEpoch. */
            public expiredKeyEpoch: number;

            /**
             * Creates a new KeyExpiration instance using the specified properties.
             * @param [properties] Properties to set
             * @returns KeyExpiration instance
             */
            public static create(properties?: proto.SyncActionValue.IKeyExpiration): proto.SyncActionValue.KeyExpiration;

            /**
             * Encodes the specified KeyExpiration message. Does not implicitly {@link proto.SyncActionValue.KeyExpiration.verify|verify} messages.
             * @param message KeyExpiration message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IKeyExpiration, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified KeyExpiration message, length delimited. Does not implicitly {@link proto.SyncActionValue.KeyExpiration.verify|verify} messages.
             * @param message KeyExpiration message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IKeyExpiration, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a KeyExpiration message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns KeyExpiration
             * @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): proto.SyncActionValue.KeyExpiration;

            /**
             * Decodes a KeyExpiration message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns KeyExpiration
             * @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)): proto.SyncActionValue.KeyExpiration;

            /**
             * Verifies a KeyExpiration 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 KeyExpiration message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns KeyExpiration
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.KeyExpiration;

            /**
             * Creates a plain object from a KeyExpiration message. Also converts values to other types if specified.
             * @param message KeyExpiration
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.KeyExpiration, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this KeyExpiration to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a LabelAssociationAction. */
        interface ILabelAssociationAction {

            /** LabelAssociationAction labeled */
            labeled?: (boolean|null);
        }

        /** Represents a LabelAssociationAction. */
        class LabelAssociationAction implements ILabelAssociationAction {

            /**
             * Constructs a new LabelAssociationAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ILabelAssociationAction);

            /** LabelAssociationAction labeled. */
            public labeled: boolean;

            /**
             * Creates a new LabelAssociationAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns LabelAssociationAction instance
             */
            public static create(properties?: proto.SyncActionValue.ILabelAssociationAction): proto.SyncActionValue.LabelAssociationAction;

            /**
             * Encodes the specified LabelAssociationAction message. Does not implicitly {@link proto.SyncActionValue.LabelAssociationAction.verify|verify} messages.
             * @param message LabelAssociationAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ILabelAssociationAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified LabelAssociationAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.LabelAssociationAction.verify|verify} messages.
             * @param message LabelAssociationAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ILabelAssociationAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a LabelAssociationAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns LabelAssociationAction
             * @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): proto.SyncActionValue.LabelAssociationAction;

            /**
             * Decodes a LabelAssociationAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns LabelAssociationAction
             * @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)): proto.SyncActionValue.LabelAssociationAction;

            /**
             * Verifies a LabelAssociationAction 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 LabelAssociationAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns LabelAssociationAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.LabelAssociationAction;

            /**
             * Creates a plain object from a LabelAssociationAction message. Also converts values to other types if specified.
             * @param message LabelAssociationAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.LabelAssociationAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this LabelAssociationAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a LabelEditAction. */
        interface ILabelEditAction {

            /** LabelEditAction name */
            name?: (string|null);

            /** LabelEditAction color */
            color?: (number|null);

            /** LabelEditAction predefinedId */
            predefinedId?: (number|null);

            /** LabelEditAction deleted */
            deleted?: (boolean|null);

            /** LabelEditAction orderIndex */
            orderIndex?: (number|null);
        }

        /** Represents a LabelEditAction. */
        class LabelEditAction implements ILabelEditAction {

            /**
             * Constructs a new LabelEditAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ILabelEditAction);

            /** LabelEditAction name. */
            public name: string;

            /** LabelEditAction color. */
            public color: number;

            /** LabelEditAction predefinedId. */
            public predefinedId: number;

            /** LabelEditAction deleted. */
            public deleted: boolean;

            /** LabelEditAction orderIndex. */
            public orderIndex: number;

            /**
             * Creates a new LabelEditAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns LabelEditAction instance
             */
            public static create(properties?: proto.SyncActionValue.ILabelEditAction): proto.SyncActionValue.LabelEditAction;

            /**
             * Encodes the specified LabelEditAction message. Does not implicitly {@link proto.SyncActionValue.LabelEditAction.verify|verify} messages.
             * @param message LabelEditAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ILabelEditAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified LabelEditAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.LabelEditAction.verify|verify} messages.
             * @param message LabelEditAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ILabelEditAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a LabelEditAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns LabelEditAction
             * @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): proto.SyncActionValue.LabelEditAction;

            /**
             * Decodes a LabelEditAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns LabelEditAction
             * @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)): proto.SyncActionValue.LabelEditAction;

            /**
             * Verifies a LabelEditAction 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 LabelEditAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns LabelEditAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.LabelEditAction;

            /**
             * Creates a plain object from a LabelEditAction message. Also converts values to other types if specified.
             * @param message LabelEditAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.LabelEditAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this LabelEditAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a LabelReorderingAction. */
        interface ILabelReorderingAction {

            /** LabelReorderingAction sortedLabelIds */
            sortedLabelIds?: (number[]|null);
        }

        /** Represents a LabelReorderingAction. */
        class LabelReorderingAction implements ILabelReorderingAction {

            /**
             * Constructs a new LabelReorderingAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ILabelReorderingAction);

            /** LabelReorderingAction sortedLabelIds. */
            public sortedLabelIds: number[];

            /**
             * Creates a new LabelReorderingAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns LabelReorderingAction instance
             */
            public static create(properties?: proto.SyncActionValue.ILabelReorderingAction): proto.SyncActionValue.LabelReorderingAction;

            /**
             * Encodes the specified LabelReorderingAction message. Does not implicitly {@link proto.SyncActionValue.LabelReorderingAction.verify|verify} messages.
             * @param message LabelReorderingAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ILabelReorderingAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified LabelReorderingAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.LabelReorderingAction.verify|verify} messages.
             * @param message LabelReorderingAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ILabelReorderingAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a LabelReorderingAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns LabelReorderingAction
             * @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): proto.SyncActionValue.LabelReorderingAction;

            /**
             * Decodes a LabelReorderingAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns LabelReorderingAction
             * @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)): proto.SyncActionValue.LabelReorderingAction;

            /**
             * Verifies a LabelReorderingAction 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 LabelReorderingAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns LabelReorderingAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.LabelReorderingAction;

            /**
             * Creates a plain object from a LabelReorderingAction message. Also converts values to other types if specified.
             * @param message LabelReorderingAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.LabelReorderingAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this LabelReorderingAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a LocaleSetting. */
        interface ILocaleSetting {

            /** LocaleSetting locale */
            locale?: (string|null);
        }

        /** Represents a LocaleSetting. */
        class LocaleSetting implements ILocaleSetting {

            /**
             * Constructs a new LocaleSetting.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ILocaleSetting);

            /** LocaleSetting locale. */
            public locale: string;

            /**
             * Creates a new LocaleSetting instance using the specified properties.
             * @param [properties] Properties to set
             * @returns LocaleSetting instance
             */
            public static create(properties?: proto.SyncActionValue.ILocaleSetting): proto.SyncActionValue.LocaleSetting;

            /**
             * Encodes the specified LocaleSetting message. Does not implicitly {@link proto.SyncActionValue.LocaleSetting.verify|verify} messages.
             * @param message LocaleSetting message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ILocaleSetting, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified LocaleSetting message, length delimited. Does not implicitly {@link proto.SyncActionValue.LocaleSetting.verify|verify} messages.
             * @param message LocaleSetting message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ILocaleSetting, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a LocaleSetting message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns LocaleSetting
             * @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): proto.SyncActionValue.LocaleSetting;

            /**
             * Decodes a LocaleSetting message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns LocaleSetting
             * @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)): proto.SyncActionValue.LocaleSetting;

            /**
             * Verifies a LocaleSetting 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 LocaleSetting message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns LocaleSetting
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.LocaleSetting;

            /**
             * Creates a plain object from a LocaleSetting message. Also converts values to other types if specified.
             * @param message LocaleSetting
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.LocaleSetting, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this LocaleSetting to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a MarkChatAsReadAction. */
        interface IMarkChatAsReadAction {

            /** MarkChatAsReadAction read */
            read?: (boolean|null);

            /** MarkChatAsReadAction messageRange */
            messageRange?: (proto.SyncActionValue.ISyncActionMessageRange|null);
        }

        /** Represents a MarkChatAsReadAction. */
        class MarkChatAsReadAction implements IMarkChatAsReadAction {

            /**
             * Constructs a new MarkChatAsReadAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IMarkChatAsReadAction);

            /** MarkChatAsReadAction read. */
            public read: boolean;

            /** MarkChatAsReadAction messageRange. */
            public messageRange?: (proto.SyncActionValue.ISyncActionMessageRange|null);

            /**
             * Creates a new MarkChatAsReadAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns MarkChatAsReadAction instance
             */
            public static create(properties?: proto.SyncActionValue.IMarkChatAsReadAction): proto.SyncActionValue.MarkChatAsReadAction;

            /**
             * Encodes the specified MarkChatAsReadAction message. Does not implicitly {@link proto.SyncActionValue.MarkChatAsReadAction.verify|verify} messages.
             * @param message MarkChatAsReadAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IMarkChatAsReadAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified MarkChatAsReadAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.MarkChatAsReadAction.verify|verify} messages.
             * @param message MarkChatAsReadAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IMarkChatAsReadAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a MarkChatAsReadAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns MarkChatAsReadAction
             * @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): proto.SyncActionValue.MarkChatAsReadAction;

            /**
             * Decodes a MarkChatAsReadAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns MarkChatAsReadAction
             * @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)): proto.SyncActionValue.MarkChatAsReadAction;

            /**
             * Verifies a MarkChatAsReadAction 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 MarkChatAsReadAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns MarkChatAsReadAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.MarkChatAsReadAction;

            /**
             * Creates a plain object from a MarkChatAsReadAction message. Also converts values to other types if specified.
             * @param message MarkChatAsReadAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.MarkChatAsReadAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this MarkChatAsReadAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a MarketingMessageAction. */
        interface IMarketingMessageAction {

            /** MarketingMessageAction name */
            name?: (string|null);

            /** MarketingMessageAction message */
            message?: (string|null);

            /** MarketingMessageAction type */
            type?: (proto.SyncActionValue.MarketingMessageAction.MarketingMessagePrototypeType|null);

            /** MarketingMessageAction createdAt */
            createdAt?: (number|Long|null);

            /** MarketingMessageAction lastSentAt */
            lastSentAt?: (number|Long|null);

            /** MarketingMessageAction isDeleted */
            isDeleted?: (boolean|null);

            /** MarketingMessageAction mediaId */
            mediaId?: (string|null);
        }

        /** Represents a MarketingMessageAction. */
        class MarketingMessageAction implements IMarketingMessageAction {

            /**
             * Constructs a new MarketingMessageAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IMarketingMessageAction);

            /** MarketingMessageAction name. */
            public name: string;

            /** MarketingMessageAction message. */
            public message: string;

            /** MarketingMessageAction type. */
            public type: proto.SyncActionValue.MarketingMessageAction.MarketingMessagePrototypeType;

            /** MarketingMessageAction createdAt. */
            public createdAt: (number|Long);

            /** MarketingMessageAction lastSentAt. */
            public lastSentAt: (number|Long);

            /** MarketingMessageAction isDeleted. */
            public isDeleted: boolean;

            /** MarketingMessageAction mediaId. */
            public mediaId: string;

            /**
             * Creates a new MarketingMessageAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns MarketingMessageAction instance
             */
            public static create(properties?: proto.SyncActionValue.IMarketingMessageAction): proto.SyncActionValue.MarketingMessageAction;

            /**
             * Encodes the specified MarketingMessageAction message. Does not implicitly {@link proto.SyncActionValue.MarketingMessageAction.verify|verify} messages.
             * @param message MarketingMessageAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IMarketingMessageAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified MarketingMessageAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.MarketingMessageAction.verify|verify} messages.
             * @param message MarketingMessageAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IMarketingMessageAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a MarketingMessageAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns MarketingMessageAction
             * @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): proto.SyncActionValue.MarketingMessageAction;

            /**
             * Decodes a MarketingMessageAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns MarketingMessageAction
             * @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)): proto.SyncActionValue.MarketingMessageAction;

            /**
             * Verifies a MarketingMessageAction 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 MarketingMessageAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns MarketingMessageAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.MarketingMessageAction;

            /**
             * Creates a plain object from a MarketingMessageAction message. Also converts values to other types if specified.
             * @param message MarketingMessageAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.MarketingMessageAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this MarketingMessageAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace MarketingMessageAction {

            /** MarketingMessagePrototypeType enum. */
            enum MarketingMessagePrototypeType {
                PERSONALIZED = 0
            }
        }

        /** Properties of a MarketingMessageBroadcastAction. */
        interface IMarketingMessageBroadcastAction {

            /** MarketingMessageBroadcastAction repliedCount */
            repliedCount?: (number|null);
        }

        /** Represents a MarketingMessageBroadcastAction. */
        class MarketingMessageBroadcastAction implements IMarketingMessageBroadcastAction {

            /**
             * Constructs a new MarketingMessageBroadcastAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IMarketingMessageBroadcastAction);

            /** MarketingMessageBroadcastAction repliedCount. */
            public repliedCount: number;

            /**
             * Creates a new MarketingMessageBroadcastAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns MarketingMessageBroadcastAction instance
             */
            public static create(properties?: proto.SyncActionValue.IMarketingMessageBroadcastAction): proto.SyncActionValue.MarketingMessageBroadcastAction;

            /**
             * Encodes the specified MarketingMessageBroadcastAction message. Does not implicitly {@link proto.SyncActionValue.MarketingMessageBroadcastAction.verify|verify} messages.
             * @param message MarketingMessageBroadcastAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IMarketingMessageBroadcastAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified MarketingMessageBroadcastAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.MarketingMessageBroadcastAction.verify|verify} messages.
             * @param message MarketingMessageBroadcastAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IMarketingMessageBroadcastAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a MarketingMessageBroadcastAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns MarketingMessageBroadcastAction
             * @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): proto.SyncActionValue.MarketingMessageBroadcastAction;

            /**
             * Decodes a MarketingMessageBroadcastAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns MarketingMessageBroadcastAction
             * @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)): proto.SyncActionValue.MarketingMessageBroadcastAction;

            /**
             * Verifies a MarketingMessageBroadcastAction 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 MarketingMessageBroadcastAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns MarketingMessageBroadcastAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.MarketingMessageBroadcastAction;

            /**
             * Creates a plain object from a MarketingMessageBroadcastAction message. Also converts values to other types if specified.
             * @param message MarketingMessageBroadcastAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.MarketingMessageBroadcastAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this MarketingMessageBroadcastAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a MuteAction. */
        interface IMuteAction {

            /** MuteAction muted */
            muted?: (boolean|null);

            /** MuteAction muteEndTimestamp */
            muteEndTimestamp?: (number|Long|null);

            /** MuteAction autoMuted */
            autoMuted?: (boolean|null);
        }

        /** Represents a MuteAction. */
        class MuteAction implements IMuteAction {

            /**
             * Constructs a new MuteAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IMuteAction);

            /** MuteAction muted. */
            public muted: boolean;

            /** MuteAction muteEndTimestamp. */
            public muteEndTimestamp: (number|Long);

            /** MuteAction autoMuted. */
            public autoMuted: boolean;

            /**
             * Creates a new MuteAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns MuteAction instance
             */
            public static create(properties?: proto.SyncActionValue.IMuteAction): proto.SyncActionValue.MuteAction;

            /**
             * Encodes the specified MuteAction message. Does not implicitly {@link proto.SyncActionValue.MuteAction.verify|verify} messages.
             * @param message MuteAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IMuteAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified MuteAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.MuteAction.verify|verify} messages.
             * @param message MuteAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IMuteAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a MuteAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns MuteAction
             * @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): proto.SyncActionValue.MuteAction;

            /**
             * Decodes a MuteAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns MuteAction
             * @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)): proto.SyncActionValue.MuteAction;

            /**
             * Verifies a MuteAction 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 MuteAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns MuteAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.MuteAction;

            /**
             * Creates a plain object from a MuteAction message. Also converts values to other types if specified.
             * @param message MuteAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.MuteAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this MuteAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a NuxAction. */
        interface INuxAction {

            /** NuxAction acknowledged */
            acknowledged?: (boolean|null);
        }

        /** Represents a NuxAction. */
        class NuxAction implements INuxAction {

            /**
             * Constructs a new NuxAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.INuxAction);

            /** NuxAction acknowledged. */
            public acknowledged: boolean;

            /**
             * Creates a new NuxAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns NuxAction instance
             */
            public static create(properties?: proto.SyncActionValue.INuxAction): proto.SyncActionValue.NuxAction;

            /**
             * Encodes the specified NuxAction message. Does not implicitly {@link proto.SyncActionValue.NuxAction.verify|verify} messages.
             * @param message NuxAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.INuxAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified NuxAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.NuxAction.verify|verify} messages.
             * @param message NuxAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.INuxAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a NuxAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns NuxAction
             * @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): proto.SyncActionValue.NuxAction;

            /**
             * Decodes a NuxAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns NuxAction
             * @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)): proto.SyncActionValue.NuxAction;

            /**
             * Verifies a NuxAction 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 NuxAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns NuxAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.NuxAction;

            /**
             * Creates a plain object from a NuxAction message. Also converts values to other types if specified.
             * @param message NuxAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.NuxAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this NuxAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a PaymentInfoAction. */
        interface IPaymentInfoAction {

            /** PaymentInfoAction cpi */
            cpi?: (string|null);
        }

        /** Represents a PaymentInfoAction. */
        class PaymentInfoAction implements IPaymentInfoAction {

            /**
             * Constructs a new PaymentInfoAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IPaymentInfoAction);

            /** PaymentInfoAction cpi. */
            public cpi: string;

            /**
             * Creates a new PaymentInfoAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PaymentInfoAction instance
             */
            public static create(properties?: proto.SyncActionValue.IPaymentInfoAction): proto.SyncActionValue.PaymentInfoAction;

            /**
             * Encodes the specified PaymentInfoAction message. Does not implicitly {@link proto.SyncActionValue.PaymentInfoAction.verify|verify} messages.
             * @param message PaymentInfoAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IPaymentInfoAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PaymentInfoAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.PaymentInfoAction.verify|verify} messages.
             * @param message PaymentInfoAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IPaymentInfoAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PaymentInfoAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PaymentInfoAction
             * @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): proto.SyncActionValue.PaymentInfoAction;

            /**
             * Decodes a PaymentInfoAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PaymentInfoAction
             * @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)): proto.SyncActionValue.PaymentInfoAction;

            /**
             * Verifies a PaymentInfoAction 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 PaymentInfoAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PaymentInfoAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.PaymentInfoAction;

            /**
             * Creates a plain object from a PaymentInfoAction message. Also converts values to other types if specified.
             * @param message PaymentInfoAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.PaymentInfoAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PaymentInfoAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a PinAction. */
        interface IPinAction {

            /** PinAction pinned */
            pinned?: (boolean|null);
        }

        /** Represents a PinAction. */
        class PinAction implements IPinAction {

            /**
             * Constructs a new PinAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IPinAction);

            /** PinAction pinned. */
            public pinned: boolean;

            /**
             * Creates a new PinAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PinAction instance
             */
            public static create(properties?: proto.SyncActionValue.IPinAction): proto.SyncActionValue.PinAction;

            /**
             * Encodes the specified PinAction message. Does not implicitly {@link proto.SyncActionValue.PinAction.verify|verify} messages.
             * @param message PinAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IPinAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PinAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.PinAction.verify|verify} messages.
             * @param message PinAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IPinAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PinAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PinAction
             * @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): proto.SyncActionValue.PinAction;

            /**
             * Decodes a PinAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PinAction
             * @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)): proto.SyncActionValue.PinAction;

            /**
             * Verifies a PinAction 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 PinAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PinAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.PinAction;

            /**
             * Creates a plain object from a PinAction message. Also converts values to other types if specified.
             * @param message PinAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.PinAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PinAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a PnForLidChatAction. */
        interface IPnForLidChatAction {

            /** PnForLidChatAction pnJid */
            pnJid?: (string|null);
        }

        /** Represents a PnForLidChatAction. */
        class PnForLidChatAction implements IPnForLidChatAction {

            /**
             * Constructs a new PnForLidChatAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IPnForLidChatAction);

            /** PnForLidChatAction pnJid. */
            public pnJid: string;

            /**
             * Creates a new PnForLidChatAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PnForLidChatAction instance
             */
            public static create(properties?: proto.SyncActionValue.IPnForLidChatAction): proto.SyncActionValue.PnForLidChatAction;

            /**
             * Encodes the specified PnForLidChatAction message. Does not implicitly {@link proto.SyncActionValue.PnForLidChatAction.verify|verify} messages.
             * @param message PnForLidChatAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IPnForLidChatAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PnForLidChatAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.PnForLidChatAction.verify|verify} messages.
             * @param message PnForLidChatAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IPnForLidChatAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PnForLidChatAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PnForLidChatAction
             * @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): proto.SyncActionValue.PnForLidChatAction;

            /**
             * Decodes a PnForLidChatAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PnForLidChatAction
             * @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)): proto.SyncActionValue.PnForLidChatAction;

            /**
             * Verifies a PnForLidChatAction 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 PnForLidChatAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PnForLidChatAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.PnForLidChatAction;

            /**
             * Creates a plain object from a PnForLidChatAction message. Also converts values to other types if specified.
             * @param message PnForLidChatAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.PnForLidChatAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PnForLidChatAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a PrimaryFeature. */
        interface IPrimaryFeature {

            /** PrimaryFeature flags */
            flags?: (string[]|null);
        }

        /** Represents a PrimaryFeature. */
        class PrimaryFeature implements IPrimaryFeature {

            /**
             * Constructs a new PrimaryFeature.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IPrimaryFeature);

            /** PrimaryFeature flags. */
            public flags: string[];

            /**
             * Creates a new PrimaryFeature instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PrimaryFeature instance
             */
            public static create(properties?: proto.SyncActionValue.IPrimaryFeature): proto.SyncActionValue.PrimaryFeature;

            /**
             * Encodes the specified PrimaryFeature message. Does not implicitly {@link proto.SyncActionValue.PrimaryFeature.verify|verify} messages.
             * @param message PrimaryFeature message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IPrimaryFeature, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PrimaryFeature message, length delimited. Does not implicitly {@link proto.SyncActionValue.PrimaryFeature.verify|verify} messages.
             * @param message PrimaryFeature message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IPrimaryFeature, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PrimaryFeature message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PrimaryFeature
             * @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): proto.SyncActionValue.PrimaryFeature;

            /**
             * Decodes a PrimaryFeature message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PrimaryFeature
             * @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)): proto.SyncActionValue.PrimaryFeature;

            /**
             * Verifies a PrimaryFeature 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 PrimaryFeature message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PrimaryFeature
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.PrimaryFeature;

            /**
             * Creates a plain object from a PrimaryFeature message. Also converts values to other types if specified.
             * @param message PrimaryFeature
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.PrimaryFeature, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PrimaryFeature to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a PrimaryVersionAction. */
        interface IPrimaryVersionAction {

            /** PrimaryVersionAction version */
            version?: (string|null);
        }

        /** Represents a PrimaryVersionAction. */
        class PrimaryVersionAction implements IPrimaryVersionAction {

            /**
             * Constructs a new PrimaryVersionAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IPrimaryVersionAction);

            /** PrimaryVersionAction version. */
            public version: string;

            /**
             * Creates a new PrimaryVersionAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PrimaryVersionAction instance
             */
            public static create(properties?: proto.SyncActionValue.IPrimaryVersionAction): proto.SyncActionValue.PrimaryVersionAction;

            /**
             * Encodes the specified PrimaryVersionAction message. Does not implicitly {@link proto.SyncActionValue.PrimaryVersionAction.verify|verify} messages.
             * @param message PrimaryVersionAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IPrimaryVersionAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PrimaryVersionAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.PrimaryVersionAction.verify|verify} messages.
             * @param message PrimaryVersionAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IPrimaryVersionAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PrimaryVersionAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PrimaryVersionAction
             * @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): proto.SyncActionValue.PrimaryVersionAction;

            /**
             * Decodes a PrimaryVersionAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PrimaryVersionAction
             * @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)): proto.SyncActionValue.PrimaryVersionAction;

            /**
             * Verifies a PrimaryVersionAction 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 PrimaryVersionAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PrimaryVersionAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.PrimaryVersionAction;

            /**
             * Creates a plain object from a PrimaryVersionAction message. Also converts values to other types if specified.
             * @param message PrimaryVersionAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.PrimaryVersionAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PrimaryVersionAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a PrivacySettingRelayAllCalls. */
        interface IPrivacySettingRelayAllCalls {

            /** PrivacySettingRelayAllCalls isEnabled */
            isEnabled?: (boolean|null);
        }

        /** Represents a PrivacySettingRelayAllCalls. */
        class PrivacySettingRelayAllCalls implements IPrivacySettingRelayAllCalls {

            /**
             * Constructs a new PrivacySettingRelayAllCalls.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IPrivacySettingRelayAllCalls);

            /** PrivacySettingRelayAllCalls isEnabled. */
            public isEnabled: boolean;

            /**
             * Creates a new PrivacySettingRelayAllCalls instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PrivacySettingRelayAllCalls instance
             */
            public static create(properties?: proto.SyncActionValue.IPrivacySettingRelayAllCalls): proto.SyncActionValue.PrivacySettingRelayAllCalls;

            /**
             * Encodes the specified PrivacySettingRelayAllCalls message. Does not implicitly {@link proto.SyncActionValue.PrivacySettingRelayAllCalls.verify|verify} messages.
             * @param message PrivacySettingRelayAllCalls message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IPrivacySettingRelayAllCalls, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PrivacySettingRelayAllCalls message, length delimited. Does not implicitly {@link proto.SyncActionValue.PrivacySettingRelayAllCalls.verify|verify} messages.
             * @param message PrivacySettingRelayAllCalls message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IPrivacySettingRelayAllCalls, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PrivacySettingRelayAllCalls message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PrivacySettingRelayAllCalls
             * @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): proto.SyncActionValue.PrivacySettingRelayAllCalls;

            /**
             * Decodes a PrivacySettingRelayAllCalls message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PrivacySettingRelayAllCalls
             * @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)): proto.SyncActionValue.PrivacySettingRelayAllCalls;

            /**
             * Verifies a PrivacySettingRelayAllCalls 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 PrivacySettingRelayAllCalls message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PrivacySettingRelayAllCalls
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.PrivacySettingRelayAllCalls;

            /**
             * Creates a plain object from a PrivacySettingRelayAllCalls message. Also converts values to other types if specified.
             * @param message PrivacySettingRelayAllCalls
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.PrivacySettingRelayAllCalls, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PrivacySettingRelayAllCalls to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a PushNameSetting. */
        interface IPushNameSetting {

            /** PushNameSetting name */
            name?: (string|null);
        }

        /** Represents a PushNameSetting. */
        class PushNameSetting implements IPushNameSetting {

            /**
             * Constructs a new PushNameSetting.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IPushNameSetting);

            /** PushNameSetting name. */
            public name: string;

            /**
             * Creates a new PushNameSetting instance using the specified properties.
             * @param [properties] Properties to set
             * @returns PushNameSetting instance
             */
            public static create(properties?: proto.SyncActionValue.IPushNameSetting): proto.SyncActionValue.PushNameSetting;

            /**
             * Encodes the specified PushNameSetting message. Does not implicitly {@link proto.SyncActionValue.PushNameSetting.verify|verify} messages.
             * @param message PushNameSetting message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IPushNameSetting, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified PushNameSetting message, length delimited. Does not implicitly {@link proto.SyncActionValue.PushNameSetting.verify|verify} messages.
             * @param message PushNameSetting message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IPushNameSetting, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a PushNameSetting message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns PushNameSetting
             * @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): proto.SyncActionValue.PushNameSetting;

            /**
             * Decodes a PushNameSetting message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns PushNameSetting
             * @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)): proto.SyncActionValue.PushNameSetting;

            /**
             * Verifies a PushNameSetting 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 PushNameSetting message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns PushNameSetting
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.PushNameSetting;

            /**
             * Creates a plain object from a PushNameSetting message. Also converts values to other types if specified.
             * @param message PushNameSetting
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.PushNameSetting, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this PushNameSetting to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a QuickReplyAction. */
        interface IQuickReplyAction {

            /** QuickReplyAction shortcut */
            shortcut?: (string|null);

            /** QuickReplyAction message */
            message?: (string|null);

            /** QuickReplyAction keywords */
            keywords?: (string[]|null);

            /** QuickReplyAction count */
            count?: (number|null);

            /** QuickReplyAction deleted */
            deleted?: (boolean|null);
        }

        /** Represents a QuickReplyAction. */
        class QuickReplyAction implements IQuickReplyAction {

            /**
             * Constructs a new QuickReplyAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IQuickReplyAction);

            /** QuickReplyAction shortcut. */
            public shortcut: string;

            /** QuickReplyAction message. */
            public message: string;

            /** QuickReplyAction keywords. */
            public keywords: string[];

            /** QuickReplyAction count. */
            public count: number;

            /** QuickReplyAction deleted. */
            public deleted: boolean;

            /**
             * Creates a new QuickReplyAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns QuickReplyAction instance
             */
            public static create(properties?: proto.SyncActionValue.IQuickReplyAction): proto.SyncActionValue.QuickReplyAction;

            /**
             * Encodes the specified QuickReplyAction message. Does not implicitly {@link proto.SyncActionValue.QuickReplyAction.verify|verify} messages.
             * @param message QuickReplyAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IQuickReplyAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified QuickReplyAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.QuickReplyAction.verify|verify} messages.
             * @param message QuickReplyAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IQuickReplyAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a QuickReplyAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns QuickReplyAction
             * @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): proto.SyncActionValue.QuickReplyAction;

            /**
             * Decodes a QuickReplyAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns QuickReplyAction
             * @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)): proto.SyncActionValue.QuickReplyAction;

            /**
             * Verifies a QuickReplyAction 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 QuickReplyAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns QuickReplyAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.QuickReplyAction;

            /**
             * Creates a plain object from a QuickReplyAction message. Also converts values to other types if specified.
             * @param message QuickReplyAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.QuickReplyAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this QuickReplyAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a RecentEmojiWeightsAction. */
        interface IRecentEmojiWeightsAction {

            /** RecentEmojiWeightsAction weights */
            weights?: (proto.IRecentEmojiWeight[]|null);
        }

        /** Represents a RecentEmojiWeightsAction. */
        class RecentEmojiWeightsAction implements IRecentEmojiWeightsAction {

            /**
             * Constructs a new RecentEmojiWeightsAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IRecentEmojiWeightsAction);

            /** RecentEmojiWeightsAction weights. */
            public weights: proto.IRecentEmojiWeight[];

            /**
             * Creates a new RecentEmojiWeightsAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns RecentEmojiWeightsAction instance
             */
            public static create(properties?: proto.SyncActionValue.IRecentEmojiWeightsAction): proto.SyncActionValue.RecentEmojiWeightsAction;

            /**
             * Encodes the specified RecentEmojiWeightsAction message. Does not implicitly {@link proto.SyncActionValue.RecentEmojiWeightsAction.verify|verify} messages.
             * @param message RecentEmojiWeightsAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IRecentEmojiWeightsAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified RecentEmojiWeightsAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.RecentEmojiWeightsAction.verify|verify} messages.
             * @param message RecentEmojiWeightsAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IRecentEmojiWeightsAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a RecentEmojiWeightsAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns RecentEmojiWeightsAction
             * @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): proto.SyncActionValue.RecentEmojiWeightsAction;

            /**
             * Decodes a RecentEmojiWeightsAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns RecentEmojiWeightsAction
             * @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)): proto.SyncActionValue.RecentEmojiWeightsAction;

            /**
             * Verifies a RecentEmojiWeightsAction 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 RecentEmojiWeightsAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns RecentEmojiWeightsAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.RecentEmojiWeightsAction;

            /**
             * Creates a plain object from a RecentEmojiWeightsAction message. Also converts values to other types if specified.
             * @param message RecentEmojiWeightsAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.RecentEmojiWeightsAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this RecentEmojiWeightsAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a RemoveRecentStickerAction. */
        interface IRemoveRecentStickerAction {

            /** RemoveRecentStickerAction lastStickerSentTs */
            lastStickerSentTs?: (number|Long|null);
        }

        /** Represents a RemoveRecentStickerAction. */
        class RemoveRecentStickerAction implements IRemoveRecentStickerAction {

            /**
             * Constructs a new RemoveRecentStickerAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IRemoveRecentStickerAction);

            /** RemoveRecentStickerAction lastStickerSentTs. */
            public lastStickerSentTs: (number|Long);

            /**
             * Creates a new RemoveRecentStickerAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns RemoveRecentStickerAction instance
             */
            public static create(properties?: proto.SyncActionValue.IRemoveRecentStickerAction): proto.SyncActionValue.RemoveRecentStickerAction;

            /**
             * Encodes the specified RemoveRecentStickerAction message. Does not implicitly {@link proto.SyncActionValue.RemoveRecentStickerAction.verify|verify} messages.
             * @param message RemoveRecentStickerAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IRemoveRecentStickerAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified RemoveRecentStickerAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.RemoveRecentStickerAction.verify|verify} messages.
             * @param message RemoveRecentStickerAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IRemoveRecentStickerAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a RemoveRecentStickerAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns RemoveRecentStickerAction
             * @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): proto.SyncActionValue.RemoveRecentStickerAction;

            /**
             * Decodes a RemoveRecentStickerAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns RemoveRecentStickerAction
             * @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)): proto.SyncActionValue.RemoveRecentStickerAction;

            /**
             * Verifies a RemoveRecentStickerAction 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 RemoveRecentStickerAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns RemoveRecentStickerAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.RemoveRecentStickerAction;

            /**
             * Creates a plain object from a RemoveRecentStickerAction message. Also converts values to other types if specified.
             * @param message RemoveRecentStickerAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.RemoveRecentStickerAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this RemoveRecentStickerAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a SecurityNotificationSetting. */
        interface ISecurityNotificationSetting {

            /** SecurityNotificationSetting showNotification */
            showNotification?: (boolean|null);
        }

        /** Represents a SecurityNotificationSetting. */
        class SecurityNotificationSetting implements ISecurityNotificationSetting {

            /**
             * Constructs a new SecurityNotificationSetting.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ISecurityNotificationSetting);

            /** SecurityNotificationSetting showNotification. */
            public showNotification: boolean;

            /**
             * Creates a new SecurityNotificationSetting instance using the specified properties.
             * @param [properties] Properties to set
             * @returns SecurityNotificationSetting instance
             */
            public static create(properties?: proto.SyncActionValue.ISecurityNotificationSetting): proto.SyncActionValue.SecurityNotificationSetting;

            /**
             * Encodes the specified SecurityNotificationSetting message. Does not implicitly {@link proto.SyncActionValue.SecurityNotificationSetting.verify|verify} messages.
             * @param message SecurityNotificationSetting message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ISecurityNotificationSetting, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified SecurityNotificationSetting message, length delimited. Does not implicitly {@link proto.SyncActionValue.SecurityNotificationSetting.verify|verify} messages.
             * @param message SecurityNotificationSetting message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ISecurityNotificationSetting, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a SecurityNotificationSetting message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns SecurityNotificationSetting
             * @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): proto.SyncActionValue.SecurityNotificationSetting;

            /**
             * Decodes a SecurityNotificationSetting message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns SecurityNotificationSetting
             * @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)): proto.SyncActionValue.SecurityNotificationSetting;

            /**
             * Verifies a SecurityNotificationSetting 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 SecurityNotificationSetting message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns SecurityNotificationSetting
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.SecurityNotificationSetting;

            /**
             * Creates a plain object from a SecurityNotificationSetting message. Also converts values to other types if specified.
             * @param message SecurityNotificationSetting
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.SecurityNotificationSetting, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this SecurityNotificationSetting to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a StarAction. */
        interface IStarAction {

            /** StarAction starred */
            starred?: (boolean|null);
        }

        /** Represents a StarAction. */
        class StarAction implements IStarAction {

            /**
             * Constructs a new StarAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IStarAction);

            /** StarAction starred. */
            public starred: boolean;

            /**
             * Creates a new StarAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns StarAction instance
             */
            public static create(properties?: proto.SyncActionValue.IStarAction): proto.SyncActionValue.StarAction;

            /**
             * Encodes the specified StarAction message. Does not implicitly {@link proto.SyncActionValue.StarAction.verify|verify} messages.
             * @param message StarAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IStarAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified StarAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.StarAction.verify|verify} messages.
             * @param message StarAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IStarAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a StarAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns StarAction
             * @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): proto.SyncActionValue.StarAction;

            /**
             * Decodes a StarAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns StarAction
             * @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)): proto.SyncActionValue.StarAction;

            /**
             * Verifies a StarAction 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 StarAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns StarAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.StarAction;

            /**
             * Creates a plain object from a StarAction message. Also converts values to other types if specified.
             * @param message StarAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.StarAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this StarAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a StatusPrivacyAction. */
        interface IStatusPrivacyAction {

            /** StatusPrivacyAction mode */
            mode?: (proto.SyncActionValue.StatusPrivacyAction.StatusDistributionMode|null);

            /** StatusPrivacyAction userJid */
            userJid?: (string[]|null);
        }

        /** Represents a StatusPrivacyAction. */
        class StatusPrivacyAction implements IStatusPrivacyAction {

            /**
             * Constructs a new StatusPrivacyAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IStatusPrivacyAction);

            /** StatusPrivacyAction mode. */
            public mode: proto.SyncActionValue.StatusPrivacyAction.StatusDistributionMode;

            /** StatusPrivacyAction userJid. */
            public userJid: string[];

            /**
             * Creates a new StatusPrivacyAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns StatusPrivacyAction instance
             */
            public static create(properties?: proto.SyncActionValue.IStatusPrivacyAction): proto.SyncActionValue.StatusPrivacyAction;

            /**
             * Encodes the specified StatusPrivacyAction message. Does not implicitly {@link proto.SyncActionValue.StatusPrivacyAction.verify|verify} messages.
             * @param message StatusPrivacyAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IStatusPrivacyAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified StatusPrivacyAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.StatusPrivacyAction.verify|verify} messages.
             * @param message StatusPrivacyAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IStatusPrivacyAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a StatusPrivacyAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns StatusPrivacyAction
             * @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): proto.SyncActionValue.StatusPrivacyAction;

            /**
             * Decodes a StatusPrivacyAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns StatusPrivacyAction
             * @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)): proto.SyncActionValue.StatusPrivacyAction;

            /**
             * Verifies a StatusPrivacyAction 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 StatusPrivacyAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns StatusPrivacyAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.StatusPrivacyAction;

            /**
             * Creates a plain object from a StatusPrivacyAction message. Also converts values to other types if specified.
             * @param message StatusPrivacyAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.StatusPrivacyAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this StatusPrivacyAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        namespace StatusPrivacyAction {

            /** StatusDistributionMode enum. */
            enum StatusDistributionMode {
                ALLOW_LIST = 0,
                DENY_LIST = 1,
                CONTACTS = 2
            }
        }

        /** Properties of a StickerAction. */
        interface IStickerAction {

            /** StickerAction url */
            url?: (string|null);

            /** StickerAction fileEncSha256 */
            fileEncSha256?: (Uint8Array|null);

            /** StickerAction mediaKey */
            mediaKey?: (Uint8Array|null);

            /** StickerAction mimetype */
            mimetype?: (string|null);

            /** StickerAction height */
            height?: (number|null);

            /** StickerAction width */
            width?: (number|null);

            /** StickerAction directPath */
            directPath?: (string|null);

            /** StickerAction fileLength */
            fileLength?: (number|Long|null);

            /** StickerAction isFavorite */
            isFavorite?: (boolean|null);

            /** StickerAction deviceIdHint */
            deviceIdHint?: (number|null);
        }

        /** Represents a StickerAction. */
        class StickerAction implements IStickerAction {

            /**
             * Constructs a new StickerAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IStickerAction);

            /** StickerAction url. */
            public url: string;

            /** StickerAction fileEncSha256. */
            public fileEncSha256: Uint8Array;

            /** StickerAction mediaKey. */
            public mediaKey: Uint8Array;

            /** StickerAction mimetype. */
            public mimetype: string;

            /** StickerAction height. */
            public height: number;

            /** StickerAction width. */
            public width: number;

            /** StickerAction directPath. */
            public directPath: string;

            /** StickerAction fileLength. */
            public fileLength: (number|Long);

            /** StickerAction isFavorite. */
            public isFavorite: boolean;

            /** StickerAction deviceIdHint. */
            public deviceIdHint: number;

            /**
             * Creates a new StickerAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns StickerAction instance
             */
            public static create(properties?: proto.SyncActionValue.IStickerAction): proto.SyncActionValue.StickerAction;

            /**
             * Encodes the specified StickerAction message. Does not implicitly {@link proto.SyncActionValue.StickerAction.verify|verify} messages.
             * @param message StickerAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IStickerAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified StickerAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.StickerAction.verify|verify} messages.
             * @param message StickerAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IStickerAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a StickerAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns StickerAction
             * @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): proto.SyncActionValue.StickerAction;

            /**
             * Decodes a StickerAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns StickerAction
             * @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)): proto.SyncActionValue.StickerAction;

            /**
             * Verifies a StickerAction 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 StickerAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns StickerAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.StickerAction;

            /**
             * Creates a plain object from a StickerAction message. Also converts values to other types if specified.
             * @param message StickerAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.StickerAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this StickerAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a SubscriptionAction. */
        interface ISubscriptionAction {

            /** SubscriptionAction isDeactivated */
            isDeactivated?: (boolean|null);

            /** SubscriptionAction isAutoRenewing */
            isAutoRenewing?: (boolean|null);

            /** SubscriptionAction expirationDate */
            expirationDate?: (number|Long|null);
        }

        /** Represents a SubscriptionAction. */
        class SubscriptionAction implements ISubscriptionAction {

            /**
             * Constructs a new SubscriptionAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ISubscriptionAction);

            /** SubscriptionAction isDeactivated. */
            public isDeactivated: boolean;

            /** SubscriptionAction isAutoRenewing. */
            public isAutoRenewing: boolean;

            /** SubscriptionAction expirationDate. */
            public expirationDate: (number|Long);

            /**
             * Creates a new SubscriptionAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns SubscriptionAction instance
             */
            public static create(properties?: proto.SyncActionValue.ISubscriptionAction): proto.SyncActionValue.SubscriptionAction;

            /**
             * Encodes the specified SubscriptionAction message. Does not implicitly {@link proto.SyncActionValue.SubscriptionAction.verify|verify} messages.
             * @param message SubscriptionAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ISubscriptionAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified SubscriptionAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.SubscriptionAction.verify|verify} messages.
             * @param message SubscriptionAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ISubscriptionAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a SubscriptionAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns SubscriptionAction
             * @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): proto.SyncActionValue.SubscriptionAction;

            /**
             * Decodes a SubscriptionAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns SubscriptionAction
             * @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)): proto.SyncActionValue.SubscriptionAction;

            /**
             * Verifies a SubscriptionAction 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 SubscriptionAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns SubscriptionAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.SubscriptionAction;

            /**
             * Creates a plain object from a SubscriptionAction message. Also converts values to other types if specified.
             * @param message SubscriptionAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.SubscriptionAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this SubscriptionAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a SyncActionMessage. */
        interface ISyncActionMessage {

            /** SyncActionMessage key */
            key?: (proto.IMessageKey|null);

            /** SyncActionMessage timestamp */
            timestamp?: (number|Long|null);
        }

        /** Represents a SyncActionMessage. */
        class SyncActionMessage implements ISyncActionMessage {

            /**
             * Constructs a new SyncActionMessage.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ISyncActionMessage);

            /** SyncActionMessage key. */
            public key?: (proto.IMessageKey|null);

            /** SyncActionMessage timestamp. */
            public timestamp: (number|Long);

            /**
             * Creates a new SyncActionMessage instance using the specified properties.
             * @param [properties] Properties to set
             * @returns SyncActionMessage instance
             */
            public static create(properties?: proto.SyncActionValue.ISyncActionMessage): proto.SyncActionValue.SyncActionMessage;

            /**
             * Encodes the specified SyncActionMessage message. Does not implicitly {@link proto.SyncActionValue.SyncActionMessage.verify|verify} messages.
             * @param message SyncActionMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ISyncActionMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified SyncActionMessage message, length delimited. Does not implicitly {@link proto.SyncActionValue.SyncActionMessage.verify|verify} messages.
             * @param message SyncActionMessage message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ISyncActionMessage, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a SyncActionMessage message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns SyncActionMessage
             * @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): proto.SyncActionValue.SyncActionMessage;

            /**
             * Decodes a SyncActionMessage message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns SyncActionMessage
             * @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)): proto.SyncActionValue.SyncActionMessage;

            /**
             * Verifies a SyncActionMessage 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 SyncActionMessage message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns SyncActionMessage
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.SyncActionMessage;

            /**
             * Creates a plain object from a SyncActionMessage message. Also converts values to other types if specified.
             * @param message SyncActionMessage
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.SyncActionMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this SyncActionMessage to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a SyncActionMessageRange. */
        interface ISyncActionMessageRange {

            /** SyncActionMessageRange lastMessageTimestamp */
            lastMessageTimestamp?: (number|Long|null);

            /** SyncActionMessageRange lastSystemMessageTimestamp */
            lastSystemMessageTimestamp?: (number|Long|null);

            /** SyncActionMessageRange messages */
            messages?: (proto.SyncActionValue.ISyncActionMessage[]|null);
        }

        /** Represents a SyncActionMessageRange. */
        class SyncActionMessageRange implements ISyncActionMessageRange {

            /**
             * Constructs a new SyncActionMessageRange.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ISyncActionMessageRange);

            /** SyncActionMessageRange lastMessageTimestamp. */
            public lastMessageTimestamp: (number|Long);

            /** SyncActionMessageRange lastSystemMessageTimestamp. */
            public lastSystemMessageTimestamp: (number|Long);

            /** SyncActionMessageRange messages. */
            public messages: proto.SyncActionValue.ISyncActionMessage[];

            /**
             * Creates a new SyncActionMessageRange instance using the specified properties.
             * @param [properties] Properties to set
             * @returns SyncActionMessageRange instance
             */
            public static create(properties?: proto.SyncActionValue.ISyncActionMessageRange): proto.SyncActionValue.SyncActionMessageRange;

            /**
             * Encodes the specified SyncActionMessageRange message. Does not implicitly {@link proto.SyncActionValue.SyncActionMessageRange.verify|verify} messages.
             * @param message SyncActionMessageRange message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ISyncActionMessageRange, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified SyncActionMessageRange message, length delimited. Does not implicitly {@link proto.SyncActionValue.SyncActionMessageRange.verify|verify} messages.
             * @param message SyncActionMessageRange message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ISyncActionMessageRange, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a SyncActionMessageRange message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns SyncActionMessageRange
             * @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): proto.SyncActionValue.SyncActionMessageRange;

            /**
             * Decodes a SyncActionMessageRange message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns SyncActionMessageRange
             * @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)): proto.SyncActionValue.SyncActionMessageRange;

            /**
             * Verifies a SyncActionMessageRange 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 SyncActionMessageRange message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns SyncActionMessageRange
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.SyncActionMessageRange;

            /**
             * Creates a plain object from a SyncActionMessageRange message. Also converts values to other types if specified.
             * @param message SyncActionMessageRange
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.SyncActionMessageRange, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this SyncActionMessageRange to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a TimeFormatAction. */
        interface ITimeFormatAction {

            /** TimeFormatAction isTwentyFourHourFormatEnabled */
            isTwentyFourHourFormatEnabled?: (boolean|null);
        }

        /** Represents a TimeFormatAction. */
        class TimeFormatAction implements ITimeFormatAction {

            /**
             * Constructs a new TimeFormatAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.ITimeFormatAction);

            /** TimeFormatAction isTwentyFourHourFormatEnabled. */
            public isTwentyFourHourFormatEnabled: boolean;

            /**
             * Creates a new TimeFormatAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns TimeFormatAction instance
             */
            public static create(properties?: proto.SyncActionValue.ITimeFormatAction): proto.SyncActionValue.TimeFormatAction;

            /**
             * Encodes the specified TimeFormatAction message. Does not implicitly {@link proto.SyncActionValue.TimeFormatAction.verify|verify} messages.
             * @param message TimeFormatAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.ITimeFormatAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified TimeFormatAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.TimeFormatAction.verify|verify} messages.
             * @param message TimeFormatAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.ITimeFormatAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a TimeFormatAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns TimeFormatAction
             * @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): proto.SyncActionValue.TimeFormatAction;

            /**
             * Decodes a TimeFormatAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns TimeFormatAction
             * @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)): proto.SyncActionValue.TimeFormatAction;

            /**
             * Verifies a TimeFormatAction 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 TimeFormatAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns TimeFormatAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.TimeFormatAction;

            /**
             * Creates a plain object from a TimeFormatAction message. Also converts values to other types if specified.
             * @param message TimeFormatAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.TimeFormatAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this TimeFormatAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of an UnarchiveChatsSetting. */
        interface IUnarchiveChatsSetting {

            /** UnarchiveChatsSetting unarchiveChats */
            unarchiveChats?: (boolean|null);
        }

        /** Represents an UnarchiveChatsSetting. */
        class UnarchiveChatsSetting implements IUnarchiveChatsSetting {

            /**
             * Constructs a new UnarchiveChatsSetting.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IUnarchiveChatsSetting);

            /** UnarchiveChatsSetting unarchiveChats. */
            public unarchiveChats: boolean;

            /**
             * Creates a new UnarchiveChatsSetting instance using the specified properties.
             * @param [properties] Properties to set
             * @returns UnarchiveChatsSetting instance
             */
            public static create(properties?: proto.SyncActionValue.IUnarchiveChatsSetting): proto.SyncActionValue.UnarchiveChatsSetting;

            /**
             * Encodes the specified UnarchiveChatsSetting message. Does not implicitly {@link proto.SyncActionValue.UnarchiveChatsSetting.verify|verify} messages.
             * @param message UnarchiveChatsSetting message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IUnarchiveChatsSetting, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified UnarchiveChatsSetting message, length delimited. Does not implicitly {@link proto.SyncActionValue.UnarchiveChatsSetting.verify|verify} messages.
             * @param message UnarchiveChatsSetting message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IUnarchiveChatsSetting, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes an UnarchiveChatsSetting message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns UnarchiveChatsSetting
             * @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): proto.SyncActionValue.UnarchiveChatsSetting;

            /**
             * Decodes an UnarchiveChatsSetting message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns UnarchiveChatsSetting
             * @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)): proto.SyncActionValue.UnarchiveChatsSetting;

            /**
             * Verifies an UnarchiveChatsSetting 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 UnarchiveChatsSetting message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns UnarchiveChatsSetting
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.UnarchiveChatsSetting;

            /**
             * Creates a plain object from an UnarchiveChatsSetting message. Also converts values to other types if specified.
             * @param message UnarchiveChatsSetting
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.UnarchiveChatsSetting, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this UnarchiveChatsSetting to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a UserStatusMuteAction. */
        interface IUserStatusMuteAction {

            /** UserStatusMuteAction muted */
            muted?: (boolean|null);
        }

        /** Represents a UserStatusMuteAction. */
        class UserStatusMuteAction implements IUserStatusMuteAction {

            /**
             * Constructs a new UserStatusMuteAction.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.SyncActionValue.IUserStatusMuteAction);

            /** UserStatusMuteAction muted. */
            public muted: boolean;

            /**
             * Creates a new UserStatusMuteAction instance using the specified properties.
             * @param [properties] Properties to set
             * @returns UserStatusMuteAction instance
             */
            public static create(properties?: proto.SyncActionValue.IUserStatusMuteAction): proto.SyncActionValue.UserStatusMuteAction;

            /**
             * Encodes the specified UserStatusMuteAction message. Does not implicitly {@link proto.SyncActionValue.UserStatusMuteAction.verify|verify} messages.
             * @param message UserStatusMuteAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.SyncActionValue.IUserStatusMuteAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified UserStatusMuteAction message, length delimited. Does not implicitly {@link proto.SyncActionValue.UserStatusMuteAction.verify|verify} messages.
             * @param message UserStatusMuteAction message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.SyncActionValue.IUserStatusMuteAction, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a UserStatusMuteAction message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns UserStatusMuteAction
             * @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): proto.SyncActionValue.UserStatusMuteAction;

            /**
             * Decodes a UserStatusMuteAction message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns UserStatusMuteAction
             * @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)): proto.SyncActionValue.UserStatusMuteAction;

            /**
             * Verifies a UserStatusMuteAction 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 UserStatusMuteAction message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns UserStatusMuteAction
             */
            public static fromObject(object: { [k: string]: any }): proto.SyncActionValue.UserStatusMuteAction;

            /**
             * Creates a plain object from a UserStatusMuteAction message. Also converts values to other types if specified.
             * @param message UserStatusMuteAction
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.SyncActionValue.UserStatusMuteAction, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this UserStatusMuteAction to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }
    }

    /** Properties of a SyncdIndex. */
    interface ISyncdIndex {

        /** SyncdIndex blob */
        blob?: (Uint8Array|null);
    }

    /** Represents a SyncdIndex. */
    class SyncdIndex implements ISyncdIndex {

        /**
         * Constructs a new SyncdIndex.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISyncdIndex);

        /** SyncdIndex blob. */
        public blob: Uint8Array;

        /**
         * Creates a new SyncdIndex instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SyncdIndex instance
         */
        public static create(properties?: proto.ISyncdIndex): proto.SyncdIndex;

        /**
         * Encodes the specified SyncdIndex message. Does not implicitly {@link proto.SyncdIndex.verify|verify} messages.
         * @param message SyncdIndex message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISyncdIndex, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SyncdIndex message, length delimited. Does not implicitly {@link proto.SyncdIndex.verify|verify} messages.
         * @param message SyncdIndex message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISyncdIndex, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SyncdIndex message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SyncdIndex
         * @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): proto.SyncdIndex;

        /**
         * Decodes a SyncdIndex message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SyncdIndex
         * @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)): proto.SyncdIndex;

        /**
         * Verifies a SyncdIndex 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 SyncdIndex message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SyncdIndex
         */
        public static fromObject(object: { [k: string]: any }): proto.SyncdIndex;

        /**
         * Creates a plain object from a SyncdIndex message. Also converts values to other types if specified.
         * @param message SyncdIndex
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SyncdIndex, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SyncdIndex to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SyncdMutation. */
    interface ISyncdMutation {

        /** SyncdMutation operation */
        operation?: (proto.SyncdMutation.SyncdOperation|null);

        /** SyncdMutation record */
        record?: (proto.ISyncdRecord|null);
    }

    /** Represents a SyncdMutation. */
    class SyncdMutation implements ISyncdMutation {

        /**
         * Constructs a new SyncdMutation.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISyncdMutation);

        /** SyncdMutation operation. */
        public operation: proto.SyncdMutation.SyncdOperation;

        /** SyncdMutation record. */
        public record?: (proto.ISyncdRecord|null);

        /**
         * Creates a new SyncdMutation instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SyncdMutation instance
         */
        public static create(properties?: proto.ISyncdMutation): proto.SyncdMutation;

        /**
         * Encodes the specified SyncdMutation message. Does not implicitly {@link proto.SyncdMutation.verify|verify} messages.
         * @param message SyncdMutation message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISyncdMutation, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SyncdMutation message, length delimited. Does not implicitly {@link proto.SyncdMutation.verify|verify} messages.
         * @param message SyncdMutation message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISyncdMutation, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SyncdMutation message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SyncdMutation
         * @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): proto.SyncdMutation;

        /**
         * Decodes a SyncdMutation message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SyncdMutation
         * @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)): proto.SyncdMutation;

        /**
         * Verifies a SyncdMutation 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 SyncdMutation message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SyncdMutation
         */
        public static fromObject(object: { [k: string]: any }): proto.SyncdMutation;

        /**
         * Creates a plain object from a SyncdMutation message. Also converts values to other types if specified.
         * @param message SyncdMutation
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SyncdMutation, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SyncdMutation to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace SyncdMutation {

        /** SyncdOperation enum. */
        enum SyncdOperation {
            SET = 0,
            REMOVE = 1
        }
    }

    /** Properties of a SyncdMutations. */
    interface ISyncdMutations {

        /** SyncdMutations mutations */
        mutations?: (proto.ISyncdMutation[]|null);
    }

    /** Represents a SyncdMutations. */
    class SyncdMutations implements ISyncdMutations {

        /**
         * Constructs a new SyncdMutations.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISyncdMutations);

        /** SyncdMutations mutations. */
        public mutations: proto.ISyncdMutation[];

        /**
         * Creates a new SyncdMutations instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SyncdMutations instance
         */
        public static create(properties?: proto.ISyncdMutations): proto.SyncdMutations;

        /**
         * Encodes the specified SyncdMutations message. Does not implicitly {@link proto.SyncdMutations.verify|verify} messages.
         * @param message SyncdMutations message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISyncdMutations, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SyncdMutations message, length delimited. Does not implicitly {@link proto.SyncdMutations.verify|verify} messages.
         * @param message SyncdMutations message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISyncdMutations, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SyncdMutations message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SyncdMutations
         * @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): proto.SyncdMutations;

        /**
         * Decodes a SyncdMutations message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SyncdMutations
         * @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)): proto.SyncdMutations;

        /**
         * Verifies a SyncdMutations 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 SyncdMutations message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SyncdMutations
         */
        public static fromObject(object: { [k: string]: any }): proto.SyncdMutations;

        /**
         * Creates a plain object from a SyncdMutations message. Also converts values to other types if specified.
         * @param message SyncdMutations
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SyncdMutations, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SyncdMutations to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SyncdPatch. */
    interface ISyncdPatch {

        /** SyncdPatch version */
        version?: (proto.ISyncdVersion|null);

        /** SyncdPatch mutations */
        mutations?: (proto.ISyncdMutation[]|null);

        /** SyncdPatch externalMutations */
        externalMutations?: (proto.IExternalBlobReference|null);

        /** SyncdPatch snapshotMac */
        snapshotMac?: (Uint8Array|null);

        /** SyncdPatch patchMac */
        patchMac?: (Uint8Array|null);

        /** SyncdPatch keyId */
        keyId?: (proto.IKeyId|null);

        /** SyncdPatch exitCode */
        exitCode?: (proto.IExitCode|null);

        /** SyncdPatch deviceIndex */
        deviceIndex?: (number|null);

        /** SyncdPatch clientDebugData */
        clientDebugData?: (Uint8Array|null);
    }

    /** Represents a SyncdPatch. */
    class SyncdPatch implements ISyncdPatch {

        /**
         * Constructs a new SyncdPatch.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISyncdPatch);

        /** SyncdPatch version. */
        public version?: (proto.ISyncdVersion|null);

        /** SyncdPatch mutations. */
        public mutations: proto.ISyncdMutation[];

        /** SyncdPatch externalMutations. */
        public externalMutations?: (proto.IExternalBlobReference|null);

        /** SyncdPatch snapshotMac. */
        public snapshotMac: Uint8Array;

        /** SyncdPatch patchMac. */
        public patchMac: Uint8Array;

        /** SyncdPatch keyId. */
        public keyId?: (proto.IKeyId|null);

        /** SyncdPatch exitCode. */
        public exitCode?: (proto.IExitCode|null);

        /** SyncdPatch deviceIndex. */
        public deviceIndex: number;

        /** SyncdPatch clientDebugData. */
        public clientDebugData: Uint8Array;

        /**
         * Creates a new SyncdPatch instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SyncdPatch instance
         */
        public static create(properties?: proto.ISyncdPatch): proto.SyncdPatch;

        /**
         * Encodes the specified SyncdPatch message. Does not implicitly {@link proto.SyncdPatch.verify|verify} messages.
         * @param message SyncdPatch message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISyncdPatch, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SyncdPatch message, length delimited. Does not implicitly {@link proto.SyncdPatch.verify|verify} messages.
         * @param message SyncdPatch message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISyncdPatch, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SyncdPatch message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SyncdPatch
         * @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): proto.SyncdPatch;

        /**
         * Decodes a SyncdPatch message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SyncdPatch
         * @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)): proto.SyncdPatch;

        /**
         * Verifies a SyncdPatch 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 SyncdPatch message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SyncdPatch
         */
        public static fromObject(object: { [k: string]: any }): proto.SyncdPatch;

        /**
         * Creates a plain object from a SyncdPatch message. Also converts values to other types if specified.
         * @param message SyncdPatch
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SyncdPatch, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SyncdPatch to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SyncdRecord. */
    interface ISyncdRecord {

        /** SyncdRecord index */
        index?: (proto.ISyncdIndex|null);

        /** SyncdRecord value */
        value?: (proto.ISyncdValue|null);

        /** SyncdRecord keyId */
        keyId?: (proto.IKeyId|null);
    }

    /** Represents a SyncdRecord. */
    class SyncdRecord implements ISyncdRecord {

        /**
         * Constructs a new SyncdRecord.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISyncdRecord);

        /** SyncdRecord index. */
        public index?: (proto.ISyncdIndex|null);

        /** SyncdRecord value. */
        public value?: (proto.ISyncdValue|null);

        /** SyncdRecord keyId. */
        public keyId?: (proto.IKeyId|null);

        /**
         * Creates a new SyncdRecord instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SyncdRecord instance
         */
        public static create(properties?: proto.ISyncdRecord): proto.SyncdRecord;

        /**
         * Encodes the specified SyncdRecord message. Does not implicitly {@link proto.SyncdRecord.verify|verify} messages.
         * @param message SyncdRecord message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISyncdRecord, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SyncdRecord message, length delimited. Does not implicitly {@link proto.SyncdRecord.verify|verify} messages.
         * @param message SyncdRecord message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISyncdRecord, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SyncdRecord message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SyncdRecord
         * @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): proto.SyncdRecord;

        /**
         * Decodes a SyncdRecord message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SyncdRecord
         * @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)): proto.SyncdRecord;

        /**
         * Verifies a SyncdRecord 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 SyncdRecord message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SyncdRecord
         */
        public static fromObject(object: { [k: string]: any }): proto.SyncdRecord;

        /**
         * Creates a plain object from a SyncdRecord message. Also converts values to other types if specified.
         * @param message SyncdRecord
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SyncdRecord, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SyncdRecord to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SyncdSnapshot. */
    interface ISyncdSnapshot {

        /** SyncdSnapshot version */
        version?: (proto.ISyncdVersion|null);

        /** SyncdSnapshot records */
        records?: (proto.ISyncdRecord[]|null);

        /** SyncdSnapshot mac */
        mac?: (Uint8Array|null);

        /** SyncdSnapshot keyId */
        keyId?: (proto.IKeyId|null);
    }

    /** Represents a SyncdSnapshot. */
    class SyncdSnapshot implements ISyncdSnapshot {

        /**
         * Constructs a new SyncdSnapshot.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISyncdSnapshot);

        /** SyncdSnapshot version. */
        public version?: (proto.ISyncdVersion|null);

        /** SyncdSnapshot records. */
        public records: proto.ISyncdRecord[];

        /** SyncdSnapshot mac. */
        public mac: Uint8Array;

        /** SyncdSnapshot keyId. */
        public keyId?: (proto.IKeyId|null);

        /**
         * Creates a new SyncdSnapshot instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SyncdSnapshot instance
         */
        public static create(properties?: proto.ISyncdSnapshot): proto.SyncdSnapshot;

        /**
         * Encodes the specified SyncdSnapshot message. Does not implicitly {@link proto.SyncdSnapshot.verify|verify} messages.
         * @param message SyncdSnapshot message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISyncdSnapshot, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SyncdSnapshot message, length delimited. Does not implicitly {@link proto.SyncdSnapshot.verify|verify} messages.
         * @param message SyncdSnapshot message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISyncdSnapshot, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SyncdSnapshot message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SyncdSnapshot
         * @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): proto.SyncdSnapshot;

        /**
         * Decodes a SyncdSnapshot message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SyncdSnapshot
         * @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)): proto.SyncdSnapshot;

        /**
         * Verifies a SyncdSnapshot 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 SyncdSnapshot message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SyncdSnapshot
         */
        public static fromObject(object: { [k: string]: any }): proto.SyncdSnapshot;

        /**
         * Creates a plain object from a SyncdSnapshot message. Also converts values to other types if specified.
         * @param message SyncdSnapshot
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SyncdSnapshot, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SyncdSnapshot to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SyncdValue. */
    interface ISyncdValue {

        /** SyncdValue blob */
        blob?: (Uint8Array|null);
    }

    /** Represents a SyncdValue. */
    class SyncdValue implements ISyncdValue {

        /**
         * Constructs a new SyncdValue.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISyncdValue);

        /** SyncdValue blob. */
        public blob: Uint8Array;

        /**
         * Creates a new SyncdValue instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SyncdValue instance
         */
        public static create(properties?: proto.ISyncdValue): proto.SyncdValue;

        /**
         * Encodes the specified SyncdValue message. Does not implicitly {@link proto.SyncdValue.verify|verify} messages.
         * @param message SyncdValue message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISyncdValue, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SyncdValue message, length delimited. Does not implicitly {@link proto.SyncdValue.verify|verify} messages.
         * @param message SyncdValue message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISyncdValue, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SyncdValue message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SyncdValue
         * @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): proto.SyncdValue;

        /**
         * Decodes a SyncdValue message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SyncdValue
         * @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)): proto.SyncdValue;

        /**
         * Verifies a SyncdValue 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 SyncdValue message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SyncdValue
         */
        public static fromObject(object: { [k: string]: any }): proto.SyncdValue;

        /**
         * Creates a plain object from a SyncdValue message. Also converts values to other types if specified.
         * @param message SyncdValue
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SyncdValue, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SyncdValue to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a SyncdVersion. */
    interface ISyncdVersion {

        /** SyncdVersion version */
        version?: (number|Long|null);
    }

    /** Represents a SyncdVersion. */
    class SyncdVersion implements ISyncdVersion {

        /**
         * Constructs a new SyncdVersion.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ISyncdVersion);

        /** SyncdVersion version. */
        public version: (number|Long);

        /**
         * Creates a new SyncdVersion instance using the specified properties.
         * @param [properties] Properties to set
         * @returns SyncdVersion instance
         */
        public static create(properties?: proto.ISyncdVersion): proto.SyncdVersion;

        /**
         * Encodes the specified SyncdVersion message. Does not implicitly {@link proto.SyncdVersion.verify|verify} messages.
         * @param message SyncdVersion message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ISyncdVersion, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified SyncdVersion message, length delimited. Does not implicitly {@link proto.SyncdVersion.verify|verify} messages.
         * @param message SyncdVersion message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ISyncdVersion, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a SyncdVersion message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns SyncdVersion
         * @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): proto.SyncdVersion;

        /**
         * Decodes a SyncdVersion message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns SyncdVersion
         * @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)): proto.SyncdVersion;

        /**
         * Verifies a SyncdVersion 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 SyncdVersion message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns SyncdVersion
         */
        public static fromObject(object: { [k: string]: any }): proto.SyncdVersion;

        /**
         * Creates a plain object from a SyncdVersion message. Also converts values to other types if specified.
         * @param message SyncdVersion
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.SyncdVersion, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this SyncdVersion to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a TemplateButton. */
    interface ITemplateButton {

        /** TemplateButton index */
        index?: (number|null);

        /** TemplateButton quickReplyButton */
        quickReplyButton?: (proto.TemplateButton.IQuickReplyButton|null);

        /** TemplateButton urlButton */
        urlButton?: (proto.TemplateButton.IURLButton|null);

        /** TemplateButton callButton */
        callButton?: (proto.TemplateButton.ICallButton|null);
    }

    /** Represents a TemplateButton. */
    class TemplateButton implements ITemplateButton {

        /**
         * Constructs a new TemplateButton.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.ITemplateButton);

        /** TemplateButton index. */
        public index: number;

        /** TemplateButton quickReplyButton. */
        public quickReplyButton?: (proto.TemplateButton.IQuickReplyButton|null);

        /** TemplateButton urlButton. */
        public urlButton?: (proto.TemplateButton.IURLButton|null);

        /** TemplateButton callButton. */
        public callButton?: (proto.TemplateButton.ICallButton|null);

        /** TemplateButton button. */
        public button?: ("quickReplyButton"|"urlButton"|"callButton");

        /**
         * Creates a new TemplateButton instance using the specified properties.
         * @param [properties] Properties to set
         * @returns TemplateButton instance
         */
        public static create(properties?: proto.ITemplateButton): proto.TemplateButton;

        /**
         * Encodes the specified TemplateButton message. Does not implicitly {@link proto.TemplateButton.verify|verify} messages.
         * @param message TemplateButton message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.ITemplateButton, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified TemplateButton message, length delimited. Does not implicitly {@link proto.TemplateButton.verify|verify} messages.
         * @param message TemplateButton message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.ITemplateButton, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a TemplateButton message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns TemplateButton
         * @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): proto.TemplateButton;

        /**
         * Decodes a TemplateButton message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns TemplateButton
         * @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)): proto.TemplateButton;

        /**
         * Verifies a TemplateButton 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 TemplateButton message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns TemplateButton
         */
        public static fromObject(object: { [k: string]: any }): proto.TemplateButton;

        /**
         * Creates a plain object from a TemplateButton message. Also converts values to other types if specified.
         * @param message TemplateButton
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.TemplateButton, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this TemplateButton to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace TemplateButton {

        /** Properties of a CallButton. */
        interface ICallButton {

            /** CallButton displayText */
            displayText?: (proto.Message.IHighlyStructuredMessage|null);

            /** CallButton phoneNumber */
            phoneNumber?: (proto.Message.IHighlyStructuredMessage|null);
        }

        /** Represents a CallButton. */
        class CallButton implements ICallButton {

            /**
             * Constructs a new CallButton.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.TemplateButton.ICallButton);

            /** CallButton displayText. */
            public displayText?: (proto.Message.IHighlyStructuredMessage|null);

            /** CallButton phoneNumber. */
            public phoneNumber?: (proto.Message.IHighlyStructuredMessage|null);

            /**
             * Creates a new CallButton instance using the specified properties.
             * @param [properties] Properties to set
             * @returns CallButton instance
             */
            public static create(properties?: proto.TemplateButton.ICallButton): proto.TemplateButton.CallButton;

            /**
             * Encodes the specified CallButton message. Does not implicitly {@link proto.TemplateButton.CallButton.verify|verify} messages.
             * @param message CallButton message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.TemplateButton.ICallButton, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified CallButton message, length delimited. Does not implicitly {@link proto.TemplateButton.CallButton.verify|verify} messages.
             * @param message CallButton message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.TemplateButton.ICallButton, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a CallButton message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns CallButton
             * @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): proto.TemplateButton.CallButton;

            /**
             * Decodes a CallButton message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns CallButton
             * @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)): proto.TemplateButton.CallButton;

            /**
             * Verifies a CallButton 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 CallButton message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns CallButton
             */
            public static fromObject(object: { [k: string]: any }): proto.TemplateButton.CallButton;

            /**
             * Creates a plain object from a CallButton message. Also converts values to other types if specified.
             * @param message CallButton
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.TemplateButton.CallButton, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this CallButton to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a QuickReplyButton. */
        interface IQuickReplyButton {

            /** QuickReplyButton displayText */
            displayText?: (proto.Message.IHighlyStructuredMessage|null);

            /** QuickReplyButton id */
            id?: (string|null);
        }

        /** Represents a QuickReplyButton. */
        class QuickReplyButton implements IQuickReplyButton {

            /**
             * Constructs a new QuickReplyButton.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.TemplateButton.IQuickReplyButton);

            /** QuickReplyButton displayText. */
            public displayText?: (proto.Message.IHighlyStructuredMessage|null);

            /** QuickReplyButton id. */
            public id: string;

            /**
             * Creates a new QuickReplyButton instance using the specified properties.
             * @param [properties] Properties to set
             * @returns QuickReplyButton instance
             */
            public static create(properties?: proto.TemplateButton.IQuickReplyButton): proto.TemplateButton.QuickReplyButton;

            /**
             * Encodes the specified QuickReplyButton message. Does not implicitly {@link proto.TemplateButton.QuickReplyButton.verify|verify} messages.
             * @param message QuickReplyButton message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.TemplateButton.IQuickReplyButton, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified QuickReplyButton message, length delimited. Does not implicitly {@link proto.TemplateButton.QuickReplyButton.verify|verify} messages.
             * @param message QuickReplyButton message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.TemplateButton.IQuickReplyButton, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a QuickReplyButton message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns QuickReplyButton
             * @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): proto.TemplateButton.QuickReplyButton;

            /**
             * Decodes a QuickReplyButton message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns QuickReplyButton
             * @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)): proto.TemplateButton.QuickReplyButton;

            /**
             * Verifies a QuickReplyButton 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 QuickReplyButton message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns QuickReplyButton
             */
            public static fromObject(object: { [k: string]: any }): proto.TemplateButton.QuickReplyButton;

            /**
             * Creates a plain object from a QuickReplyButton message. Also converts values to other types if specified.
             * @param message QuickReplyButton
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.TemplateButton.QuickReplyButton, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this QuickReplyButton to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }

        /** Properties of a URLButton. */
        interface IURLButton {

            /** URLButton displayText */
            displayText?: (proto.Message.IHighlyStructuredMessage|null);

            /** URLButton url */
            url?: (proto.Message.IHighlyStructuredMessage|null);
        }

        /** Represents a URLButton. */
        class URLButton implements IURLButton {

            /**
             * Constructs a new URLButton.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.TemplateButton.IURLButton);

            /** URLButton displayText. */
            public displayText?: (proto.Message.IHighlyStructuredMessage|null);

            /** URLButton url. */
            public url?: (proto.Message.IHighlyStructuredMessage|null);

            /**
             * Creates a new URLButton instance using the specified properties.
             * @param [properties] Properties to set
             * @returns URLButton instance
             */
            public static create(properties?: proto.TemplateButton.IURLButton): proto.TemplateButton.URLButton;

            /**
             * Encodes the specified URLButton message. Does not implicitly {@link proto.TemplateButton.URLButton.verify|verify} messages.
             * @param message URLButton message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.TemplateButton.IURLButton, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified URLButton message, length delimited. Does not implicitly {@link proto.TemplateButton.URLButton.verify|verify} messages.
             * @param message URLButton message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.TemplateButton.IURLButton, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a URLButton message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns URLButton
             * @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): proto.TemplateButton.URLButton;

            /**
             * Decodes a URLButton message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns URLButton
             * @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)): proto.TemplateButton.URLButton;

            /**
             * Verifies a URLButton 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 URLButton message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns URLButton
             */
            public static fromObject(object: { [k: string]: any }): proto.TemplateButton.URLButton;

            /**
             * Creates a plain object from a URLButton message. Also converts values to other types if specified.
             * @param message URLButton
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.TemplateButton.URLButton, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this URLButton to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }
    }

    /** Properties of a UserReceipt. */
    interface IUserReceipt {

        /** UserReceipt userJid */
        userJid: string;

        /** UserReceipt receiptTimestamp */
        receiptTimestamp?: (number|Long|null);

        /** UserReceipt readTimestamp */
        readTimestamp?: (number|Long|null);

        /** UserReceipt playedTimestamp */
        playedTimestamp?: (number|Long|null);

        /** UserReceipt pendingDeviceJid */
        pendingDeviceJid?: (string[]|null);

        /** UserReceipt deliveredDeviceJid */
        deliveredDeviceJid?: (string[]|null);
    }

    /** Represents a UserReceipt. */
    class UserReceipt implements IUserReceipt {

        /**
         * Constructs a new UserReceipt.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IUserReceipt);

        /** UserReceipt userJid. */
        public userJid: string;

        /** UserReceipt receiptTimestamp. */
        public receiptTimestamp: (number|Long);

        /** UserReceipt readTimestamp. */
        public readTimestamp: (number|Long);

        /** UserReceipt playedTimestamp. */
        public playedTimestamp: (number|Long);

        /** UserReceipt pendingDeviceJid. */
        public pendingDeviceJid: string[];

        /** UserReceipt deliveredDeviceJid. */
        public deliveredDeviceJid: string[];

        /**
         * Creates a new UserReceipt instance using the specified properties.
         * @param [properties] Properties to set
         * @returns UserReceipt instance
         */
        public static create(properties?: proto.IUserReceipt): proto.UserReceipt;

        /**
         * Encodes the specified UserReceipt message. Does not implicitly {@link proto.UserReceipt.verify|verify} messages.
         * @param message UserReceipt message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IUserReceipt, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified UserReceipt message, length delimited. Does not implicitly {@link proto.UserReceipt.verify|verify} messages.
         * @param message UserReceipt message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IUserReceipt, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a UserReceipt message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns UserReceipt
         * @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): proto.UserReceipt;

        /**
         * Decodes a UserReceipt message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns UserReceipt
         * @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)): proto.UserReceipt;

        /**
         * Verifies a UserReceipt 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 UserReceipt message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns UserReceipt
         */
        public static fromObject(object: { [k: string]: any }): proto.UserReceipt;

        /**
         * Creates a plain object from a UserReceipt message. Also converts values to other types if specified.
         * @param message UserReceipt
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.UserReceipt, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this UserReceipt to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a VerifiedNameCertificate. */
    interface IVerifiedNameCertificate {

        /** VerifiedNameCertificate details */
        details?: (Uint8Array|null);

        /** VerifiedNameCertificate signature */
        signature?: (Uint8Array|null);

        /** VerifiedNameCertificate serverSignature */
        serverSignature?: (Uint8Array|null);
    }

    /** Represents a VerifiedNameCertificate. */
    class VerifiedNameCertificate implements IVerifiedNameCertificate {

        /**
         * Constructs a new VerifiedNameCertificate.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IVerifiedNameCertificate);

        /** VerifiedNameCertificate details. */
        public details: Uint8Array;

        /** VerifiedNameCertificate signature. */
        public signature: Uint8Array;

        /** VerifiedNameCertificate serverSignature. */
        public serverSignature: Uint8Array;

        /**
         * Creates a new VerifiedNameCertificate instance using the specified properties.
         * @param [properties] Properties to set
         * @returns VerifiedNameCertificate instance
         */
        public static create(properties?: proto.IVerifiedNameCertificate): proto.VerifiedNameCertificate;

        /**
         * Encodes the specified VerifiedNameCertificate message. Does not implicitly {@link proto.VerifiedNameCertificate.verify|verify} messages.
         * @param message VerifiedNameCertificate message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IVerifiedNameCertificate, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified VerifiedNameCertificate message, length delimited. Does not implicitly {@link proto.VerifiedNameCertificate.verify|verify} messages.
         * @param message VerifiedNameCertificate message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IVerifiedNameCertificate, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a VerifiedNameCertificate message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns VerifiedNameCertificate
         * @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): proto.VerifiedNameCertificate;

        /**
         * Decodes a VerifiedNameCertificate message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns VerifiedNameCertificate
         * @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)): proto.VerifiedNameCertificate;

        /**
         * Verifies a VerifiedNameCertificate 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 VerifiedNameCertificate message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns VerifiedNameCertificate
         */
        public static fromObject(object: { [k: string]: any }): proto.VerifiedNameCertificate;

        /**
         * Creates a plain object from a VerifiedNameCertificate message. Also converts values to other types if specified.
         * @param message VerifiedNameCertificate
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.VerifiedNameCertificate, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this VerifiedNameCertificate to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace VerifiedNameCertificate {

        /** Properties of a Details. */
        interface IDetails {

            /** Details serial */
            serial?: (number|Long|null);

            /** Details issuer */
            issuer?: (string|null);

            /** Details verifiedName */
            verifiedName?: (string|null);

            /** Details localizedNames */
            localizedNames?: (proto.ILocalizedName[]|null);

            /** Details issueTime */
            issueTime?: (number|Long|null);
        }

        /** Represents a Details. */
        class Details implements IDetails {

            /**
             * Constructs a new Details.
             * @param [properties] Properties to set
             */
            constructor(properties?: proto.VerifiedNameCertificate.IDetails);

            /** Details serial. */
            public serial: (number|Long);

            /** Details issuer. */
            public issuer: string;

            /** Details verifiedName. */
            public verifiedName: string;

            /** Details localizedNames. */
            public localizedNames: proto.ILocalizedName[];

            /** Details issueTime. */
            public issueTime: (number|Long);

            /**
             * Creates a new Details instance using the specified properties.
             * @param [properties] Properties to set
             * @returns Details instance
             */
            public static create(properties?: proto.VerifiedNameCertificate.IDetails): proto.VerifiedNameCertificate.Details;

            /**
             * Encodes the specified Details message. Does not implicitly {@link proto.VerifiedNameCertificate.Details.verify|verify} messages.
             * @param message Details message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encode(message: proto.VerifiedNameCertificate.IDetails, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified Details message, length delimited. Does not implicitly {@link proto.VerifiedNameCertificate.Details.verify|verify} messages.
             * @param message Details message or plain object to encode
             * @param [writer] Writer to encode to
             * @returns Writer
             */
            public static encodeDelimited(message: proto.VerifiedNameCertificate.IDetails, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Decodes a Details message from the specified reader or buffer.
             * @param reader Reader or buffer to decode from
             * @param [length] Message length if known beforehand
             * @returns Details
             * @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): proto.VerifiedNameCertificate.Details;

            /**
             * Decodes a Details message from the specified reader or buffer, length delimited.
             * @param reader Reader or buffer to decode from
             * @returns Details
             * @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)): proto.VerifiedNameCertificate.Details;

            /**
             * Verifies a Details 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 Details message from a plain object. Also converts values to their respective internal types.
             * @param object Plain object
             * @returns Details
             */
            public static fromObject(object: { [k: string]: any }): proto.VerifiedNameCertificate.Details;

            /**
             * Creates a plain object from a Details message. Also converts values to other types if specified.
             * @param message Details
             * @param [options] Conversion options
             * @returns Plain object
             */
            public static toObject(message: proto.VerifiedNameCertificate.Details, options?: $protobuf.IConversionOptions): { [k: string]: any };

            /**
             * Converts this Details to JSON.
             * @returns JSON object
             */
            public toJSON(): { [k: string]: any };
        }
    }

    /** Properties of a WallpaperSettings. */
    interface IWallpaperSettings {

        /** WallpaperSettings filename */
        filename?: (string|null);

        /** WallpaperSettings opacity */
        opacity?: (number|null);
    }

    /** Represents a WallpaperSettings. */
    class WallpaperSettings implements IWallpaperSettings {

        /**
         * Constructs a new WallpaperSettings.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IWallpaperSettings);

        /** WallpaperSettings filename. */
        public filename: string;

        /** WallpaperSettings opacity. */
        public opacity: number;

        /**
         * Creates a new WallpaperSettings instance using the specified properties.
         * @param [properties] Properties to set
         * @returns WallpaperSettings instance
         */
        public static create(properties?: proto.IWallpaperSettings): proto.WallpaperSettings;

        /**
         * Encodes the specified WallpaperSettings message. Does not implicitly {@link proto.WallpaperSettings.verify|verify} messages.
         * @param message WallpaperSettings message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IWallpaperSettings, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified WallpaperSettings message, length delimited. Does not implicitly {@link proto.WallpaperSettings.verify|verify} messages.
         * @param message WallpaperSettings message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IWallpaperSettings, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a WallpaperSettings message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns WallpaperSettings
         * @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): proto.WallpaperSettings;

        /**
         * Decodes a WallpaperSettings message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns WallpaperSettings
         * @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)): proto.WallpaperSettings;

        /**
         * Verifies a WallpaperSettings 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 WallpaperSettings message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns WallpaperSettings
         */
        public static fromObject(object: { [k: string]: any }): proto.WallpaperSettings;

        /**
         * Creates a plain object from a WallpaperSettings message. Also converts values to other types if specified.
         * @param message WallpaperSettings
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.WallpaperSettings, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this WallpaperSettings to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    /** Properties of a WebFeatures. */
    interface IWebFeatures {

        /** WebFeatures labelsDisplay */
        labelsDisplay?: (proto.WebFeatures.Flag|null);

        /** WebFeatures voipIndividualOutgoing */
        voipIndividualOutgoing?: (proto.WebFeatures.Flag|null);

        /** WebFeatures groupsV3 */
        groupsV3?: (proto.WebFeatures.Flag|null);

        /** WebFeatures groupsV3Create */
        groupsV3Create?: (proto.WebFeatures.Flag|null);

        /** WebFeatures changeNumberV2 */
        changeNumberV2?: (proto.WebFeatures.Flag|null);

        /** WebFeatures queryStatusV3Thumbnail */
        queryStatusV3Thumbnail?: (proto.WebFeatures.Flag|null);

        /** WebFeatures liveLocations */
        liveLocations?: (proto.WebFeatures.Flag|null);

        /** WebFeatures queryVname */
        queryVname?: (proto.WebFeatures.Flag|null);

        /** WebFeatures voipIndividualIncoming */
        voipIndividualIncoming?: (proto.WebFeatures.Flag|null);

        /** WebFeatures quickRepliesQuery */
        quickRepliesQuery?: (proto.WebFeatures.Flag|null);

        /** WebFeatures payments */
        payments?: (proto.WebFeatures.Flag|null);

        /** WebFeatures stickerPackQuery */
        stickerPackQuery?: (proto.WebFeatures.Flag|null);

        /** WebFeatures liveLocationsFinal */
        liveLocationsFinal?: (proto.WebFeatures.Flag|null);

        /** WebFeatures labelsEdit */
        labelsEdit?: (proto.WebFeatures.Flag|null);

        /** WebFeatures mediaUpload */
        mediaUpload?: (proto.WebFeatures.Flag|null);

        /** WebFeatures mediaUploadRichQuickReplies */
        mediaUploadRichQuickReplies?: (proto.WebFeatures.Flag|null);

        /** WebFeatures vnameV2 */
        vnameV2?: (proto.WebFeatures.Flag|null);

        /** WebFeatures videoPlaybackUrl */
        videoPlaybackUrl?: (proto.WebFeatures.Flag|null);

        /** WebFeatures statusRanking */
        statusRanking?: (proto.WebFeatures.Flag|null);

        /** WebFeatures voipIndividualVideo */
        voipIndividualVideo?: (proto.WebFeatures.Flag|null);

        /** WebFeatures thirdPartyStickers */
        thirdPartyStickers?: (proto.WebFeatures.Flag|null);

        /** WebFeatures frequentlyForwardedSetting */
        frequentlyForwardedSetting?: (proto.WebFeatures.Flag|null);

        /** WebFeatures groupsV4JoinPermission */
        groupsV4JoinPermission?: (proto.WebFeatures.Flag|null);

        /** WebFeatures recentStickers */
        recentStickers?: (proto.WebFeatures.Flag|null);

        /** WebFeatures catalog */
        catalog?: (proto.WebFeatures.Flag|null);

        /** WebFeatures starredStickers */
        starredStickers?: (proto.WebFeatures.Flag|null);

        /** WebFeatures voipGroupCall */
        voipGroupCall?: (proto.WebFeatures.Flag|null);

        /** WebFeatures templateMessage */
        templateMessage?: (proto.WebFeatures.Flag|null);

        /** WebFeatures templateMessageInteractivity */
        templateMessageInteractivity?: (proto.WebFeatures.Flag|null);

        /** WebFeatures ephemeralMessages */
        ephemeralMessages?: (proto.WebFeatures.Flag|null);

        /** WebFeatures e2ENotificationSync */
        e2ENotificationSync?: (proto.WebFeatures.Flag|null);

        /** WebFeatures recentStickersV2 */
        recentStickersV2?: (proto.WebFeatures.Flag|null);

        /** WebFeatures recentStickersV3 */
        recentStickersV3?: (proto.WebFeatures.Flag|null);

        /** WebFeatures userNotice */
        userNotice?: (proto.WebFeatures.Flag|null);

        /** WebFeatures support */
        support?: (proto.WebFeatures.Flag|null);

        /** WebFeatures groupUiiCleanup */
        groupUiiCleanup?: (proto.WebFeatures.Flag|null);

        /** WebFeatures groupDogfoodingInternalOnly */
        groupDogfoodingInternalOnly?: (proto.WebFeatures.Flag|null);

        /** WebFeatures settingsSync */
        settingsSync?: (proto.WebFeatures.Flag|null);

        /** WebFeatures archiveV2 */
        archiveV2?: (proto.WebFeatures.Flag|null);

        /** WebFeatures ephemeralAllowGroupMembers */
        ephemeralAllowGroupMembers?: (proto.WebFeatures.Flag|null);

        /** WebFeatures ephemeral24HDuration */
        ephemeral24HDuration?: (proto.WebFeatures.Flag|null);

        /** WebFeatures mdForceUpgrade */
        mdForceUpgrade?: (proto.WebFeatures.Flag|null);

        /** WebFeatures disappearingMode */
        disappearingMode?: (proto.WebFeatures.Flag|null);

        /** WebFeatures externalMdOptInAvailable */
        externalMdOptInAvailable?: (proto.WebFeatures.Flag|null);

        /** WebFeatures noDeleteMessageTimeLimit */
        noDeleteMessageTimeLimit?: (proto.WebFeatures.Flag|null);
    }

    /** Represents a WebFeatures. */
    class WebFeatures implements IWebFeatures {

        /**
         * Constructs a new WebFeatures.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IWebFeatures);

        /** WebFeatures labelsDisplay. */
        public labelsDisplay: proto.WebFeatures.Flag;

        /** WebFeatures voipIndividualOutgoing. */
        public voipIndividualOutgoing: proto.WebFeatures.Flag;

        /** WebFeatures groupsV3. */
        public groupsV3: proto.WebFeatures.Flag;

        /** WebFeatures groupsV3Create. */
        public groupsV3Create: proto.WebFeatures.Flag;

        /** WebFeatures changeNumberV2. */
        public changeNumberV2: proto.WebFeatures.Flag;

        /** WebFeatures queryStatusV3Thumbnail. */
        public queryStatusV3Thumbnail: proto.WebFeatures.Flag;

        /** WebFeatures liveLocations. */
        public liveLocations: proto.WebFeatures.Flag;

        /** WebFeatures queryVname. */
        public queryVname: proto.WebFeatures.Flag;

        /** WebFeatures voipIndividualIncoming. */
        public voipIndividualIncoming: proto.WebFeatures.Flag;

        /** WebFeatures quickRepliesQuery. */
        public quickRepliesQuery: proto.WebFeatures.Flag;

        /** WebFeatures payments. */
        public payments: proto.WebFeatures.Flag;

        /** WebFeatures stickerPackQuery. */
        public stickerPackQuery: proto.WebFeatures.Flag;

        /** WebFeatures liveLocationsFinal. */
        public liveLocationsFinal: proto.WebFeatures.Flag;

        /** WebFeatures labelsEdit. */
        public labelsEdit: proto.WebFeatures.Flag;

        /** WebFeatures mediaUpload. */
        public mediaUpload: proto.WebFeatures.Flag;

        /** WebFeatures mediaUploadRichQuickReplies. */
        public mediaUploadRichQuickReplies: proto.WebFeatures.Flag;

        /** WebFeatures vnameV2. */
        public vnameV2: proto.WebFeatures.Flag;

        /** WebFeatures videoPlaybackUrl. */
        public videoPlaybackUrl: proto.WebFeatures.Flag;

        /** WebFeatures statusRanking. */
        public statusRanking: proto.WebFeatures.Flag;

        /** WebFeatures voipIndividualVideo. */
        public voipIndividualVideo: proto.WebFeatures.Flag;

        /** WebFeatures thirdPartyStickers. */
        public thirdPartyStickers: proto.WebFeatures.Flag;

        /** WebFeatures frequentlyForwardedSetting. */
        public frequentlyForwardedSetting: proto.WebFeatures.Flag;

        /** WebFeatures groupsV4JoinPermission. */
        public groupsV4JoinPermission: proto.WebFeatures.Flag;

        /** WebFeatures recentStickers. */
        public recentStickers: proto.WebFeatures.Flag;

        /** WebFeatures catalog. */
        public catalog: proto.WebFeatures.Flag;

        /** WebFeatures starredStickers. */
        public starredStickers: proto.WebFeatures.Flag;

        /** WebFeatures voipGroupCall. */
        public voipGroupCall: proto.WebFeatures.Flag;

        /** WebFeatures templateMessage. */
        public templateMessage: proto.WebFeatures.Flag;

        /** WebFeatures templateMessageInteractivity. */
        public templateMessageInteractivity: proto.WebFeatures.Flag;

        /** WebFeatures ephemeralMessages. */
        public ephemeralMessages: proto.WebFeatures.Flag;

        /** WebFeatures e2ENotificationSync. */
        public e2ENotificationSync: proto.WebFeatures.Flag;

        /** WebFeatures recentStickersV2. */
        public recentStickersV2: proto.WebFeatures.Flag;

        /** WebFeatures recentStickersV3. */
        public recentStickersV3: proto.WebFeatures.Flag;

        /** WebFeatures userNotice. */
        public userNotice: proto.WebFeatures.Flag;

        /** WebFeatures support. */
        public support: proto.WebFeatures.Flag;

        /** WebFeatures groupUiiCleanup. */
        public groupUiiCleanup: proto.WebFeatures.Flag;

        /** WebFeatures groupDogfoodingInternalOnly. */
        public groupDogfoodingInternalOnly: proto.WebFeatures.Flag;

        /** WebFeatures settingsSync. */
        public settingsSync: proto.WebFeatures.Flag;

        /** WebFeatures archiveV2. */
        public archiveV2: proto.WebFeatures.Flag;

        /** WebFeatures ephemeralAllowGroupMembers. */
        public ephemeralAllowGroupMembers: proto.WebFeatures.Flag;

        /** WebFeatures ephemeral24HDuration. */
        public ephemeral24HDuration: proto.WebFeatures.Flag;

        /** WebFeatures mdForceUpgrade. */
        public mdForceUpgrade: proto.WebFeatures.Flag;

        /** WebFeatures disappearingMode. */
        public disappearingMode: proto.WebFeatures.Flag;

        /** WebFeatures externalMdOptInAvailable. */
        public externalMdOptInAvailable: proto.WebFeatures.Flag;

        /** WebFeatures noDeleteMessageTimeLimit. */
        public noDeleteMessageTimeLimit: proto.WebFeatures.Flag;

        /**
         * Creates a new WebFeatures instance using the specified properties.
         * @param [properties] Properties to set
         * @returns WebFeatures instance
         */
        public static create(properties?: proto.IWebFeatures): proto.WebFeatures;

        /**
         * Encodes the specified WebFeatures message. Does not implicitly {@link proto.WebFeatures.verify|verify} messages.
         * @param message WebFeatures message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IWebFeatures, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified WebFeatures message, length delimited. Does not implicitly {@link proto.WebFeatures.verify|verify} messages.
         * @param message WebFeatures message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IWebFeatures, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a WebFeatures message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns WebFeatures
         * @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): proto.WebFeatures;

        /**
         * Decodes a WebFeatures message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns WebFeatures
         * @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)): proto.WebFeatures;

        /**
         * Verifies a WebFeatures 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 WebFeatures message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns WebFeatures
         */
        public static fromObject(object: { [k: string]: any }): proto.WebFeatures;

        /**
         * Creates a plain object from a WebFeatures message. Also converts values to other types if specified.
         * @param message WebFeatures
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.WebFeatures, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this WebFeatures to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace WebFeatures {

        /** Flag enum. */
        enum Flag {
            NOT_STARTED = 0,
            FORCE_UPGRADE = 1,
            DEVELOPMENT = 2,
            PRODUCTION = 3
        }
    }

    /** Properties of a WebMessageInfo. */
    interface IWebMessageInfo {

        /** WebMessageInfo key */
        key: proto.IMessageKey;

        /** WebMessageInfo message */
        message?: (proto.IMessage|null);

        /** WebMessageInfo messageTimestamp */
        messageTimestamp?: (number|Long|null);

        /** WebMessageInfo status */
        status?: (proto.WebMessageInfo.Status|null);

        /** WebMessageInfo participant */
        participant?: (string|null);

        /** WebMessageInfo messageC2STimestamp */
        messageC2STimestamp?: (number|Long|null);

        /** WebMessageInfo ignore */
        ignore?: (boolean|null);

        /** WebMessageInfo starred */
        starred?: (boolean|null);

        /** WebMessageInfo broadcast */
        broadcast?: (boolean|null);

        /** WebMessageInfo pushName */
        pushName?: (string|null);

        /** WebMessageInfo mediaCiphertextSha256 */
        mediaCiphertextSha256?: (Uint8Array|null);

        /** WebMessageInfo multicast */
        multicast?: (boolean|null);

        /** WebMessageInfo urlText */
        urlText?: (boolean|null);

        /** WebMessageInfo urlNumber */
        urlNumber?: (boolean|null);

        /** WebMessageInfo messageStubType */
        messageStubType?: (proto.WebMessageInfo.StubType|null);

        /** WebMessageInfo clearMedia */
        clearMedia?: (boolean|null);

        /** WebMessageInfo messageStubParameters */
        messageStubParameters?: (string[]|null);

        /** WebMessageInfo duration */
        duration?: (number|null);

        /** WebMessageInfo labels */
        labels?: (string[]|null);

        /** WebMessageInfo paymentInfo */
        paymentInfo?: (proto.IPaymentInfo|null);

        /** WebMessageInfo finalLiveLocation */
        finalLiveLocation?: (proto.Message.ILiveLocationMessage|null);

        /** WebMessageInfo quotedPaymentInfo */
        quotedPaymentInfo?: (proto.IPaymentInfo|null);

        /** WebMessageInfo ephemeralStartTimestamp */
        ephemeralStartTimestamp?: (number|Long|null);

        /** WebMessageInfo ephemeralDuration */
        ephemeralDuration?: (number|null);

        /** WebMessageInfo ephemeralOffToOn */
        ephemeralOffToOn?: (boolean|null);

        /** WebMessageInfo ephemeralOutOfSync */
        ephemeralOutOfSync?: (boolean|null);

        /** WebMessageInfo bizPrivacyStatus */
        bizPrivacyStatus?: (proto.WebMessageInfo.BizPrivacyStatus|null);

        /** WebMessageInfo verifiedBizName */
        verifiedBizName?: (string|null);

        /** WebMessageInfo mediaData */
        mediaData?: (proto.IMediaData|null);

        /** WebMessageInfo photoChange */
        photoChange?: (proto.IPhotoChange|null);

        /** WebMessageInfo userReceipt */
        userReceipt?: (proto.IUserReceipt[]|null);

        /** WebMessageInfo reactions */
        reactions?: (proto.IReaction[]|null);

        /** WebMessageInfo quotedStickerData */
        quotedStickerData?: (proto.IMediaData|null);

        /** WebMessageInfo futureproofData */
        futureproofData?: (Uint8Array|null);

        /** WebMessageInfo statusPsa */
        statusPsa?: (proto.IStatusPSA|null);

        /** WebMessageInfo pollUpdates */
        pollUpdates?: (proto.IPollUpdate[]|null);

        /** WebMessageInfo pollAdditionalMetadata */
        pollAdditionalMetadata?: (proto.IPollAdditionalMetadata|null);

        /** WebMessageInfo agentId */
        agentId?: (string|null);

        /** WebMessageInfo statusAlreadyViewed */
        statusAlreadyViewed?: (boolean|null);

        /** WebMessageInfo messageSecret */
        messageSecret?: (Uint8Array|null);

        /** WebMessageInfo keepInChat */
        keepInChat?: (proto.IKeepInChat|null);

        /** WebMessageInfo originalSelfAuthorUserJidString */
        originalSelfAuthorUserJidString?: (string|null);

        /** WebMessageInfo revokeMessageTimestamp */
        revokeMessageTimestamp?: (number|Long|null);

        /** WebMessageInfo pinInChat */
        pinInChat?: (proto.IPinInChat|null);

        /** WebMessageInfo premiumMessageInfo */
        premiumMessageInfo?: (proto.IPremiumMessageInfo|null);

        /** WebMessageInfo is1PBizBotMessage */
        is1PBizBotMessage?: (boolean|null);

        /** WebMessageInfo isGroupHistoryMessage */
        isGroupHistoryMessage?: (boolean|null);

        /** WebMessageInfo botMessageInvokerJid */
        botMessageInvokerJid?: (string|null);

        /** WebMessageInfo commentMetadata */
        commentMetadata?: (proto.ICommentMetadata|null);

        /** WebMessageInfo eventResponses */
        eventResponses?: (proto.IEventResponse[]|null);

        /** WebMessageInfo reportingTokenInfo */
        reportingTokenInfo?: (proto.IReportingTokenInfo|null);

        /** WebMessageInfo newsletterServerId */
        newsletterServerId?: (number|Long|null);
    }

    /** Represents a WebMessageInfo. */
    class WebMessageInfo implements IWebMessageInfo {

        /**
         * Constructs a new WebMessageInfo.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IWebMessageInfo);

        /** WebMessageInfo key. */
        public key: proto.IMessageKey;

        /** WebMessageInfo message. */
        public message?: (proto.IMessage|null);

        /** WebMessageInfo messageTimestamp. */
        public messageTimestamp: (number|Long);

        /** WebMessageInfo status. */
        public status: proto.WebMessageInfo.Status;

        /** WebMessageInfo participant. */
        public participant: string;

        /** WebMessageInfo messageC2STimestamp. */
        public messageC2STimestamp: (number|Long);

        /** WebMessageInfo ignore. */
        public ignore: boolean;

        /** WebMessageInfo starred. */
        public starred: boolean;

        /** WebMessageInfo broadcast. */
        public broadcast: boolean;

        /** WebMessageInfo pushName. */
        public pushName: string;

        /** WebMessageInfo mediaCiphertextSha256. */
        public mediaCiphertextSha256: Uint8Array;

        /** WebMessageInfo multicast. */
        public multicast: boolean;

        /** WebMessageInfo urlText. */
        public urlText: boolean;

        /** WebMessageInfo urlNumber. */
        public urlNumber: boolean;

        /** WebMessageInfo messageStubType. */
        public messageStubType: proto.WebMessageInfo.StubType;

        /** WebMessageInfo clearMedia. */
        public clearMedia: boolean;

        /** WebMessageInfo messageStubParameters. */
        public messageStubParameters: string[];

        /** WebMessageInfo duration. */
        public duration: number;

        /** WebMessageInfo labels. */
        public labels: string[];

        /** WebMessageInfo paymentInfo. */
        public paymentInfo?: (proto.IPaymentInfo|null);

        /** WebMessageInfo finalLiveLocation. */
        public finalLiveLocation?: (proto.Message.ILiveLocationMessage|null);

        /** WebMessageInfo quotedPaymentInfo. */
        public quotedPaymentInfo?: (proto.IPaymentInfo|null);

        /** WebMessageInfo ephemeralStartTimestamp. */
        public ephemeralStartTimestamp: (number|Long);

        /** WebMessageInfo ephemeralDuration. */
        public ephemeralDuration: number;

        /** WebMessageInfo ephemeralOffToOn. */
        public ephemeralOffToOn: boolean;

        /** WebMessageInfo ephemeralOutOfSync. */
        public ephemeralOutOfSync: boolean;

        /** WebMessageInfo bizPrivacyStatus. */
        public bizPrivacyStatus: proto.WebMessageInfo.BizPrivacyStatus;

        /** WebMessageInfo verifiedBizName. */
        public verifiedBizName: string;

        /** WebMessageInfo mediaData. */
        public mediaData?: (proto.IMediaData|null);

        /** WebMessageInfo photoChange. */
        public photoChange?: (proto.IPhotoChange|null);

        /** WebMessageInfo userReceipt. */
        public userReceipt: proto.IUserReceipt[];

        /** WebMessageInfo reactions. */
        public reactions: proto.IReaction[];

        /** WebMessageInfo quotedStickerData. */
        public quotedStickerData?: (proto.IMediaData|null);

        /** WebMessageInfo futureproofData. */
        public futureproofData: Uint8Array;

        /** WebMessageInfo statusPsa. */
        public statusPsa?: (proto.IStatusPSA|null);

        /** WebMessageInfo pollUpdates. */
        public pollUpdates: proto.IPollUpdate[];

        /** WebMessageInfo pollAdditionalMetadata. */
        public pollAdditionalMetadata?: (proto.IPollAdditionalMetadata|null);

        /** WebMessageInfo agentId. */
        public agentId: string;

        /** WebMessageInfo statusAlreadyViewed. */
        public statusAlreadyViewed: boolean;

        /** WebMessageInfo messageSecret. */
        public messageSecret: Uint8Array;

        /** WebMessageInfo keepInChat. */
        public keepInChat?: (proto.IKeepInChat|null);

        /** WebMessageInfo originalSelfAuthorUserJidString. */
        public originalSelfAuthorUserJidString: string;

        /** WebMessageInfo revokeMessageTimestamp. */
        public revokeMessageTimestamp: (number|Long);

        /** WebMessageInfo pinInChat. */
        public pinInChat?: (proto.IPinInChat|null);

        /** WebMessageInfo premiumMessageInfo. */
        public premiumMessageInfo?: (proto.IPremiumMessageInfo|null);

        /** WebMessageInfo is1PBizBotMessage. */
        public is1PBizBotMessage: boolean;

        /** WebMessageInfo isGroupHistoryMessage. */
        public isGroupHistoryMessage: boolean;

        /** WebMessageInfo botMessageInvokerJid. */
        public botMessageInvokerJid: string;

        /** WebMessageInfo commentMetadata. */
        public commentMetadata?: (proto.ICommentMetadata|null);

        /** WebMessageInfo eventResponses. */
        public eventResponses: proto.IEventResponse[];

        /** WebMessageInfo reportingTokenInfo. */
        public reportingTokenInfo?: (proto.IReportingTokenInfo|null);

        /** WebMessageInfo newsletterServerId. */
        public newsletterServerId: (number|Long);

        /**
         * Creates a new WebMessageInfo instance using the specified properties.
         * @param [properties] Properties to set
         * @returns WebMessageInfo instance
         */
        public static create(properties?: proto.IWebMessageInfo): proto.WebMessageInfo;

        /**
         * Encodes the specified WebMessageInfo message. Does not implicitly {@link proto.WebMessageInfo.verify|verify} messages.
         * @param message WebMessageInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IWebMessageInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified WebMessageInfo message, length delimited. Does not implicitly {@link proto.WebMessageInfo.verify|verify} messages.
         * @param message WebMessageInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IWebMessageInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a WebMessageInfo message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns WebMessageInfo
         * @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): proto.WebMessageInfo;

        /**
         * Decodes a WebMessageInfo message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns WebMessageInfo
         * @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)): proto.WebMessageInfo;

        /**
         * Verifies a WebMessageInfo 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 WebMessageInfo message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns WebMessageInfo
         */
        public static fromObject(object: { [k: string]: any }): proto.WebMessageInfo;

        /**
         * Creates a plain object from a WebMessageInfo message. Also converts values to other types if specified.
         * @param message WebMessageInfo
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.WebMessageInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this WebMessageInfo to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }

    namespace WebMessageInfo {

        /** BizPrivacyStatus enum. */
        enum BizPrivacyStatus {
            E2EE = 0,
            FB = 2,
            BSP = 1,
            BSP_AND_FB = 3
        }

        /** Status enum. */
        enum Status {
            ERROR = 0,
            PENDING = 1,
            SERVER_ACK = 2,
            DELIVERY_ACK = 3,
            READ = 4,
            PLAYED = 5
        }

        /** StubType enum. */
        enum StubType {
            UNKNOWN = 0,
            REVOKE = 1,
            CIPHERTEXT = 2,
            FUTUREPROOF = 3,
            NON_VERIFIED_TRANSITION = 4,
            UNVERIFIED_TRANSITION = 5,
            VERIFIED_TRANSITION = 6,
            VERIFIED_LOW_UNKNOWN = 7,
            VERIFIED_HIGH = 8,
            VERIFIED_INITIAL_UNKNOWN = 9,
            VERIFIED_INITIAL_LOW = 10,
            VERIFIED_INITIAL_HIGH = 11,
            VERIFIED_TRANSITION_ANY_TO_NONE = 12,
            VERIFIED_TRANSITION_ANY_TO_HIGH = 13,
            VERIFIED_TRANSITION_HIGH_TO_LOW = 14,
            VERIFIED_TRANSITION_HIGH_TO_UNKNOWN = 15,
            VERIFIED_TRANSITION_UNKNOWN_TO_LOW = 16,
            VERIFIED_TRANSITION_LOW_TO_UNKNOWN = 17,
            VERIFIED_TRANSITION_NONE_TO_LOW = 18,
            VERIFIED_TRANSITION_NONE_TO_UNKNOWN = 19,
            GROUP_CREATE = 20,
            GROUP_CHANGE_SUBJECT = 21,
            GROUP_CHANGE_ICON = 22,
            GROUP_CHANGE_INVITE_LINK = 23,
            GROUP_CHANGE_DESCRIPTION = 24,
            GROUP_CHANGE_RESTRICT = 25,
            GROUP_CHANGE_ANNOUNCE = 26,
            GROUP_PARTICIPANT_ADD = 27,
            GROUP_PARTICIPANT_REMOVE = 28,
            GROUP_PARTICIPANT_PROMOTE = 29,
            GROUP_PARTICIPANT_DEMOTE = 30,
            GROUP_PARTICIPANT_INVITE = 31,
            GROUP_PARTICIPANT_LEAVE = 32,
            GROUP_PARTICIPANT_CHANGE_NUMBER = 33,
            BROADCAST_CREATE = 34,
            BROADCAST_ADD = 35,
            BROADCAST_REMOVE = 36,
            GENERIC_NOTIFICATION = 37,
            E2E_IDENTITY_CHANGED = 38,
            E2E_ENCRYPTED = 39,
            CALL_MISSED_VOICE = 40,
            CALL_MISSED_VIDEO = 41,
            INDIVIDUAL_CHANGE_NUMBER = 42,
            GROUP_DELETE = 43,
            GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE = 44,
            CALL_MISSED_GROUP_VOICE = 45,
            CALL_MISSED_GROUP_VIDEO = 46,
            PAYMENT_CIPHERTEXT = 47,
            PAYMENT_FUTUREPROOF = 48,
            PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED = 49,
            PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED = 50,
            PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED = 51,
            PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP = 52,
            PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP = 53,
            PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER = 54,
            PAYMENT_ACTION_SEND_PAYMENT_REMINDER = 55,
            PAYMENT_ACTION_SEND_PAYMENT_INVITATION = 56,
            PAYMENT_ACTION_REQUEST_DECLINED = 57,
            PAYMENT_ACTION_REQUEST_EXPIRED = 58,
            PAYMENT_ACTION_REQUEST_CANCELLED = 59,
            BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM = 60,
            BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP = 61,
            BIZ_INTRO_TOP = 62,
            BIZ_INTRO_BOTTOM = 63,
            BIZ_NAME_CHANGE = 64,
            BIZ_MOVE_TO_CONSUMER_APP = 65,
            BIZ_TWO_TIER_MIGRATION_TOP = 66,
            BIZ_TWO_TIER_MIGRATION_BOTTOM = 67,
            OVERSIZED = 68,
            GROUP_CHANGE_NO_FREQUENTLY_FORWARDED = 69,
            GROUP_V4_ADD_INVITE_SENT = 70,
            GROUP_PARTICIPANT_ADD_REQUEST_JOIN = 71,
            CHANGE_EPHEMERAL_SETTING = 72,
            E2E_DEVICE_CHANGED = 73,
            VIEWED_ONCE = 74,
            E2E_ENCRYPTED_NOW = 75,
            BLUE_MSG_BSP_FB_TO_BSP_PREMISE = 76,
            BLUE_MSG_BSP_FB_TO_SELF_FB = 77,
            BLUE_MSG_BSP_FB_TO_SELF_PREMISE = 78,
            BLUE_MSG_BSP_FB_UNVERIFIED = 79,
            BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 80,
            BLUE_MSG_BSP_FB_VERIFIED = 81,
            BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 82,
            BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE = 83,
            BLUE_MSG_BSP_PREMISE_UNVERIFIED = 84,
            BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 85,
            BLUE_MSG_BSP_PREMISE_VERIFIED = 86,
            BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 87,
            BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED = 88,
            BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED = 89,
            BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED = 90,
            BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED = 91,
            BLUE_MSG_SELF_FB_TO_BSP_PREMISE = 92,
            BLUE_MSG_SELF_FB_TO_SELF_PREMISE = 93,
            BLUE_MSG_SELF_FB_UNVERIFIED = 94,
            BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 95,
            BLUE_MSG_SELF_FB_VERIFIED = 96,
            BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 97,
            BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE = 98,
            BLUE_MSG_SELF_PREMISE_UNVERIFIED = 99,
            BLUE_MSG_SELF_PREMISE_VERIFIED = 100,
            BLUE_MSG_TO_BSP_FB = 101,
            BLUE_MSG_TO_CONSUMER = 102,
            BLUE_MSG_TO_SELF_FB = 103,
            BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED = 104,
            BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 105,
            BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED = 106,
            BLUE_MSG_UNVERIFIED_TO_VERIFIED = 107,
            BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED = 108,
            BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 109,
            BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED = 110,
            BLUE_MSG_VERIFIED_TO_UNVERIFIED = 111,
            BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 112,
            BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED = 113,
            BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 114,
            BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED = 115,
            BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 116,
            BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 117,
            E2E_IDENTITY_UNAVAILABLE = 118,
            GROUP_CREATING = 119,
            GROUP_CREATE_FAILED = 120,
            GROUP_BOUNCED = 121,
            BLOCK_CONTACT = 122,
            EPHEMERAL_SETTING_NOT_APPLIED = 123,
            SYNC_FAILED = 124,
            SYNCING = 125,
            BIZ_PRIVACY_MODE_INIT_FB = 126,
            BIZ_PRIVACY_MODE_INIT_BSP = 127,
            BIZ_PRIVACY_MODE_TO_FB = 128,
            BIZ_PRIVACY_MODE_TO_BSP = 129,
            DISAPPEARING_MODE = 130,
            E2E_DEVICE_FETCH_FAILED = 131,
            ADMIN_REVOKE = 132,
            GROUP_INVITE_LINK_GROWTH_LOCKED = 133,
            COMMUNITY_LINK_PARENT_GROUP = 134,
            COMMUNITY_LINK_SIBLING_GROUP = 135,
            COMMUNITY_LINK_SUB_GROUP = 136,
            COMMUNITY_UNLINK_PARENT_GROUP = 137,
            COMMUNITY_UNLINK_SIBLING_GROUP = 138,
            COMMUNITY_UNLINK_SUB_GROUP = 139,
            GROUP_PARTICIPANT_ACCEPT = 140,
            GROUP_PARTICIPANT_LINKED_GROUP_JOIN = 141,
            COMMUNITY_CREATE = 142,
            EPHEMERAL_KEEP_IN_CHAT = 143,
            GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST = 144,
            GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE = 145,
            INTEGRITY_UNLINK_PARENT_GROUP = 146,
            COMMUNITY_PARTICIPANT_PROMOTE = 147,
            COMMUNITY_PARTICIPANT_DEMOTE = 148,
            COMMUNITY_PARENT_GROUP_DELETED = 149,
            COMMUNITY_LINK_PARENT_GROUP_MEMBERSHIP_APPROVAL = 150,
            GROUP_PARTICIPANT_JOINED_GROUP_AND_PARENT_GROUP = 151,
            MASKED_THREAD_CREATED = 152,
            MASKED_THREAD_UNMASKED = 153,
            BIZ_CHAT_ASSIGNMENT = 154,
            CHAT_PSA = 155,
            CHAT_POLL_CREATION_MESSAGE = 156,
            CAG_MASKED_THREAD_CREATED = 157,
            COMMUNITY_PARENT_GROUP_SUBJECT_CHANGED = 158,
            CAG_INVITE_AUTO_ADD = 159,
            BIZ_CHAT_ASSIGNMENT_UNASSIGN = 160,
            CAG_INVITE_AUTO_JOINED = 161,
            SCHEDULED_CALL_START_MESSAGE = 162,
            COMMUNITY_INVITE_RICH = 163,
            COMMUNITY_INVITE_AUTO_ADD_RICH = 164,
            SUB_GROUP_INVITE_RICH = 165,
            SUB_GROUP_PARTICIPANT_ADD_RICH = 166,
            COMMUNITY_LINK_PARENT_GROUP_RICH = 167,
            COMMUNITY_PARTICIPANT_ADD_RICH = 168,
            SILENCED_UNKNOWN_CALLER_AUDIO = 169,
            SILENCED_UNKNOWN_CALLER_VIDEO = 170,
            GROUP_MEMBER_ADD_MODE = 171,
            GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD = 172,
            COMMUNITY_CHANGE_DESCRIPTION = 173,
            SENDER_INVITE = 174,
            RECEIVER_INVITE = 175,
            COMMUNITY_ALLOW_MEMBER_ADDED_GROUPS = 176,
            PINNED_MESSAGE_IN_CHAT = 177,
            PAYMENT_INVITE_SETUP_INVITER = 178,
            PAYMENT_INVITE_SETUP_INVITEE_RECEIVE_ONLY = 179,
            PAYMENT_INVITE_SETUP_INVITEE_SEND_AND_RECEIVE = 180,
            LINKED_GROUP_CALL_START = 181,
            REPORT_TO_ADMIN_ENABLED_STATUS = 182,
            EMPTY_SUBGROUP_CREATE = 183,
            SCHEDULED_CALL_CANCEL = 184,
            SUBGROUP_ADMIN_TRIGGERED_AUTO_ADD_RICH = 185,
            GROUP_CHANGE_RECENT_HISTORY_SHARING = 186,
            PAID_MESSAGE_SERVER_CAMPAIGN_ID = 187,
            GENERAL_CHAT_CREATE = 188,
            GENERAL_CHAT_ADD = 189,
            GENERAL_CHAT_AUTO_ADD_DISABLED = 190,
            SUGGESTED_SUBGROUP_ANNOUNCE = 191,
            BIZ_BOT_1P_MESSAGING_ENABLED = 192,
            CHANGE_USERNAME = 193,
            BIZ_COEX_PRIVACY_INIT_SELF = 194,
            BIZ_COEX_PRIVACY_TRANSITION_SELF = 195,
            SUPPORT_AI_EDUCATION = 196,
            BIZ_BOT_3P_MESSAGING_ENABLED = 197,
            REMINDER_SETUP_MESSAGE = 198,
            REMINDER_SENT_MESSAGE = 199,
            REMINDER_CANCEL_MESSAGE = 200
        }
    }

    /** Properties of a WebNotificationsInfo. */
    interface IWebNotificationsInfo {

        /** WebNotificationsInfo timestamp */
        timestamp?: (number|Long|null);

        /** WebNotificationsInfo unreadChats */
        unreadChats?: (number|null);

        /** WebNotificationsInfo notifyMessageCount */
        notifyMessageCount?: (number|null);

        /** WebNotificationsInfo notifyMessages */
        notifyMessages?: (proto.IWebMessageInfo[]|null);
    }

    /** Represents a WebNotificationsInfo. */
    class WebNotificationsInfo implements IWebNotificationsInfo {

        /**
         * Constructs a new WebNotificationsInfo.
         * @param [properties] Properties to set
         */
        constructor(properties?: proto.IWebNotificationsInfo);

        /** WebNotificationsInfo timestamp. */
        public timestamp: (number|Long);

        /** WebNotificationsInfo unreadChats. */
        public unreadChats: number;

        /** WebNotificationsInfo notifyMessageCount. */
        public notifyMessageCount: number;

        /** WebNotificationsInfo notifyMessages. */
        public notifyMessages: proto.IWebMessageInfo[];

        /**
         * Creates a new WebNotificationsInfo instance using the specified properties.
         * @param [properties] Properties to set
         * @returns WebNotificationsInfo instance
         */
        public static create(properties?: proto.IWebNotificationsInfo): proto.WebNotificationsInfo;

        /**
         * Encodes the specified WebNotificationsInfo message. Does not implicitly {@link proto.WebNotificationsInfo.verify|verify} messages.
         * @param message WebNotificationsInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encode(message: proto.IWebNotificationsInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Encodes the specified WebNotificationsInfo message, length delimited. Does not implicitly {@link proto.WebNotificationsInfo.verify|verify} messages.
         * @param message WebNotificationsInfo message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: proto.IWebNotificationsInfo, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes a WebNotificationsInfo message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns WebNotificationsInfo
         * @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): proto.WebNotificationsInfo;

        /**
         * Decodes a WebNotificationsInfo message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns WebNotificationsInfo
         * @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)): proto.WebNotificationsInfo;

        /**
         * Verifies a WebNotificationsInfo 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 WebNotificationsInfo message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns WebNotificationsInfo
         */
        public static fromObject(object: { [k: string]: any }): proto.WebNotificationsInfo;

        /**
         * Creates a plain object from a WebNotificationsInfo message. Also converts values to other types if specified.
         * @param message WebNotificationsInfo
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: proto.WebNotificationsInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this WebNotificationsInfo to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }
}
