@twilio/plugin-microvisor/proto_gen/proto.d.ts

Interact with your Twilio Microvisor devices

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():