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

    /** Properties of a HpkeCiphertext. */
    interface IHpkeCiphertext {

        /** HpkeCiphertext receiverId */
        receiverId?: (number|Long|null);

        /** HpkeCiphertext senderPub */
        senderPub?: (Uint8Array|null);

        /** HpkeCiphertext ciphertext */
        ciphertext?: (Uint8Array|null);
    }

    /** Represents a HpkeCiphertext. */
    class HpkeCiphertext implements IHpkeCiphertext {

        /**
         * Constructs a new HpkeCiphertext.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IHpkeCiphertext);

        /** HpkeCiphertext receiverId. */
        public receiverId: (number|Long);

        /** HpkeCiphertext senderPub. */
        public senderPub: Uint8Array;

        /** HpkeCiphertext ciphertext. */
        public ciphertext: Uint8Array;

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

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

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

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

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

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

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

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

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

    /** Properties of a NewKeys. */
    interface INewKeys {

        /** NewKeys signerId */
        signerId?: (number|Long|null);

        /** NewKeys body */
        body?: (bundle.NewKeys.IBody|null);

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

    /** Represents a NewKeys. */
    class NewKeys implements INewKeys {

        /**
         * Constructs a new NewKeys.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.INewKeys);

        /** NewKeys signerId. */
        public signerId: (number|Long);

        /** NewKeys body. */
        public body?: (bundle.NewKeys.IBody|null);

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

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

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

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

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

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

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

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

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

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

    namespace NewKeys {

        /** Properties of a Body. */
        interface IBody {

            /** Body deleteManifestSigners */
            deleteManifestSigners?: ((number|Long)[]|null);

            /** Body deleteLayerDecrypters */
            deleteLayerDecrypters?: ((number|Long)[]|null);

            /** Body addManifestSigners */
            addManifestSigners?: (Uint8Array[]|null);

            /** Body addLayerDecrypters */
            addLayerDecrypters?: (bundle.IHpkeCiphertext[]|null);
        }

        /** Represents a Body. */
        class Body implements IBody {

            /**
             * Constructs a new Body.
             * @param [properties] Properties to set
             */
            constructor(properties?: bundle.NewKeys.IBody);

            /** Body deleteManifestSigners. */
            public deleteManifestSigners: (number|Long)[];

            /** Body deleteLayerDecrypters. */
            public deleteLayerDecrypters: (number|Long)[];

            /** Body addManifestSigners. */
            public addManifestSigners: Uint8Array[];

            /** Body addLayerDecrypters. */
            public addLayerDecrypters: bundle.IHpkeCiphertext[];

            /**
             * Creates a new Body instance using the specified properties.
             * @param [properties] Properties to set
             * @returns Body instance
             */
            public static create(properties?: bundle.NewKeys.IBody): bundle.NewKeys.Body;

            /**
             * Encodes the specified Body message. Does not implicitly {@link bundle.NewKeys.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: bundle.NewKeys.IBody, writer?: $protobuf.Writer): $protobuf.Writer;

            /**
             * Encodes the specified Body message, length delimited. Does not implicitly {@link bundle.NewKeys.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: bundle.NewKeys.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): bundle.NewKeys.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)): bundle.NewKeys.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 }): bundle.NewKeys.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: bundle.NewKeys.Body, options?: $protobuf.IConversionOptions): { [k: string]: any };

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

    /** Properties of an OpaqueManifest. */
    interface IOpaqueManifest {

        /** OpaqueManifest signerId */
        signerId?: (number|Long|null);

        /** OpaqueManifest body */
        body?: (Uint8Array|null);

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

    /** Represents an OpaqueManifest. */
    class OpaqueManifest implements IOpaqueManifest {

        /**
         * Constructs a new OpaqueManifest.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IOpaqueManifest);

        /** OpaqueManifest signerId. */
        public signerId: (number|Long);

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

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

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

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

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

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

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

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

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

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

    /** Properties of an AppManifest. */
    interface IAppManifest {

        /** AppManifest signerId */
        signerId?: (number|Long|null);

        /** AppManifest body */
        body?: (bundle.AppManifest.IAppBody|null);

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

    /** Represents an AppManifest. */
    class AppManifest implements IAppManifest {

        /**
         * Constructs a new AppManifest.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IAppManifest);

        /** AppManifest signerId. */
        public signerId: (number|Long);

        /** AppManifest body. */
        public body?: (bundle.AppManifest.IAppBody|null);

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

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

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

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

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

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

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

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

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

    namespace AppManifest {

        /** Properties of an AppBody. */
        interface IAppBody {

            /** AppBody layers */
            layers?: (bundle.IAppLayerReference[]|null);

            /** AppBody debug */
            debug?: (bundle.IDebugPolicy|null);

            /** AppBody crash */
            crash?: (bundle.ICrashPolicy|null);

            /** AppBody update */
            update?: (bundle.IUpdatePolicy|null);

            /** AppBody connectivity */
            connectivity?: (bundle.IConnectivityPolicy|null);
        }

        /** Represents an AppBody. */
        class AppBody implements IAppBody {

            /**
             * Constructs a new AppBody.
             * @param [properties] Properties to set
             */
            constructor(properties?: bundle.AppManifest.IAppBody);

            /** AppBody layers. */
            public layers: bundle.IAppLayerReference[];

            /** AppBody debug. */
            public debug?: (bundle.IDebugPolicy|null);

            /** AppBody crash. */
            public crash?: (bundle.ICrashPolicy|null);

            /** AppBody update. */
            public update?: (bundle.IUpdatePolicy|null);

            /** AppBody connectivity. */
            public connectivity?: (bundle.IConnectivityPolicy|null);

            /**
             * Creates a new AppBody instance using the specified properties.
             * @param [properties] Properties to set
             * @returns AppBody instance
             */
            public static create(properties?: bundle.AppManifest.IAppBody): bundle.AppManifest.AppBody;

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

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

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

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

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

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

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

    /** Properties of an InternalFlashRegion. */
    interface IInternalFlashRegion {

        /** InternalFlashRegion start */
        start?: (number|null);

        /** InternalFlashRegion size */
        size?: (number|null);
    }

    /** Represents an InternalFlashRegion. */
    class InternalFlashRegion implements IInternalFlashRegion {

        /**
         * Constructs a new InternalFlashRegion.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IInternalFlashRegion);

        /** InternalFlashRegion start. */
        public start: number;

        /** InternalFlashRegion size. */
        public size: number;

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

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

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

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

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

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

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

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

    /** Properties of a SpiFlashRegion. */
    interface ISpiFlashRegion {

        /** SpiFlashRegion start */
        start?: (number|null);

        /** SpiFlashRegion size */
        size?: (number|null);
    }

    /** Represents a SpiFlashRegion. */
    class SpiFlashRegion implements ISpiFlashRegion {

        /**
         * Constructs a new SpiFlashRegion.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.ISpiFlashRegion);

        /** SpiFlashRegion start. */
        public start: number;

        /** SpiFlashRegion size. */
        public size: number;

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

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

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

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

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

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

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

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

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

    /** Properties of an AppLayerRegion. */
    interface IAppLayerRegion {

        /** AppLayerRegion internalFlash */
        internalFlash?: (bundle.IInternalFlashRegion|null);

        /** AppLayerRegion externalFlash */
        externalFlash?: (bundle.ISpiFlashRegion|null);
    }

    /** Represents an AppLayerRegion. */
    class AppLayerRegion implements IAppLayerRegion {

        /**
         * Constructs a new AppLayerRegion.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IAppLayerRegion);

        /** AppLayerRegion internalFlash. */
        public internalFlash?: (bundle.IInternalFlashRegion|null);

        /** AppLayerRegion externalFlash. */
        public externalFlash?: (bundle.ISpiFlashRegion|null);

        /** AppLayerRegion where. */
        public where?: ("internalFlash"|"externalFlash");

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

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

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

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

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

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

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

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

    /** Properties of an AppLayerReference. */
    interface IAppLayerReference {

        /** AppLayerReference target */
        target?: (bundle.IAppLayerRegion|null);

        /** AppLayerReference encryptedWithKeyId */
        encryptedWithKeyId?: (number|Long|null);

        /** AppLayerReference fetchHash */
        fetchHash?: (Uint8Array|null);

        /** AppLayerReference measurementHash */
        measurementHash?: (Uint8Array|null);
    }

    /** Represents an AppLayerReference. */
    class AppLayerReference implements IAppLayerReference {

        /**
         * Constructs a new AppLayerReference.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IAppLayerReference);

        /** AppLayerReference target. */
        public target?: (bundle.IAppLayerRegion|null);

        /** AppLayerReference encryptedWithKeyId. */
        public encryptedWithKeyId: (number|Long);

        /** AppLayerReference fetchHash. */
        public fetchHash: Uint8Array;

        /** AppLayerReference measurementHash. */
        public measurementHash: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of a DebugPolicy. */
    interface IDebugPolicy {

        /** DebugPolicy debuggable */
        debuggable?: (boolean|null);

        /** DebugPolicy debugAuthPubkey */
        debugAuthPubkey?: (Uint8Array|null);
    }

    /** Represents a DebugPolicy. */
    class DebugPolicy implements IDebugPolicy {

        /**
         * Constructs a new DebugPolicy.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IDebugPolicy);

        /** DebugPolicy debuggable. */
        public debuggable: boolean;

        /** DebugPolicy debugAuthPubkey. */
        public debugAuthPubkey: Uint8Array;

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

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

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

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

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

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

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

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

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

    /** Properties of a CrashPolicy. */
    interface ICrashPolicy {

        /** CrashPolicy minimumRestartMs */
        minimumRestartMs?: (number|null);

        /** CrashPolicy maximumRestartMs */
        maximumRestartMs?: (number|null);

        /** CrashPolicy crashReportPubkey */
        crashReportPubkey?: (Uint8Array|null);

        /** CrashPolicy includeStackBytes */
        includeStackBytes?: (number|null);
    }

    /** Represents a CrashPolicy. */
    class CrashPolicy implements ICrashPolicy {

        /**
         * Constructs a new CrashPolicy.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.ICrashPolicy);

        /** CrashPolicy minimumRestartMs. */
        public minimumRestartMs: number;

        /** CrashPolicy maximumRestartMs. */
        public maximumRestartMs: number;

        /** CrashPolicy crashReportPubkey. */
        public crashReportPubkey: Uint8Array;

        /** CrashPolicy includeStackBytes. */
        public includeStackBytes: number;

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

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

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

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

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

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

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

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

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

    /** Properties of an UpdatePolicy. */
    interface IUpdatePolicy {

        /** UpdatePolicy maximumPolitenessTimeSec */
        maximumPolitenessTimeSec?: (number|null);

        /** UpdatePolicy minimumKernelVersion */
        minimumKernelVersion?: (number|null);
    }

    /** Represents an UpdatePolicy. */
    class UpdatePolicy implements IUpdatePolicy {

        /**
         * Constructs a new UpdatePolicy.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IUpdatePolicy);

        /** UpdatePolicy maximumPolitenessTimeSec. */
        public maximumPolitenessTimeSec: number;

        /** UpdatePolicy minimumKernelVersion. */
        public minimumKernelVersion: number;

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

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

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

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

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

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

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

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

    /** Properties of a ConnectivityPolicy. */
    interface IConnectivityPolicy {

        /** ConnectivityPolicy connectionGraceTimeSec */
        connectionGraceTimeSec?: (number|null);

        /** ConnectivityPolicy minimumCheckInTimeSec */
        minimumCheckInTimeSec?: (number|null);
    }

    /** Represents a ConnectivityPolicy. */
    class ConnectivityPolicy implements IConnectivityPolicy {

        /**
         * Constructs a new ConnectivityPolicy.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IConnectivityPolicy);

        /** ConnectivityPolicy connectionGraceTimeSec. */
        public connectionGraceTimeSec: number;

        /** ConnectivityPolicy minimumCheckInTimeSec. */
        public minimumCheckInTimeSec: number;

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

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

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

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

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

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

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

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

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

    /** Properties of a KernelManifest. */
    interface IKernelManifest {

        /** KernelManifest signerId */
        signerId?: (number|Long|null);

        /** KernelManifest body */
        body?: (bundle.KernelManifest.IKernelBody|null);

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

    /** Represents a KernelManifest. */
    class KernelManifest implements IKernelManifest {

        /**
         * Constructs a new KernelManifest.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IKernelManifest);

        /** KernelManifest signerId. */
        public signerId: (number|Long);

        /** KernelManifest body. */
        public body?: (bundle.KernelManifest.IKernelBody|null);

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

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

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

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

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

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

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

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

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

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

    namespace KernelManifest {

        /** Properties of a KernelBody. */
        interface IKernelBody {

            /** KernelBody layers */
            layers?: (bundle.IKernelLayerReference[]|null);

            /** KernelBody meta */
            meta?: (bundle.IKernelMeta|null);
        }

        /** Represents a KernelBody. */
        class KernelBody implements IKernelBody {

            /**
             * Constructs a new KernelBody.
             * @param [properties] Properties to set
             */
            constructor(properties?: bundle.KernelManifest.IKernelBody);

            /** KernelBody layers. */
            public layers: bundle.IKernelLayerReference[];

            /** KernelBody meta. */
            public meta?: (bundle.IKernelMeta|null);

            /**
             * Creates a new KernelBody instance using the specified properties.
             * @param [properties] Properties to set
             * @returns KernelBody instance
             */
            public static create(properties?: bundle.KernelManifest.IKernelBody): bundle.KernelManifest.KernelBody;

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

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

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

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

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

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

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

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

    /** Properties of a KernelLayerReference. */
    interface IKernelLayerReference {

        /** KernelLayerReference target */
        target?: (bundle.IKernelLayerRegion|null);

        /** KernelLayerReference encryptedWithKeyId */
        encryptedWithKeyId?: (number|Long|null);

        /** KernelLayerReference fetchHash */
        fetchHash?: (Uint8Array|null);

        /** KernelLayerReference measurementHash */
        measurementHash?: (Uint8Array|null);
    }

    /** Represents a KernelLayerReference. */
    class KernelLayerReference implements IKernelLayerReference {

        /**
         * Constructs a new KernelLayerReference.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IKernelLayerReference);

        /** KernelLayerReference target. */
        public target?: (bundle.IKernelLayerRegion|null);

        /** KernelLayerReference encryptedWithKeyId. */
        public encryptedWithKeyId: (number|Long);

        /** KernelLayerReference fetchHash. */
        public fetchHash: Uint8Array;

        /** KernelLayerReference measurementHash. */
        public measurementHash: Uint8Array;

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

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

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

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

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

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

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

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

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

    /** Properties of a KernelLayerRegion. */
    interface IKernelLayerRegion {

        /** KernelLayerRegion kernel */
        kernel?: (bundle.IInternalFlashRegion|null);

        /** KernelLayerRegion bootrom */
        bootrom?: (bundle.IInternalFlashRegion|null);

        /** KernelLayerRegion upgrader */
        upgrader?: (bundle.IInternalFlashRegion|null);
    }

    /** Represents a KernelLayerRegion. */
    class KernelLayerRegion implements IKernelLayerRegion {

        /**
         * Constructs a new KernelLayerRegion.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IKernelLayerRegion);

        /** KernelLayerRegion kernel. */
        public kernel?: (bundle.IInternalFlashRegion|null);

        /** KernelLayerRegion bootrom. */
        public bootrom?: (bundle.IInternalFlashRegion|null);

        /** KernelLayerRegion upgrader. */
        public upgrader?: (bundle.IInternalFlashRegion|null);

        /** KernelLayerRegion where. */
        public where?: ("kernel"|"bootrom"|"upgrader");

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

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

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

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

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

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

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

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

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

    /** DeviceType enum. */
    enum DeviceType {
        Invalid = 0,
        Imp201c = 1
    }

    /** Properties of a KernelMeta. */
    interface IKernelMeta {

        /** KernelMeta versionSecurityRatchet */
        versionSecurityRatchet?: (number|null);

        /** KernelMeta deviceType */
        deviceType?: (bundle.DeviceType|null);

        /** KernelMeta versionString */
        versionString?: (string|null);

        /** KernelMeta versionNumber */
        versionNumber?: (number|null);
    }

    /** Represents a KernelMeta. */
    class KernelMeta implements IKernelMeta {

        /**
         * Constructs a new KernelMeta.
         * @param [properties] Properties to set
         */
        constructor(properties?: bundle.IKernelMeta);

        /** KernelMeta versionSecurityRatchet. */
        public versionSecurityRatchet: number;

        /** KernelMeta deviceType. */
        public deviceType: bundle.DeviceType;

        /** KernelMeta versionString. */
        public versionString: string;

        /** KernelMeta versionNumber. */
        public versionNumber: number;

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

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

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

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

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

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

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

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

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

/** Properties of a HelloRequest. */
export interface IHelloRequest {
}

/** Represents a HelloRequest. */
export class HelloRequest implements IHelloRequest {

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

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

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

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

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

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

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

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

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

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

/** Properties of a HelloResponse. */
export interface IHelloResponse {

    /** HelloResponse haltStatus */
    haltStatus?: (HaltStatus|null);

    /** HelloResponse haltReason */
    haltReason?: (IHaltReasonResponse|null);
}

/** Represents a HelloResponse. */
export class HelloResponse implements IHelloResponse {

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

    /** HelloResponse haltStatus. */
    public haltStatus: HaltStatus;

    /** HelloResponse haltReason. */
    public haltReason?: (IHaltReasonResponse|null);

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

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

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

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

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

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

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

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

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

/** Properties of a GoodbyeRequest. */
export interface IGoodbyeRequest {
}

/** Represents a GoodbyeRequest. */
export class GoodbyeRequest implements IGoodbyeRequest {

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

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

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

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

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

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

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

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

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

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

/** Properties of a GoodbyeResponse. */
export interface IGoodbyeResponse {
}

/** Represents a GoodbyeResponse. */
export class GoodbyeResponse implements IGoodbyeResponse {

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

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

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

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

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

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

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

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

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

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

/** Properties of a PingRequest. */
export interface IPingRequest {
}

/** Represents a PingRequest. */
export class PingRequest implements IPingRequest {

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

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

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

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

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

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

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

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

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

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

/** Properties of a PingResponse. */
export interface IPingResponse {
}

/** Represents a PingResponse. */
export class PingResponse implements IPingResponse {

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

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

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

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

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

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

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

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

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

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

/** Properties of a HaltReasonRequest. */
export interface IHaltReasonRequest {
}

/** Represents a HaltReasonRequest. */
export class HaltReasonRequest implements IHaltReasonRequest {

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

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

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

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

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

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

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

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

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

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

/** Properties of a HaltReasonResponse. */
export interface IHaltReasonResponse {

    /** HaltReasonResponse haltReason */
    haltReason?: (HaltReasonResponse.HaltReason|null);

    /** HaltReasonResponse registers */
    registers?: (IReadRegistersResponse|null);
}

/** Represents a HaltReasonResponse. */
export class HaltReasonResponse implements IHaltReasonResponse {

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

    /** HaltReasonResponse haltReason. */
    public haltReason: HaltReasonResponse.HaltReason;

    /** HaltReasonResponse registers. */
    public registers?: (IReadRegistersResponse|null);

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

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

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

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

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

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

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

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

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

export namespace HaltReasonResponse {

    /** HaltReason enum. */
    enum HaltReason {
        NONE = 0,
        HARD_FAULT = 3,
        MEM_FAULT = 4,
        BUS_FAULT = 5,
        USAGE_FAULT = 6,
        SECURE_FAULT = 7,
        DEBUG_MONITOR = 12,
        HALT_REQUEST = 128,
        BREAK = 129,
        SINGLE_STEP = 130
    }
}

/** Properties of a ReadRegistersRequest. */
export interface IReadRegistersRequest {
}

/** Represents a ReadRegistersRequest. */
export class ReadRegistersRequest implements IReadRegistersRequest {

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

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

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

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

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

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

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

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

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

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

/** Properties of a ReadWriteRegisters. */
export interface IReadWriteRegisters {

    /** ReadWriteRegisters basicRegisters */
    basicRegisters?: (registers.IBasicRegisters|null);

    /** ReadWriteRegisters extendedRegisters */
    extendedRegisters?: (registers.IExtendedRegisters|null);
}

/** Represents a ReadWriteRegisters. */
export class ReadWriteRegisters implements IReadWriteRegisters {

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

    /** ReadWriteRegisters basicRegisters. */
    public basicRegisters?: (registers.IBasicRegisters|null);

    /** ReadWriteRegisters extendedRegisters. */
    public extendedRegisters?: (registers.IExtendedRegisters|null);

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

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

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

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

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

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

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

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

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

/** Properties of a ReadOnlyRegisters. */
export interface IReadOnlyRegisters {

    /** ReadOnlyRegisters specialRegisters */
    specialRegisters?: (registers.ISpecialRegisters|null);

    /** ReadOnlyRegisters faultRegisters */
    faultRegisters?: (registers.IFaultRegisters|null);

    /** ReadOnlyRegisters primask */
    primask?: (number|null);

    /** ReadOnlyRegisters basepri */
    basepri?: (number|null);
}

/** Represents a ReadOnlyRegisters. */
export class ReadOnlyRegisters implements IReadOnlyRegisters {

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

    /** ReadOnlyRegisters specialRegisters. */
    public specialRegisters?: (registers.ISpecialRegisters|null);

    /** ReadOnlyRegisters faultRegisters. */
    public faultRegisters?: (registers.IFaultRegisters|null);

    /** ReadOnlyRegisters primask. */
    public primask: number;

    /** ReadOnlyRegisters basepri. */
    public basepri: number;

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

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

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

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

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

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

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

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

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

/** Properties of a ReadRegistersResponse. */
export interface IReadRegistersResponse {

    /** ReadRegistersResponse readWrite */
    readWrite?: (IReadWriteRegisters|null);

    /** ReadRegistersResponse readOnly */
    readOnly?: (IReadOnlyRegisters|null);

    /** ReadRegistersResponse error */
    error?: (ReadWriteError|null);
}

/** Represents a ReadRegistersResponse. */
export class ReadRegistersResponse implements IReadRegistersResponse {

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

    /** ReadRegistersResponse readWrite. */
    public readWrite?: (IReadWriteRegisters|null);

    /** ReadRegistersResponse readOnly. */
    public readOnly?: (IReadOnlyRegisters|null);

    /** ReadRegistersResponse error. */
    public error: ReadWriteError;

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

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

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

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

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

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

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

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

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

/** Properties of a ReadRegisterRequest. */
export interface IReadRegisterRequest {

    /** ReadRegisterRequest index */
    index?: (number|null);
}

/** Represents a ReadRegisterRequest. */
export class ReadRegisterRequest implements IReadRegisterRequest {

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

    /** ReadRegisterRequest index. */
    public index: number;

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

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

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

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

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

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

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

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

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

/** Properties of a ReadRegisterResponse. */
export interface IReadRegisterResponse {

    /** ReadRegisterResponse value */
    value?: (number|null);

    /** ReadRegisterResponse error */
    error?: (ReadWriteError|null);
}

/** Represents a ReadRegisterResponse. */
export class ReadRegisterResponse implements IReadRegisterResponse {

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

    /** ReadRegisterResponse value. */
    public value: number;

    /** ReadRegisterResponse error. */
    public error: ReadWriteError;

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

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

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

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

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

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

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

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

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

/** Properties of a WriteRegistersRequest. */
export interface IWriteRegistersRequest {

    /** WriteRegistersRequest registers */
    registers?: (IReadWriteRegisters|null);
}

/** Represents a WriteRegistersRequest. */
export class WriteRegistersRequest implements IWriteRegistersRequest {

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

    /** WriteRegistersRequest registers. */
    public registers?: (IReadWriteRegisters|null);

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

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

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

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

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

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

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

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

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

/** Properties of a WriteRegistersResponse. */
export interface IWriteRegistersResponse {

    /** WriteRegistersResponse error */
    error?: (ReadWriteError|null);
}

/** Represents a WriteRegistersResponse. */
export class WriteRegistersResponse implements IWriteRegistersResponse {

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

    /** WriteRegistersResponse error. */
    public error: ReadWriteError;

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

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

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

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

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

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

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

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

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

/** Properties of a WriteRegisterRequest. */
export interface IWriteRegisterRequest {

    /** WriteRegisterRequest index */
    index?: (number|null);

    /** WriteRegisterRequest value */
    value?: (number|null);
}

/** Represents a WriteRegisterRequest. */
export class WriteRegisterRequest implements IWriteRegisterRequest {

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

    /** WriteRegisterRequest index. */
    public index: number;

    /** WriteRegisterRequest value. */
    public value: number;

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

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

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

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

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

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

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

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

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

/** Properties of a WriteRegisterResponse. */
export interface IWriteRegisterResponse {

    /** WriteRegisterResponse error */
    error?: (ReadWriteError|null);
}

/** Represents a WriteRegisterResponse. */
export class WriteRegisterResponse implements IWriteRegisterResponse {

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

    /** WriteRegisterResponse error. */
    public error: ReadWriteError;

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

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

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

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

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

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

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

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

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

/** Properties of a ReadMemoryRequest. */
export interface IReadMemoryRequest {

    /** ReadMemoryRequest address */
    address?: (number|null);

    /** ReadMemoryRequest byteCount */
    byteCount?: (number|null);
}

/** Represents a ReadMemoryRequest. */
export class ReadMemoryRequest implements IReadMemoryRequest {

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

    /** ReadMemoryRequest address. */
    public address: number;

    /** ReadMemoryRequest byteCount. */
    public byteCount: number;

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

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

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

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

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

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

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

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

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

/** Properties of a ReadMemoryResponse. */
export interface IReadMemoryResponse {

    /** ReadMemoryResponse memory */
    memory?: (Uint8Array|null);

    /** ReadMemoryResponse error */
    error?: (ReadWriteError|null);
}

/** Represents a ReadMemoryResponse. */
export class ReadMemoryResponse implements IReadMemoryResponse {

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

    /** ReadMemoryResponse memory. */
    public memory: Uint8Array;

    /** ReadMemoryResponse error. */
    public error: ReadWriteError;

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

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

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

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

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

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

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

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

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

/** Properties of a WriteMemoryRequest. */
export interface IWriteMemoryRequest {

    /** WriteMemoryRequest address */
    address?: (number|null);

    /** WriteMemoryRequest memory */
    memory?: (Uint8Array|null);
}

/** Represents a WriteMemoryRequest. */
export class WriteMemoryRequest implements IWriteMemoryRequest {

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

    /** WriteMemoryRequest address. */
    public address: number;

    /** WriteMemoryRequest memory. */
    public memory: Uint8Array;

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

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

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

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

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

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

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

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

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

/** Properties of a WriteMemoryResponse. */
export interface IWriteMemoryResponse {

    /** WriteMemoryResponse error */
    error?: (ReadWriteError|null);
}

/** Represents a WriteMemoryResponse. */
export class WriteMemoryResponse implements IWriteMemoryResponse {

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

    /** WriteMemoryResponse error. */
    public error: ReadWriteError;

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

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

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

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

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

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

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

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

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

/** Properties of a ContinueRequest. */
export interface IContinueRequest {
}

/** Represents a ContinueRequest. */
export class ContinueRequest implements IContinueRequest {

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

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

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

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

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

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

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

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

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

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

/** Properties of a ContinueResponse. */
export interface IContinueResponse {
}

/** Represents a ContinueResponse. */
export class ContinueResponse implements IContinueResponse {

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

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

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

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

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

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

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

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

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

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

/** Properties of a HaltRequest. */
export interface IHaltRequest {
}

/** Represents a HaltRequest. */
export class HaltRequest implements IHaltRequest {

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

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

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

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

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

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

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

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

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

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

/** Properties of a HaltResponse. */
export interface IHaltResponse {

    /** HaltResponse haltReason */
    haltReason?: (IHaltReasonResponse|null);

    /** HaltResponse haltStatus */
    haltStatus?: (HaltStatus|null);
}

/** Represents a HaltResponse. */
export class HaltResponse implements IHaltResponse {

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

    /** HaltResponse haltReason. */
    public haltReason?: (IHaltReasonResponse|null);

    /** HaltResponse haltStatus. */
    public haltStatus: HaltStatus;

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

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

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

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

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

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

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

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

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

/** Properties of an InsertBreakpointRequest. */
export interface IInsertBreakpointRequest {

    /** InsertBreakpointRequest address */
    address?: (number|null);
}

/** Represents an InsertBreakpointRequest. */
export class InsertBreakpointRequest implements IInsertBreakpointRequest {

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

    /** InsertBreakpointRequest address. */
    public address: number;

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

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

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

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

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

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

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

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

/** Properties of an InsertBreakpointResponse. */
export interface IInsertBreakpointResponse {

    /** InsertBreakpointResponse success */
    success?: (boolean|null);
}

/** Represents an InsertBreakpointResponse. */
export class InsertBreakpointResponse implements IInsertBreakpointResponse {

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

    /** InsertBreakpointResponse success. */
    public success: boolean;

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

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

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

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

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

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

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

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

/** Properties of a RemoveBreakpointRequest. */
export interface IRemoveBreakpointRequest {

    /** RemoveBreakpointRequest address */
    address?: (number|null);
}

/** Represents a RemoveBreakpointRequest. */
export class RemoveBreakpointRequest implements IRemoveBreakpointRequest {

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

    /** RemoveBreakpointRequest address. */
    public address: number;

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

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

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

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

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

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

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

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

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

/** Properties of a RemoveBreakpointResponse. */
export interface IRemoveBreakpointResponse {

    /** RemoveBreakpointResponse success */
    success?: (boolean|null);
}

/** Represents a RemoveBreakpointResponse. */
export class RemoveBreakpointResponse implements IRemoveBreakpointResponse {

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

    /** RemoveBreakpointResponse success. */
    public success: boolean;

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

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

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

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

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

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

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

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

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

/** Properties of a StepRequest. */
export interface IStepRequest {
}

/** Represents a StepRequest. */
export class StepRequest implements IStepRequest {

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

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

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

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

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

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

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

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

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

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

/** Properties of a StepResponse. */
export interface IStepResponse {
}

/** Represents a StepResponse. */
export class StepResponse implements IStepResponse {

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

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

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

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

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

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

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

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

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

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

/** Properties of a PluginTelemetryRequest. */
export interface IPluginTelemetryRequest {

    /** PluginTelemetryRequest type */
    type?: (PluginTelemetryType|null);

    /** PluginTelemetryRequest data */
    data?: (Uint8Array|null);
}

/** Represents a PluginTelemetryRequest. */
export class PluginTelemetryRequest implements IPluginTelemetryRequest {

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

    /** PluginTelemetryRequest type. */
    public type: PluginTelemetryType;

    /** PluginTelemetryRequest data. */
    public data: Uint8Array;

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

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

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

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

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

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

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

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

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

/** Properties of a PluginTelemetryResponse. */
export interface IPluginTelemetryResponse {
}

/** Represents a PluginTelemetryResponse. */
export class PluginTelemetryResponse implements IPluginTelemetryResponse {

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

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

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

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

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

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

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

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

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

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

/** HaltStatus enum. */
export enum HaltStatus {
    HALTED = 0,
    HALT_PENDING = 1,
    TERMINATED = 2
}

/** ReadWriteError enum. */
export enum ReadWriteError {
    NONE = 0,
    BAD_PARAMETER = 1,
    USER_THREAD_NOT_RUNNING = 2
}

/** PluginTelemetryType enum. */
export enum PluginTelemetryType {
    UNSUPPORTED_GDB_PACKET = 0
}

/** DebugProtocol_DeviceToServer_MessageTypes enum. */
export enum DebugProtocol_DeviceToServer_MessageTypes {
    TYPE_D2S_HELLO_RESPONSE = 0,
    TYPE_D2S_GOODBYE_RESPONSE = 1,
    TYPE_D2S_HALT_REASON_RESPONSE = 2,
    TYPE_D2S_READ_REGISTERS_RESPONSE = 3,
    TYPE_D2S_READ_REGISTER_RESPONSE = 4,
    TYPE_D2S_WRITE_REGISTERS_RESPONSE = 5,
    TYPE_D2S_WRITE_REGISTER_RESPONSE = 6,
    TYPE_D2S_READ_MEMORY_RESPONSE = 7,
    TYPE_D2S_WRITE_MEMORY_RESPONSE = 8,
    TYPE_D2S_CONTINUE_RESPONSE = 9,
    TYPE_D2S_HALT_RESPONSE = 10,
    TYPE_D2S_INSERT_BREAKPOINT_RESPONSE = 11,
    TYPE_D2S_REMOVE_BREAKPOINT_RESPONSE = 12,
    TYPE_D2S_STEP_RESPONSE = 13,
    TYPE_D2S_PING_RESPONSE = 14,
    TYPE_D2S_PLUGIN_TELEMETRY_RESPONSE = 15
}

/** DebugProtocol_ServerToDevice_MessageTypes enum. */
export enum DebugProtocol_ServerToDevice_MessageTypes {
    TYPE_S2D_HELLO_REQUEST = 0,
    TYPE_S2D_GOODBYE_REQUEST = 1,
    TYPE_S2D_HALT_REASON_REQUEST = 2,
    TYPE_S2D_READ_REGISTERS_REQUEST = 3,
    TYPE_S2D_READ_REGISTER_REQUEST = 4,
    TYPE_S2D_WRITE_REGISTERS_REQUEST = 5,
    TYPE_S2D_WRITE_REGISTER_REQUEST = 6,
    TYPE_S2D_READ_MEMORY_REQUEST = 7,
    TYPE_S2D_WRITE_MEMORY_REQUEST = 8,
    TYPE_S2D_CONTINUE_REQUEST = 9,
    TYPE_S2D_HALT_REQUEST = 10,
    TYPE_S2D_INSERT_BREAKPOINT_REQUEST = 11,
    TYPE_S2D_REMOVE_BREAKPOINT_REQUEST = 12,
    TYPE_S2D_STEP_REQUEST = 13,
    TYPE_S2D_PING_REQUEST = 14,
    TYPE_S2D_PLUGIN_TELEMETRY_REQUEST = 15
}

/** Represents a DebugProtocol */
export class DebugProtocol extends $protobuf.rpc.Service {

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

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

    /**
     * Calls Hello.
     * @param request HelloRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and HelloResponse
     */
    public hello(request: IHelloRequest, callback: DebugProtocol.HelloCallback): void;

    /**
     * Calls Hello.
     * @param request HelloRequest message or plain object
     * @returns Promise
     */
    public hello(request: IHelloRequest): Promise<HelloResponse>;

    /**
     * Calls Goodbye.
     * @param request GoodbyeRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and GoodbyeResponse
     */
    public goodbye(request: IGoodbyeRequest, callback: DebugProtocol.GoodbyeCallback): void;

    /**
     * Calls Goodbye.
     * @param request GoodbyeRequest message or plain object
     * @returns Promise
     */
    public goodbye(request: IGoodbyeRequest): Promise<GoodbyeResponse>;

    /**
     * Calls HaltReason.
     * @param request HaltReasonRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and HaltReasonResponse
     */
    public haltReason(request: IHaltReasonRequest, callback: DebugProtocol.HaltReasonCallback): void;

    /**
     * Calls HaltReason.
     * @param request HaltReasonRequest message or plain object
     * @returns Promise
     */
    public haltReason(request: IHaltReasonRequest): Promise<HaltReasonResponse>;

    /**
     * Calls ReadRegisters.
     * @param request ReadRegistersRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and ReadRegistersResponse
     */
    public readRegisters(request: IReadRegistersRequest, callback: DebugProtocol.ReadRegistersCallback): void;

    /**
     * Calls ReadRegisters.
     * @param request ReadRegistersRequest message or plain object
     * @returns Promise
     */
    public readRegisters(request: IReadRegistersRequest): Promise<ReadRegistersResponse>;

    /**
     * Calls ReadRegister.
     * @param request ReadRegisterRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and ReadRegisterResponse
     */
    public readRegister(request: IReadRegisterRequest, callback: DebugProtocol.ReadRegisterCallback): void;

    /**
     * Calls ReadRegister.
     * @param request ReadRegisterRequest message or plain object
     * @returns Promise
     */
    public readRegister(request: IReadRegisterRequest): Promise<ReadRegisterResponse>;

    /**
     * Calls WriteRegisters.
     * @param request WriteRegistersRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and WriteRegistersResponse
     */
    public writeRegisters(request: IWriteRegistersRequest, callback: DebugProtocol.WriteRegistersCallback): void;

    /**
     * Calls WriteRegisters.
     * @param request WriteRegistersRequest message or plain object
     * @returns Promise
     */
    public writeRegisters(request: IWriteRegistersRequest): Promise<WriteRegistersResponse>;

    /**
     * Calls WriteRegister.
     * @param request WriteRegisterRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and WriteRegisterResponse
     */
    public writeRegister(request: IWriteRegisterRequest, callback: DebugProtocol.WriteRegisterCallback): void;

    /**
     * Calls WriteRegister.
     * @param request WriteRegisterRequest message or plain object
     * @returns Promise
     */
    public writeRegister(request: IWriteRegisterRequest): Promise<WriteRegisterResponse>;

    /**
     * Calls ReadMemory.
     * @param request ReadMemoryRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and ReadMemoryResponse
     */
    public readMemory(request: IReadMemoryRequest, callback: DebugProtocol.ReadMemoryCallback): void;

    /**
     * Calls ReadMemory.
     * @param request ReadMemoryRequest message or plain object
     * @returns Promise
     */
    public readMemory(request: IReadMemoryRequest): Promise<ReadMemoryResponse>;

    /**
     * Calls WriteMemory.
     * @param request WriteMemoryRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and WriteMemoryResponse
     */
    public writeMemory(request: IWriteMemoryRequest, callback: DebugProtocol.WriteMemoryCallback): void;

    /**
     * Calls WriteMemory.
     * @param request WriteMemoryRequest message or plain object
     * @returns Promise
     */
    public writeMemory(request: IWriteMemoryRequest): Promise<WriteMemoryResponse>;

    /**
     * Calls Continue.
     * @param request ContinueRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and ContinueResponse
     */
    public continue(request: IContinueRequest, callback: DebugProtocol.ContinueCallback): void;

    /**
     * Calls Continue.
     * @param request ContinueRequest message or plain object
     * @returns Promise
     */
    public continue(request: IContinueRequest): Promise<ContinueResponse>;

    /**
     * Calls Halt.
     * @param request HaltRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and HaltResponse
     */
    public halt(request: IHaltRequest, callback: DebugProtocol.HaltCallback): void;

    /**
     * Calls Halt.
     * @param request HaltRequest message or plain object
     * @returns Promise
     */
    public halt(request: IHaltRequest): Promise<HaltResponse>;

    /**
     * Calls InsertBreakpoint.
     * @param request InsertBreakpointRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and InsertBreakpointResponse
     */
    public insertBreakpoint(request: IInsertBreakpointRequest, callback: DebugProtocol.InsertBreakpointCallback): void;

    /**
     * Calls InsertBreakpoint.
     * @param request InsertBreakpointRequest message or plain object
     * @returns Promise
     */
    public insertBreakpoint(request: IInsertBreakpointRequest): Promise<InsertBreakpointResponse>;

    /**
     * Calls RemoveBreakpoint.
     * @param request RemoveBreakpointRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and RemoveBreakpointResponse
     */
    public removeBreakpoint(request: IRemoveBreakpointRequest, callback: DebugProtocol.RemoveBreakpointCallback): void;

    /**
     * Calls RemoveBreakpoint.
     * @param request RemoveBreakpointRequest message or plain object
     * @returns Promise
     */
    public removeBreakpoint(request: IRemoveBreakpointRequest): Promise<RemoveBreakpointResponse>;

    /**
     * Calls Step.
     * @param request StepRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and StepResponse
     */
    public step(request: IStepRequest, callback: DebugProtocol.StepCallback): void;

    /**
     * Calls Step.
     * @param request StepRequest message or plain object
     * @returns Promise
     */
    public step(request: IStepRequest): Promise<StepResponse>;

    /**
     * Calls Ping.
     * @param request PingRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and PingResponse
     */
    public ping(request: IPingRequest, callback: DebugProtocol.PingCallback): void;

    /**
     * Calls Ping.
     * @param request PingRequest message or plain object
     * @returns Promise
     */
    public ping(request: IPingRequest): Promise<PingResponse>;

    /**
     * Calls PluginTelemetry.
     * @param request PluginTelemetryRequest message or plain object
     * @param callback Node-style callback called with the error, if any, and PluginTelemetryResponse
     */
    public pluginTelemetry(request: IPluginTelemetryRequest, callback: DebugProtocol.PluginTelemetryCallback): void;

    /**
     * Calls PluginTelemetry.
     * @param request PluginTelemetryRequest message or plain object
     * @returns Promise
     */
    public pluginTelemetry(request: IPluginTelemetryRequest): Promise<PluginTelemetryResponse>;
}

export namespace DebugProtocol {

    /**
     * Callback as used by {@link DebugProtocol#hello}.
     * @param error Error, if any
     * @param [response] HelloResponse
     */
    type HelloCallback = (error: (Error|null), response?: HelloResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#goodbye}.
     * @param error Error, if any
     * @param [response] GoodbyeResponse
     */
    type GoodbyeCallback = (error: (Error|null), response?: GoodbyeResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#haltReason}.
     * @param error Error, if any
     * @param [response] HaltReasonResponse
     */
    type HaltReasonCallback = (error: (Error|null), response?: HaltReasonResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#readRegisters}.
     * @param error Error, if any
     * @param [response] ReadRegistersResponse
     */
    type ReadRegistersCallback = (error: (Error|null), response?: ReadRegistersResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#readRegister}.
     * @param error Error, if any
     * @param [response] ReadRegisterResponse
     */
    type ReadRegisterCallback = (error: (Error|null), response?: ReadRegisterResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#writeRegisters}.
     * @param error Error, if any
     * @param [response] WriteRegistersResponse
     */
    type WriteRegistersCallback = (error: (Error|null), response?: WriteRegistersResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#writeRegister}.
     * @param error Error, if any
     * @param [response] WriteRegisterResponse
     */
    type WriteRegisterCallback = (error: (Error|null), response?: WriteRegisterResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#readMemory}.
     * @param error Error, if any
     * @param [response] ReadMemoryResponse
     */
    type ReadMemoryCallback = (error: (Error|null), response?: ReadMemoryResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#writeMemory}.
     * @param error Error, if any
     * @param [response] WriteMemoryResponse
     */
    type WriteMemoryCallback = (error: (Error|null), response?: WriteMemoryResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#continue_}.
     * @param error Error, if any
     * @param [response] ContinueResponse
     */
    type ContinueCallback = (error: (Error|null), response?: ContinueResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#halt}.
     * @param error Error, if any
     * @param [response] HaltResponse
     */
    type HaltCallback = (error: (Error|null), response?: HaltResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#insertBreakpoint}.
     * @param error Error, if any
     * @param [response] InsertBreakpointResponse
     */
    type InsertBreakpointCallback = (error: (Error|null), response?: InsertBreakpointResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#removeBreakpoint}.
     * @param error Error, if any
     * @param [response] RemoveBreakpointResponse
     */
    type RemoveBreakpointCallback = (error: (Error|null), response?: RemoveBreakpointResponse) => void;

    /**
     * Callback as used by {@link DebugProtocol#step}.
     * @param error Error, if any
     * @param [response] StepResponse
     */
    type StepCallback = (error: (Error|null), response?: StepResponse) => void;

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

    /**
     * Callback as used by {@link DebugProtocol#pluginTelemetry}.
     * @param error Error, if any
     * @param [response] PluginTelemetryResponse
     */
    type PluginTelemetryCallback = (error: (Error|null), response?: PluginTelemetryResponse) => void;
}

/** Namespace registers. */
export namespace registers {

    /** Properties of a BasicRegisters. */
    interface IBasicRegisters {

        /** BasicRegisters r0 */
        r0?: (number|null);

        /** BasicRegisters r1 */
        r1?: (number|null);

        /** BasicRegisters r2 */
        r2?: (number|null);

        /** BasicRegisters r3 */
        r3?: (number|null);

        /** BasicRegisters r12 */
        r12?: (number|null);

        /** BasicRegisters lr */
        lr?: (number|null);

        /** BasicRegisters pc */
        pc?: (number|null);

        /** BasicRegisters xpsr */
        xpsr?: (number|null);
    }

    /** Represents a BasicRegisters. */
    class BasicRegisters implements IBasicRegisters {

        /**
         * Constructs a new BasicRegisters.
         * @param [properties] Properties to set
         */
        constructor(properties?: registers.IBasicRegisters);

        /** BasicRegisters r0. */
        public r0: number;

        /** BasicRegisters r1. */
        public r1: number;

        /** BasicRegisters r2. */
        public r2: number;

        /** BasicRegisters r3. */
        public r3: number;

        /** BasicRegisters r12. */
        public r12: number;

        /** BasicRegisters lr. */
        public lr: number;

        /** BasicRegisters pc. */
        public pc: number;

        /** BasicRegisters xpsr. */
        public xpsr: number;

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

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

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

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

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

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

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

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

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

    /** Properties of an ExtendedRegisters. */
    interface IExtendedRegisters {

        /** ExtendedRegisters sp */
        sp?: (number|null);

        /** ExtendedRegisters r4 */
        r4?: (number|null);

        /** ExtendedRegisters r5 */
        r5?: (number|null);

        /** ExtendedRegisters r6 */
        r6?: (number|null);

        /** ExtendedRegisters r7 */
        r7?: (number|null);

        /** ExtendedRegisters r8 */
        r8?: (number|null);

        /** ExtendedRegisters r9 */
        r9?: (number|null);

        /** ExtendedRegisters r10 */
        r10?: (number|null);

        /** ExtendedRegisters r11 */
        r11?: (number|null);
    }

    /** Represents an ExtendedRegisters. */
    class ExtendedRegisters implements IExtendedRegisters {

        /**
         * Constructs a new ExtendedRegisters.
         * @param [properties] Properties to set
         */
        constructor(properties?: registers.IExtendedRegisters);

        /** ExtendedRegisters sp. */
        public sp: number;

        /** ExtendedRegisters r4. */
        public r4: number;

        /** ExtendedRegisters r5. */
        public r5: number;

        /** ExtendedRegisters r6. */
        public r6: number;

        /** ExtendedRegisters r7. */
        public r7: number;

        /** ExtendedRegisters r8. */
        public r8: number;

        /** ExtendedRegisters r9. */
        public r9: number;

        /** ExtendedRegisters r10. */
        public r10: number;

        /** ExtendedRegisters r11. */
        public r11: number;

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

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

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

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

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

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

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

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

    /** Properties of a SpecialRegisters. */
    interface ISpecialRegisters {

        /** SpecialRegisters control */
        control?: (number|null);

        /** SpecialRegisters msplim */
        msplim?: (number|null);

        /** SpecialRegisters psplim */
        psplim?: (number|null);

        /** SpecialRegisters msp */
        msp?: (number|null);

        /** SpecialRegisters psp */
        psp?: (number|null);
    }

    /** Represents a SpecialRegisters. */
    class SpecialRegisters implements ISpecialRegisters {

        /**
         * Constructs a new SpecialRegisters.
         * @param [properties] Properties to set
         */
        constructor(properties?: registers.ISpecialRegisters);

        /** SpecialRegisters control. */
        public control: number;

        /** SpecialRegisters msplim. */
        public msplim: number;

        /** SpecialRegisters psplim. */
        public psplim: number;

        /** SpecialRegisters msp. */
        public msp: number;

        /** SpecialRegisters psp. */
        public psp: number;

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

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

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

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

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

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

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

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

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

    /** Properties of a FaultRegisters. */
    interface IFaultRegisters {

        /** FaultRegisters fault */
        fault?: (number|null);

        /** FaultRegisters sfsr */
        sfsr?: (number|null);

        /** FaultRegisters sfar */
        sfar?: (number|null);

        /** FaultRegisters shcsr */
        shcsr?: (number|null);

        /** FaultRegisters hfsr */
        hfsr?: (number|null);

        /** FaultRegisters cfsr */
        cfsr?: (number|null);

        /** FaultRegisters bfar */
        bfar?: (number|null);

        /** FaultRegisters mmfar */
        mmfar?: (number|null);
    }

    /** Represents a FaultRegisters. */
    class FaultRegisters implements IFaultRegisters {

        /**
         * Constructs a new FaultRegisters.
         * @param [properties] Properties to set
         */
        constructor(properties?: registers.IFaultRegisters);

        /** FaultRegisters fault. */
        public fault: number;

        /** FaultRegisters sfsr. */
        public sfsr: number;

        /** FaultRegisters sfar. */
        public sfar: number;

        /** FaultRegisters shcsr. */
        public shcsr: number;

        /** FaultRegisters hfsr. */
        public hfsr: number;

        /** FaultRegisters cfsr. */
        public cfsr: number;

        /** FaultRegisters bfar. */
        public bfar: number;

        /** FaultRegisters mmfar. */
        public mmfar: number;

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

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

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

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

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

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

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

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

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

/** Namespace encryption. */
export namespace encryption {

    /** Properties of an EncryptionDeviceKey. */
    interface IEncryptionDeviceKey {

        /** EncryptionDeviceKey pkr */
        pkr?: (Uint8Array|null);
    }

    /** Represents an EncryptionDeviceKey. */
    class EncryptionDeviceKey implements IEncryptionDeviceKey {

        /**
         * Constructs a new EncryptionDeviceKey.
         * @param [properties] Properties to set
         */
        constructor(properties?: encryption.IEncryptionDeviceKey);

        /** EncryptionDeviceKey pkr. */
        public pkr: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of an EncryptionDebuggerKey. */
    interface IEncryptionDebuggerKey {

        /** EncryptionDebuggerKey enc */
        enc?: (Uint8Array|null);
    }

    /** Represents an EncryptionDebuggerKey. */
    class EncryptionDebuggerKey implements IEncryptionDebuggerKey {

        /**
         * Constructs a new EncryptionDebuggerKey.
         * @param [properties] Properties to set
         */
        constructor(properties?: encryption.IEncryptionDebuggerKey);

        /** EncryptionDebuggerKey enc. */
        public enc: Uint8Array;

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

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

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

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

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

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

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

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

    /** Properties of an EncryptionAbort. */
    interface IEncryptionAbort {

        /** EncryptionAbort error */
        error?: (encryption.EncryptionAbort.CryptoError|null);
    }

    /** Represents an EncryptionAbort. */
    class EncryptionAbort implements IEncryptionAbort {

        /**
         * Constructs a new EncryptionAbort.
         * @param [properties] Properties to set
         */
        constructor(properties?: encryption.IEncryptionAbort);

        /** EncryptionAbort error. */
        public error: encryption.EncryptionAbort.CryptoError;

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

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

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

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

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

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

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

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

    namespace EncryptionAbort {

        /** CryptoError enum. */
        enum CryptoError {
            OK = 0,
            NO_USER_CODE = 1,
            NO_DEBUG_KEY = 2,
            INVALID_FORMAT = 3,
            OUT_OF_ORDER_MESSAGE = 4,
            UNKNOWN_KEY_TYPE = 5,
            AUTHENTICATION_ERROR = 6,
            INTERNAL_ERROR = 7,
            MESSAGE_TOO_LARGE = 8,
            INVALID_DEBUG_PUBLIC_KEY = 9
        }
    }

    /** Properties of an EncryptionEnvelope. */
    interface IEncryptionEnvelope {

        /** EncryptionEnvelope ct */
        ct?: (Uint8Array|null);
    }

    /** Represents an EncryptionEnvelope. */
    class EncryptionEnvelope implements IEncryptionEnvelope {

        /**
         * Constructs a new EncryptionEnvelope.
         * @param [properties] Properties to set
         */
        constructor(properties?: encryption.IEncryptionEnvelope);

        /** EncryptionEnvelope ct. */
        public ct: Uint8Array;

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

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

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

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

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

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

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

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

    /** EncryptionLayer_MessageTypes enum. */
    enum EncryptionLayer_MessageTypes {
        TYPE_DEVICE_KEY = 0,
        TYPE_DEBUGGER_KEY = 1,
        TYPE_ABORT = 2,
        TYPE_ENVELOPE = 3
    }
}

/** Namespace provision. */
export namespace provision {

    /** ProvisioningCommands_MessageTypes_F2D enum. */
    enum ProvisioningCommands_MessageTypes_F2D {
        TYPE_F2D_INVALID = 0,
        TYPE_F2D_GET_VERSION_REQUEST = 1,
        TYPE_F2D_GET_WIFI_CONFIGURATION_REQUEST = 2,
        TYPE_F2D_SET_WIFI_CONFIGURATION_REQUEST = 3,
        TYPE_F2D_JOIN_WIFI_REQUEST = 4,
        TYPE_F2D_SCAN_WIFI_REQUEST = 5,
        TYPE_F2D_GET_APN_REQUEST = 6,
        TYPE_F2D_SET_APN_REQUEST = 7,
        TYPE_F2D_GET_ICCID_REQUEST = 8,
        TYPE_F2D_GET_CSR_REQUEST = 9,
        TYPE_F2D_SAVE_CERTIFICATE_REQUEST = 10,
        TYPE_F2D_GET_SID_REQUEST = 11,
        TYPE_F2D_GET_CURRENT_STEP_REQUEST = 12,
        TYPE_F2D_ACKNOWLEDGE_STEP_REQUEST = 13
    }

    /** ProvisioningCommands_MessageTypes_D2F enum. */
    enum ProvisioningCommands_MessageTypes_D2F {
        TYPE_D2F_INVALID = 0,
        TYPE_D2F_GET_VERSION_RESPONSE = 1,
        TYPE_D2F_GET_WIFI_CONFIGURATION_RESPONSE = 2,
        TYPE_D2F_SET_WIFI_CONFIGURATION_RESPONSE = 3,
        TYPE_D2F_JOIN_WIFI_RESPONSE = 4,
        TYPE_D2F_SCAN_WIFI_RESPONSE = 5,
        TYPE_D2F_GET_APN_RESPONSE = 6,
        TYPE_D2F_SET_APN_RESPONSE = 7,
        TYPE_D2F_GET_ICCID_RESPONSE = 8,
        TYPE_D2F_GET_CSR_RESPONSE = 9,
        TYPE_D2F_SAVE_CERTIFICATE_RESPONSE = 10,
        TYPE_D2F_GET_SID_RESPONSE = 11,
        TYPE_D2F_GET_CURRENT_STEP_RESPONSE = 12,
        TYPE_D2F_ACKNOWLEDGE_STEP_RESPONSE = 13
    }

    /** ProvisioningProtocolError enum. */
    enum ProvisioningProtocolError {
        ERROR_BAD_FRAMING = 0,
        ERROR_BAD_CRC = 1,
        ERROR_BAD_FORMAT = 2,
        ERROR_UNSUPPORTED_COMMAND = 3
    }

    /** Properties of a GetVersionCommand. */
    interface IGetVersionCommand {
    }

    /** Represents a GetVersionCommand. */
    class GetVersionCommand implements IGetVersionCommand {

        /**
         * Constructs a new GetVersionCommand.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetVersionCommand);

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

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

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

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

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

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

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

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

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

    /** Properties of a GetVersionResponse. */
    interface IGetVersionResponse {

        /** GetVersionResponse version */
        version?: (Uint8Array|null);

        /** GetVersionResponse type */
        type?: (provision.GetVersionResponse.FirmwareType|null);
    }

    /** Represents a GetVersionResponse. */
    class GetVersionResponse implements IGetVersionResponse {

        /**
         * Constructs a new GetVersionResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetVersionResponse);

        /** GetVersionResponse version. */
        public version: Uint8Array;

        /** GetVersionResponse type. */
        public type: provision.GetVersionResponse.FirmwareType;

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

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

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

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

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

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

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

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

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

    namespace GetVersionResponse {

        /** FirmwareType enum. */
        enum FirmwareType {
            KERNEL = 0,
            SFILOAD = 1,
            HWTEST = 2
        }
    }

    /** Properties of a GetDeviceSidCommand. */
    interface IGetDeviceSidCommand {
    }

    /** Represents a GetDeviceSidCommand. */
    class GetDeviceSidCommand implements IGetDeviceSidCommand {

        /**
         * Constructs a new GetDeviceSidCommand.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetDeviceSidCommand);

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

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

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

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

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

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

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

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

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

    /** Properties of a GetDeviceSidResponse. */
    interface IGetDeviceSidResponse {

        /** GetDeviceSidResponse sid */
        sid?: (Uint8Array|null);
    }

    /** Represents a GetDeviceSidResponse. */
    class GetDeviceSidResponse implements IGetDeviceSidResponse {

        /**
         * Constructs a new GetDeviceSidResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetDeviceSidResponse);

        /** GetDeviceSidResponse sid. */
        public sid: Uint8Array;

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

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

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

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

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

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

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

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

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

    /** Properties of a WifiConfiguration. */
    interface IWifiConfiguration {

        /** WifiConfiguration ssid */
        ssid?: (Uint8Array|null);

        /** WifiConfiguration password */
        password?: (Uint8Array|null);
    }

    /** Represents a WifiConfiguration. */
    class WifiConfiguration implements IWifiConfiguration {

        /**
         * Constructs a new WifiConfiguration.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IWifiConfiguration);

        /** WifiConfiguration ssid. */
        public ssid: Uint8Array;

        /** WifiConfiguration password. */
        public password: Uint8Array;

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

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

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

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

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

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

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

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

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

    /** Properties of a GetWifiConfigurationCommand. */
    interface IGetWifiConfigurationCommand {
    }

    /** Represents a GetWifiConfigurationCommand. */
    class GetWifiConfigurationCommand implements IGetWifiConfigurationCommand {

        /**
         * Constructs a new GetWifiConfigurationCommand.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetWifiConfigurationCommand);

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

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

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

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

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

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

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

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

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

    /** Properties of a GetWifiConfigurationResponse. */
    interface IGetWifiConfigurationResponse {

        /** GetWifiConfigurationResponse success */
        success?: (boolean|null);

        /** GetWifiConfigurationResponse ssid */
        ssid?: (Uint8Array|null);

        /** GetWifiConfigurationResponse hasPassword */
        hasPassword?: (boolean|null);
    }

    /** Represents a GetWifiConfigurationResponse. */
    class GetWifiConfigurationResponse implements IGetWifiConfigurationResponse {

        /**
         * Constructs a new GetWifiConfigurationResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetWifiConfigurationResponse);

        /** GetWifiConfigurationResponse success. */
        public success: boolean;

        /** GetWifiConfigurationResponse ssid. */
        public ssid: Uint8Array;

        /** GetWifiConfigurationResponse hasPassword. */
        public hasPassword: boolean;

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

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

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

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

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

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

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

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

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

    /** Properties of a SetWifiConfigurationCommand. */
    interface ISetWifiConfigurationCommand {

        /** SetWifiConfigurationCommand configuration */
        configuration?: (provision.IWifiConfiguration|null);
    }

    /** Represents a SetWifiConfigurationCommand. */
    class SetWifiConfigurationCommand implements ISetWifiConfigurationCommand {

        /**
         * Constructs a new SetWifiConfigurationCommand.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.ISetWifiConfigurationCommand);

        /** SetWifiConfigurationCommand configuration. */
        public configuration?: (provision.IWifiConfiguration|null);

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

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

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

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

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

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

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

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

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

    /** Properties of a SetWifiConfigurationResponse. */
    interface ISetWifiConfigurationResponse {

        /** SetWifiConfigurationResponse success */
        success?: (boolean|null);
    }

    /** Represents a SetWifiConfigurationResponse. */
    class SetWifiConfigurationResponse implements ISetWifiConfigurationResponse {

        /**
         * Constructs a new SetWifiConfigurationResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.ISetWifiConfigurationResponse);

        /** SetWifiConfigurationResponse success. */
        public success: boolean;

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

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

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

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

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

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

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

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

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

    /** Properties of a GetApnCommand. */
    interface IGetApnCommand {
    }

    /** Represents a GetApnCommand. */
    class GetApnCommand implements IGetApnCommand {

        /**
         * Constructs a new GetApnCommand.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetApnCommand);

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

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

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

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

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

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

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

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

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

    /** Properties of a GetApnResponse. */
    interface IGetApnResponse {

        /** GetApnResponse apn */
        apn?: (Uint8Array|null);

        /** GetApnResponse success */
        success?: (boolean|null);
    }

    /** Represents a GetApnResponse. */
    class GetApnResponse implements IGetApnResponse {

        /**
         * Constructs a new GetApnResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetApnResponse);

        /** GetApnResponse apn. */
        public apn: Uint8Array;

        /** GetApnResponse success. */
        public success: boolean;

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

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

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

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

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

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

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

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

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

    /** Properties of a SetApnCommand. */
    interface ISetApnCommand {

        /** SetApnCommand apn */
        apn?: (Uint8Array|null);

        /** SetApnCommand clear */
        clear?: (boolean|null);
    }

    /** Represents a SetApnCommand. */
    class SetApnCommand implements ISetApnCommand {

        /**
         * Constructs a new SetApnCommand.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.ISetApnCommand);

        /** SetApnCommand apn. */
        public apn: Uint8Array;

        /** SetApnCommand clear. */
        public clear: boolean;

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

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

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

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

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

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

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

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

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

    /** Properties of a SetApnResponse. */
    interface ISetApnResponse {

        /** SetApnResponse success */
        success?: (boolean|null);
    }

    /** Represents a SetApnResponse. */
    class SetApnResponse implements ISetApnResponse {

        /**
         * Constructs a new SetApnResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.ISetApnResponse);

        /** SetApnResponse success. */
        public success: boolean;

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

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

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

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

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

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

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

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

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

    /** Properties of a GetIccidCommand. */
    interface IGetIccidCommand {
    }

    /** Represents a GetIccidCommand. */
    class GetIccidCommand implements IGetIccidCommand {

        /**
         * Constructs a new GetIccidCommand.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetIccidCommand);

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

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

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

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

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

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

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

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

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

    /** Properties of a GetIccidResponse. */
    interface IGetIccidResponse {

        /** GetIccidResponse iccid */
        iccid?: (Uint8Array|null);

        /** GetIccidResponse success */
        success?: (boolean|null);
    }

    /** Represents a GetIccidResponse. */
    class GetIccidResponse implements IGetIccidResponse {

        /**
         * Constructs a new GetIccidResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetIccidResponse);

        /** GetIccidResponse iccid. */
        public iccid: Uint8Array;

        /** GetIccidResponse success. */
        public success: boolean;

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

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

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

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

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

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

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

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

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

    /** Properties of a DeviceRegistrationRequestBody. */
    interface IDeviceRegistrationRequestBody {

        /** DeviceRegistrationRequestBody certificationRequest */
        certificationRequest?: (Uint8Array|null);

        /** DeviceRegistrationRequestBody attributes */
        attributes?: ({ [k: string]: string }|null);
    }

    /** Represents a DeviceRegistrationRequestBody. */
    class DeviceRegistrationRequestBody implements IDeviceRegistrationRequestBody {

        /**
         * Constructs a new DeviceRegistrationRequestBody.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IDeviceRegistrationRequestBody);

        /** DeviceRegistrationRequestBody certificationRequest. */
        public certificationRequest: Uint8Array;

        /** DeviceRegistrationRequestBody attributes. */
        public attributes: { [k: string]: string };

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

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

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

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

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

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

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

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

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

    /** Properties of a DeviceRegistrationRequest. */
    interface IDeviceRegistrationRequest {

        /** DeviceRegistrationRequest signerId */
        signerId?: (number|Long|null);

        /** DeviceRegistrationRequest body */
        body?: (provision.IDeviceRegistrationRequestBody|null);

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

    /** Represents a DeviceRegistrationRequest. */
    class DeviceRegistrationRequest implements IDeviceRegistrationRequest {

        /**
         * Constructs a new DeviceRegistrationRequest.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IDeviceRegistrationRequest);

        /** DeviceRegistrationRequest signerId. */
        public signerId: (number|Long);

        /** DeviceRegistrationRequest body. */
        public body?: (provision.IDeviceRegistrationRequestBody|null);

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

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

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

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

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

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

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

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

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

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

    /** Properties of a DeviceRegistrationResponse. */
    interface IDeviceRegistrationResponse {

        /** DeviceRegistrationResponse certificates */
        certificates?: (Uint8Array[]|null);

        /** DeviceRegistrationResponse homeServerSuffix */
        homeServerSuffix?: (string|null);
    }

    /** Represents a DeviceRegistrationResponse. */
    class DeviceRegistrationResponse implements IDeviceRegistrationResponse {

        /**
         * Constructs a new DeviceRegistrationResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IDeviceRegistrationResponse);

        /** DeviceRegistrationResponse certificates. */
        public certificates: Uint8Array[];

        /** DeviceRegistrationResponse homeServerSuffix. */
        public homeServerSuffix: string;

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

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

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

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

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

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

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

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

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

    /** Properties of a GetCertificateSigningRequestCommand. */
    interface IGetCertificateSigningRequestCommand {
    }

    /** Represents a GetCertificateSigningRequestCommand. */
    class GetCertificateSigningRequestCommand implements IGetCertificateSigningRequestCommand {

        /**
         * Constructs a new GetCertificateSigningRequestCommand.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetCertificateSigningRequestCommand);

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

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

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

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

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

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

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

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

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

    /** Properties of a GetCertificateSigningRequestResponse. */
    interface IGetCertificateSigningRequestResponse {

        /** GetCertificateSigningRequestResponse request */
        request?: (provision.IDeviceRegistrationRequest|null);

        /** GetCertificateSigningRequestResponse success */
        success?: (boolean|null);
    }

    /** Represents a GetCertificateSigningRequestResponse. */
    class GetCertificateSigningRequestResponse implements IGetCertificateSigningRequestResponse {

        /**
         * Constructs a new GetCertificateSigningRequestResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetCertificateSigningRequestResponse);

        /** GetCertificateSigningRequestResponse request. */
        public request?: (provision.IDeviceRegistrationRequest|null);

        /** GetCertificateSigningRequestResponse success. */
        public success: boolean;

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

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

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

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

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

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

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

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

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

    /** Properties of a SaveCertificateCommand. */
    interface ISaveCertificateCommand {

        /** SaveCertificateCommand response */
        response?: (provision.IDeviceRegistrationResponse|null);
    }

    /** Represents a SaveCertificateCommand. */
    class SaveCertificateCommand implements ISaveCertificateCommand {

        /**
         * Constructs a new SaveCertificateCommand.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.ISaveCertificateCommand);

        /** SaveCertificateCommand response. */
        public response?: (provision.IDeviceRegistrationResponse|null);

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

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

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

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

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

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

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

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

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

    /** Properties of a SaveCertificateResponse. */
    interface ISaveCertificateResponse {

        /** SaveCertificateResponse success */
        success?: (boolean|null);
    }

    /** Represents a SaveCertificateResponse. */
    class SaveCertificateResponse implements ISaveCertificateResponse {

        /**
         * Constructs a new SaveCertificateResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.ISaveCertificateResponse);

        /** SaveCertificateResponse success. */
        public success: boolean;

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

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

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

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

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

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

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

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

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

    /** ProvisioningStep enum. */
    enum ProvisioningStep {
        INVALID = 0,
        LOAD_MICROVISOR_TEST_IMAGE = 1,
        HARDWARE_TEST = 2,
        APPLICATION_TEST = 3
    }

    /** StepState enum. */
    enum StepState {
        IN_PROGRESS = 0,
        SUCCESS = 1,
        FAILURE = 2
    }

    /** Properties of a GetCurrentStepRequest. */
    interface IGetCurrentStepRequest {
    }

    /** Represents a GetCurrentStepRequest. */
    class GetCurrentStepRequest implements IGetCurrentStepRequest {

        /**
         * Constructs a new GetCurrentStepRequest.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetCurrentStepRequest);

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

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

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

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

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

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

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

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

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

    /** Properties of a GetCurrentStepResponse. */
    interface IGetCurrentStepResponse {

        /** GetCurrentStepResponse step */
        step?: (provision.ProvisioningStep|null);

        /** GetCurrentStepResponse state */
        state?: (provision.StepState|null);

        /** GetCurrentStepResponse extraData */
        extraData?: (Uint8Array|null);
    }

    /** Represents a GetCurrentStepResponse. */
    class GetCurrentStepResponse implements IGetCurrentStepResponse {

        /**
         * Constructs a new GetCurrentStepResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IGetCurrentStepResponse);

        /** GetCurrentStepResponse step. */
        public step: provision.ProvisioningStep;

        /** GetCurrentStepResponse state. */
        public state: provision.StepState;

        /** GetCurrentStepResponse extraData. */
        public extraData: Uint8Array;

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

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

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

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

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

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

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

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

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

    /** Properties of an AcknowledgeStepRequest. */
    interface IAcknowledgeStepRequest {

        /** AcknowledgeStepRequest step */
        step?: (provision.ProvisioningStep|null);
    }

    /** Represents an AcknowledgeStepRequest. */
    class AcknowledgeStepRequest implements IAcknowledgeStepRequest {

        /**
         * Constructs a new AcknowledgeStepRequest.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IAcknowledgeStepRequest);

        /** AcknowledgeStepRequest step. */
        public step: provision.ProvisioningStep;

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

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

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

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

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

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

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

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

    /** Properties of an AcknowledgeStepResponse. */
    interface IAcknowledgeStepResponse {
    }

    /** Represents an AcknowledgeStepResponse. */
    class AcknowledgeStepResponse implements IAcknowledgeStepResponse {

        /**
         * Constructs a new AcknowledgeStepResponse.
         * @param [properties] Properties to set
         */
        constructor(properties?: provision.IAcknowledgeStepResponse);

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

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

        /**
         * Encodes the specified AcknowledgeStepResponse message, length delimited. Does not implicitly {@link provision.AcknowledgeStepResponse.verify|verify} messages.
         * @param message AcknowledgeStepResponse message or plain object to encode
         * @param [writer] Writer to encode to
         * @returns Writer
         */
        public static encodeDelimited(message: provision.IAcknowledgeStepResponse, writer?: $protobuf.Writer): $protobuf.Writer;

        /**
         * Decodes an AcknowledgeStepResponse message from the specified reader or buffer.
         * @param reader Reader or buffer to decode from
         * @param [length] Message length if known beforehand
         * @returns AcknowledgeStepResponse
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): provision.AcknowledgeStepResponse;

        /**
         * Decodes an AcknowledgeStepResponse message from the specified reader or buffer, length delimited.
         * @param reader Reader or buffer to decode from
         * @returns AcknowledgeStepResponse
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): provision.AcknowledgeStepResponse;

        /**
         * Verifies an AcknowledgeStepResponse message.
         * @param message Plain 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 AcknowledgeStepResponse message from a plain object. Also converts values to their respective internal types.
         * @param object Plain object
         * @returns AcknowledgeStepResponse
         */
        public static fromObject(object: { [k: string]: any }): provision.AcknowledgeStepResponse;

        /**
         * Creates a plain object from an AcknowledgeStepResponse message. Also converts values to other types if specified.
         * @param message AcknowledgeStepResponse
         * @param [options] Conversion options
         * @returns Plain object
         */
        public static toObject(message: provision.AcknowledgeStepResponse, options?: $protobuf.IConversionOptions): { [k: string]: any };

        /**
         * Converts this AcknowledgeStepResponse to JSON.
         * @returns JSON object
         */
        public toJSON(): { [k: string]: any };
    }
}