@huddly/camera-proto/lib/api/huddly_pb.d.ts

An npm package describing the protobuf api for huddly network cameras

// package: huddly
// file: api/huddly.proto

/* tslint:disable */
/* eslint-disable */

import * as jspb from "google-protobuf";
import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb";
import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb";

export class Signature extends jspb.Message { 
    getData(): Uint8Array | string;
    getData_asU8(): Uint8Array;
    getData_asB64(): string;
    setData(value: Uint8Array | string): Signature;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Signature.AsObject;
    static toObject(includeInstance: boolean, msg: Signature): Signature.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Signature, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Signature;
    static deserializeBinaryFromReader(message: Signature, reader: jspb.BinaryReader): Signature;
}

export namespace Signature {
    export type AsObject = {
        data: Uint8Array | string,
    }
}

export class OptionCertificates extends jspb.Message { 
    clearCertificatesList(): void;
    getCertificatesList(): Array<OptionCertificates.OptionCertificate>;
    setCertificatesList(value: Array<OptionCertificates.OptionCertificate>): OptionCertificates;
    addCertificates(value?: OptionCertificates.OptionCertificate, index?: number): OptionCertificates.OptionCertificate;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): OptionCertificates.AsObject;
    static toObject(includeInstance: boolean, msg: OptionCertificates): OptionCertificates.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: OptionCertificates, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): OptionCertificates;
    static deserializeBinaryFromReader(message: OptionCertificates, reader: jspb.BinaryReader): OptionCertificates;
}

export namespace OptionCertificates {
    export type AsObject = {
        certificatesList: Array<OptionCertificates.OptionCertificate.AsObject>,
    }


    export class OptionCertificate extends jspb.Message { 
        getName(): string;
        setName(value: string): OptionCertificate;
        getCertificate(): Uint8Array | string;
        getCertificate_asU8(): Uint8Array;
        getCertificate_asB64(): string;
        setCertificate(value: Uint8Array | string): OptionCertificate;

        serializeBinary(): Uint8Array;
        toObject(includeInstance?: boolean): OptionCertificate.AsObject;
        static toObject(includeInstance: boolean, msg: OptionCertificate): OptionCertificate.AsObject;
        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
        static serializeBinaryToWriter(message: OptionCertificate, writer: jspb.BinaryWriter): void;
        static deserializeBinary(bytes: Uint8Array): OptionCertificate;
        static deserializeBinaryFromReader(message: OptionCertificate, reader: jspb.BinaryReader): OptionCertificate;
    }

    export namespace OptionCertificate {
        export type AsObject = {
            name: string,
            certificate: Uint8Array | string,
        }
    }

}

export class VerificationRequest extends jspb.Message { 
    getFormat(): VerificationFormat;
    setFormat(value: VerificationFormat): VerificationRequest;
    getData(): Uint8Array | string;
    getData_asU8(): Uint8Array;
    getData_asB64(): string;
    setData(value: Uint8Array | string): VerificationRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): VerificationRequest.AsObject;
    static toObject(includeInstance: boolean, msg: VerificationRequest): VerificationRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: VerificationRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): VerificationRequest;
    static deserializeBinaryFromReader(message: VerificationRequest, reader: jspb.BinaryReader): VerificationRequest;
}

export namespace VerificationRequest {
    export type AsObject = {
        format: VerificationFormat,
        data: Uint8Array | string,
    }
}

export class UserIdentifier extends jspb.Message { 
    getId(): string;
    setId(value: string): UserIdentifier;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): UserIdentifier.AsObject;
    static toObject(includeInstance: boolean, msg: UserIdentifier): UserIdentifier.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: UserIdentifier, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): UserIdentifier;
    static deserializeBinaryFromReader(message: UserIdentifier, reader: jspb.BinaryReader): UserIdentifier;
}

export namespace UserIdentifier {
    export type AsObject = {
        id: string,
    }
}

export class CropIndexStatusRequest extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): CropIndexStatusRequest.AsObject;
    static toObject(includeInstance: boolean, msg: CropIndexStatusRequest): CropIndexStatusRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: CropIndexStatusRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): CropIndexStatusRequest;
    static deserializeBinaryFromReader(message: CropIndexStatusRequest, reader: jspb.BinaryReader): CropIndexStatusRequest;
}

export namespace CropIndexStatusRequest {
    export type AsObject = {
    }
}

export class CropIndexStatusResponse extends jspb.Message { 
    getCropIndex(): number;
    setCropIndex(value: number): CropIndexStatusResponse;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): CropIndexStatusResponse.AsObject;
    static toObject(includeInstance: boolean, msg: CropIndexStatusResponse): CropIndexStatusResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: CropIndexStatusResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): CropIndexStatusResponse;
    static deserializeBinaryFromReader(message: CropIndexStatusResponse, reader: jspb.BinaryReader): CropIndexStatusResponse;
}

export namespace CropIndexStatusResponse {
    export type AsObject = {
        cropIndex: number,
    }
}

export class Rect extends jspb.Message { 
    getXCenter(): number;
    setXCenter(value: number): Rect;
    getYCenter(): number;
    setYCenter(value: number): Rect;
    getZoomFactor(): number;
    setZoomFactor(value: number): Rect;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Rect.AsObject;
    static toObject(includeInstance: boolean, msg: Rect): Rect.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Rect, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Rect;
    static deserializeBinaryFromReader(message: Rect, reader: jspb.BinaryReader): Rect;
}

export namespace Rect {
    export type AsObject = {
        xCenter: number,
        yCenter: number,
        zoomFactor: number,
    }
}

export class Range extends jspb.Message { 
    getMin(): number;
    setMin(value: number): Range;
    getMax(): number;
    setMax(value: number): Range;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Range.AsObject;
    static toObject(includeInstance: boolean, msg: Range): Range.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Range, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Range;
    static deserializeBinaryFromReader(message: Range, reader: jspb.BinaryReader): Range;
}

export namespace Range {
    export type AsObject = {
        min: number,
        max: number,
    }
}

export class VideoFormats extends jspb.Message { 
    clearFormatsList(): void;
    getFormatsList(): Array<VideoFormats.Format>;
    setFormatsList(value: Array<VideoFormats.Format>): VideoFormats;
    addFormats(value?: VideoFormats.Format, index?: number): VideoFormats.Format;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): VideoFormats.AsObject;
    static toObject(includeInstance: boolean, msg: VideoFormats): VideoFormats.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: VideoFormats, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): VideoFormats;
    static deserializeBinaryFromReader(message: VideoFormats, reader: jspb.BinaryReader): VideoFormats;
}

export namespace VideoFormats {
    export type AsObject = {
        formatsList: Array<VideoFormats.Format.AsObject>,
    }


    export class Format extends jspb.Message { 
        getWidth(): number;
        setWidth(value: number): Format;
        getHeight(): number;
        setHeight(value: number): Format;

        hasZoom(): boolean;
        clearZoom(): void;
        getZoom(): Range | undefined;
        setZoom(value?: Range): Format;

        hasDzoom(): boolean;
        clearDzoom(): void;
        getDzoom(): Range | undefined;
        setDzoom(value?: Range): Format;

        hasPan(): boolean;
        clearPan(): void;
        getPan(): Range | undefined;
        setPan(value?: Range): Format;

        hasTilt(): boolean;
        clearTilt(): void;
        getTilt(): Range | undefined;
        setTilt(value?: Range): Format;
        getType(): VideoType;
        setType(value: VideoType): Format;
        getUri(): string;
        setUri(value: string): Format;
        getFps(): number;
        setFps(value: number): Format;

        serializeBinary(): Uint8Array;
        toObject(includeInstance?: boolean): Format.AsObject;
        static toObject(includeInstance: boolean, msg: Format): Format.AsObject;
        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
        static serializeBinaryToWriter(message: Format, writer: jspb.BinaryWriter): void;
        static deserializeBinary(bytes: Uint8Array): Format;
        static deserializeBinaryFromReader(message: Format, reader: jspb.BinaryReader): Format;
    }

    export namespace Format {
        export type AsObject = {
            width: number,
            height: number,
            zoom?: Range.AsObject,
            dzoom?: Range.AsObject,
            pan?: Range.AsObject,
            tilt?: Range.AsObject,
            type: VideoType,
            uri: string,
            fps: number,
        }
    }

}

export class IndexedTransitions extends jspb.Message { 
    clearStartingIndexList(): void;
    getStartingIndexList(): Array<number>;
    setStartingIndexList(value: Array<number>): IndexedTransitions;
    addStartingIndex(value: number, index?: number): number;
    clearTransitionList(): void;
    getTransitionList(): Array<IndexedTransitions.Transition>;
    setTransitionList(value: Array<IndexedTransitions.Transition>): IndexedTransitions;
    addTransition(value?: IndexedTransitions.Transition, index?: number): IndexedTransitions.Transition;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): IndexedTransitions.AsObject;
    static toObject(includeInstance: boolean, msg: IndexedTransitions): IndexedTransitions.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: IndexedTransitions, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): IndexedTransitions;
    static deserializeBinaryFromReader(message: IndexedTransitions, reader: jspb.BinaryReader): IndexedTransitions;
}

export namespace IndexedTransitions {
    export type AsObject = {
        startingIndexList: Array<number>,
        transitionList: Array<IndexedTransitions.Transition.AsObject>,
    }


    export class Transition extends jspb.Message { 
        clearCropsList(): void;
        getCropsList(): Array<IndexedTransitions.Transition.Crop>;
        setCropsList(value: Array<IndexedTransitions.Transition.Crop>): Transition;
        addCrops(value?: IndexedTransitions.Transition.Crop, index?: number): IndexedTransitions.Transition.Crop;

        serializeBinary(): Uint8Array;
        toObject(includeInstance?: boolean): Transition.AsObject;
        static toObject(includeInstance: boolean, msg: Transition): Transition.AsObject;
        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
        static serializeBinaryToWriter(message: Transition, writer: jspb.BinaryWriter): void;
        static deserializeBinary(bytes: Uint8Array): Transition;
        static deserializeBinaryFromReader(message: Transition, reader: jspb.BinaryReader): Transition;
    }

    export namespace Transition {
        export type AsObject = {
            cropsList: Array<IndexedTransitions.Transition.Crop.AsObject>,
        }


        export class Crop extends jspb.Message { 

            hasRect(): boolean;
            clearRect(): void;
            getRect(): Rect | undefined;
            setRect(value?: Rect): Crop;
            getCropIndex(): number;
            setCropIndex(value: number): Crop;

            serializeBinary(): Uint8Array;
            toObject(includeInstance?: boolean): Crop.AsObject;
            static toObject(includeInstance: boolean, msg: Crop): Crop.AsObject;
            static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
            static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
            static serializeBinaryToWriter(message: Crop, writer: jspb.BinaryWriter): void;
            static deserializeBinary(bytes: Uint8Array): Crop;
            static deserializeBinaryFromReader(message: Crop, reader: jspb.BinaryReader): Crop;
        }

        export namespace Crop {
            export type AsObject = {
                rect?: Rect.AsObject,
                cropIndex: number,
            }
        }

    }

}

export class IndexedTransitionsResponse extends jspb.Message { 
    getChosenStartingIndex(): number;
    setChosenStartingIndex(value: number): IndexedTransitionsResponse;

    hasCurrentPosition(): boolean;
    clearCurrentPosition(): void;
    getCurrentPosition(): Rect | undefined;
    setCurrentPosition(value?: Rect): IndexedTransitionsResponse;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): IndexedTransitionsResponse.AsObject;
    static toObject(includeInstance: boolean, msg: IndexedTransitionsResponse): IndexedTransitionsResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: IndexedTransitionsResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): IndexedTransitionsResponse;
    static deserializeBinaryFromReader(message: IndexedTransitionsResponse, reader: jspb.BinaryReader): IndexedTransitionsResponse;
}

export namespace IndexedTransitionsResponse {
    export type AsObject = {
        chosenStartingIndex: number,
        currentPosition?: Rect.AsObject,
    }
}

export class CurrentPtzCrop extends jspb.Message { 

    hasCurrentCrop(): boolean;
    clearCurrentCrop(): void;
    getCurrentCrop(): Rect | undefined;
    setCurrentCrop(value?: Rect): CurrentPtzCrop;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): CurrentPtzCrop.AsObject;
    static toObject(includeInstance: boolean, msg: CurrentPtzCrop): CurrentPtzCrop.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: CurrentPtzCrop, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): CurrentPtzCrop;
    static deserializeBinaryFromReader(message: CurrentPtzCrop, reader: jspb.BinaryReader): CurrentPtzCrop;
}

export namespace CurrentPtzCrop {
    export type AsObject = {
        currentCrop?: Rect.AsObject,
    }
}

export class Chunk extends jspb.Message { 
    getContent(): Uint8Array | string;
    getContent_asU8(): Uint8Array;
    getContent_asB64(): string;
    setContent(value: Uint8Array | string): Chunk;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Chunk.AsObject;
    static toObject(includeInstance: boolean, msg: Chunk): Chunk.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Chunk, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Chunk;
    static deserializeBinaryFromReader(message: Chunk, reader: jspb.BinaryReader): Chunk;
}

export namespace Chunk {
    export type AsObject = {
        content: Uint8Array | string,
    }
}

export class DeviceVersion extends jspb.Message { 
    getVersion(): string;
    setVersion(value: string): DeviceVersion;
    getVersionState(): VersionState;
    setVersionState(value: VersionState): DeviceVersion;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): DeviceVersion.AsObject;
    static toObject(includeInstance: boolean, msg: DeviceVersion): DeviceVersion.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: DeviceVersion, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): DeviceVersion;
    static deserializeBinaryFromReader(message: DeviceVersion, reader: jspb.BinaryReader): DeviceVersion;
}

export namespace DeviceVersion {
    export type AsObject = {
        version: string,
        versionState: VersionState,
    }
}

export class PTZ extends jspb.Message { 
    getPan(): number;
    setPan(value: number): PTZ;
    getTilt(): number;
    setTilt(value: number): PTZ;
    getZoom(): number;
    setZoom(value: number): PTZ;
    getTrans(): number;
    setTrans(value: number): PTZ;

    hasRangepan(): boolean;
    clearRangepan(): void;
    getRangepan(): Range | undefined;
    setRangepan(value?: Range): PTZ;

    hasRangetilt(): boolean;
    clearRangetilt(): void;
    getRangetilt(): Range | undefined;
    setRangetilt(value?: Range): PTZ;

    hasRangezoom(): boolean;
    clearRangezoom(): void;
    getRangezoom(): Range | undefined;
    setRangezoom(value?: Range): PTZ;

    hasRangedzoom(): boolean;
    clearRangedzoom(): void;
    getRangedzoom(): Range | undefined;
    setRangedzoom(value?: Range): PTZ;
    getDefaultpan(): number;
    setDefaultpan(value: number): PTZ;
    getDefaulttilt(): number;
    setDefaulttilt(value: number): PTZ;
    getDefaultzoom(): number;
    setDefaultzoom(value: number): PTZ;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): PTZ.AsObject;
    static toObject(includeInstance: boolean, msg: PTZ): PTZ.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: PTZ, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): PTZ;
    static deserializeBinaryFromReader(message: PTZ, reader: jspb.BinaryReader): PTZ;
}

export namespace PTZ {
    export type AsObject = {
        pan: number,
        tilt: number,
        zoom: number,
        trans: number,
        rangepan?: Range.AsObject,
        rangetilt?: Range.AsObject,
        rangezoom?: Range.AsObject,
        rangedzoom?: Range.AsObject,
        defaultpan: number,
        defaulttilt: number,
        defaultzoom: number,
    }
}

export class PTZNormalized extends jspb.Message { 
    getPan(): number;
    setPan(value: number): PTZNormalized;
    getTilt(): number;
    setTilt(value: number): PTZNormalized;
    getZoom(): number;
    setZoom(value: number): PTZNormalized;
    getTransition(): boolean;
    setTransition(value: boolean): PTZNormalized;

    hasTransitionTimeMs(): boolean;
    clearTransitionTimeMs(): void;
    getTransitionTimeMs(): number | undefined;
    setTransitionTimeMs(value: number): PTZNormalized;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): PTZNormalized.AsObject;
    static toObject(includeInstance: boolean, msg: PTZNormalized): PTZNormalized.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: PTZNormalized, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): PTZNormalized;
    static deserializeBinaryFromReader(message: PTZNormalized, reader: jspb.BinaryReader): PTZNormalized;
}

export namespace PTZNormalized {
    export type AsObject = {
        pan: number,
        tilt: number,
        zoom: number,
        transition: boolean,
        transitionTimeMs?: number,
    }
}

export class SingleNormalizedPTZEntry extends jspb.Message { 
    getValue(): number;
    setValue(value: number): SingleNormalizedPTZEntry;
    getZoomFactor(): number;
    setZoomFactor(value: number): SingleNormalizedPTZEntry;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): SingleNormalizedPTZEntry.AsObject;
    static toObject(includeInstance: boolean, msg: SingleNormalizedPTZEntry): SingleNormalizedPTZEntry.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: SingleNormalizedPTZEntry, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): SingleNormalizedPTZEntry;
    static deserializeBinaryFromReader(message: SingleNormalizedPTZEntry, reader: jspb.BinaryReader): SingleNormalizedPTZEntry;
}

export namespace SingleNormalizedPTZEntry {
    export type AsObject = {
        value: number,
        zoomFactor: number,
    }
}

export class Bbox extends jspb.Message { 
    getX(): number;
    setX(value: number): Bbox;
    getY(): number;
    setY(value: number): Bbox;
    getWidth(): number;
    setWidth(value: number): Bbox;
    getHeight(): number;
    setHeight(value: number): Bbox;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Bbox.AsObject;
    static toObject(includeInstance: boolean, msg: Bbox): Bbox.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Bbox, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Bbox;
    static deserializeBinaryFromReader(message: Bbox, reader: jspb.BinaryReader): Bbox;
}

export namespace Bbox {
    export type AsObject = {
        x: number,
        y: number,
        width: number,
        height: number,
    }
}

export class Frame extends jspb.Message { 

    hasBbox(): boolean;
    clearBbox(): void;
    getBbox(): Bbox | undefined;
    setBbox(value?: Bbox): Frame;
    getSmoothTransition(): number;
    setSmoothTransition(value: number): Frame;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Frame.AsObject;
    static toObject(includeInstance: boolean, msg: Frame): Frame.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Frame, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Frame;
    static deserializeBinaryFromReader(message: Frame, reader: jspb.BinaryReader): Frame;
}

export namespace Frame {
    export type AsObject = {
        bbox?: Bbox.AsObject,
        smoothTransition: number,
    }
}

export class Detection extends jspb.Message { 
    getId(): number;
    setId(value: number): Detection;
    getLabel(): string;
    setLabel(value: string): Detection;
    getConfidence(): number;
    setConfidence(value: number): Detection;

    hasBbox(): boolean;
    clearBbox(): void;
    getBbox(): Bbox | undefined;
    setBbox(value?: Bbox): Detection;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Detection.AsObject;
    static toObject(includeInstance: boolean, msg: Detection): Detection.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Detection, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Detection;
    static deserializeBinaryFromReader(message: Detection, reader: jspb.BinaryReader): Detection;
}

export namespace Detection {
    export type AsObject = {
        id: number,
        label: string,
        confidence: number,
        bbox?: Bbox.AsObject,
    }
}

export class Detections extends jspb.Message { 
    clearDetectionsList(): void;
    getDetectionsList(): Array<Detection>;
    setDetectionsList(value: Array<Detection>): Detections;
    addDetections(value?: Detection, index?: number): Detection;
    getTimestamp(): number;
    setTimestamp(value: number): Detections;
    getFrameCount(): number;
    setFrameCount(value: number): Detections;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Detections.AsObject;
    static toObject(includeInstance: boolean, msg: Detections): Detections.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Detections, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Detections;
    static deserializeBinaryFromReader(message: Detections, reader: jspb.BinaryReader): Detections;
}

export namespace Detections {
    export type AsObject = {
        detectionsList: Array<Detection.AsObject>,
        timestamp: number,
        frameCount: number,
    }
}

export class LEDControl extends jspb.Message { 
    getLed(): LEDState;
    setLed(value: LEDState): LEDControl;
    getActive(): number;
    setActive(value: number): LEDControl;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): LEDControl.AsObject;
    static toObject(includeInstance: boolean, msg: LEDControl): LEDControl.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: LEDControl, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): LEDControl;
    static deserializeBinaryFromReader(message: LEDControl, reader: jspb.BinaryReader): LEDControl;
}

export namespace LEDControl {
    export type AsObject = {
        led: LEDState,
        active: number,
    }
}

export class DeviceName extends jspb.Message { 
    getName(): string;
    setName(value: string): DeviceName;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): DeviceName.AsObject;
    static toObject(includeInstance: boolean, msg: DeviceName): DeviceName.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: DeviceName, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): DeviceName;
    static deserializeBinaryFromReader(message: DeviceName, reader: jspb.BinaryReader): DeviceName;
}

export namespace DeviceName {
    export type AsObject = {
        name: string,
    }
}

export class BootSlot extends jspb.Message { 
    getSlot(): Slot;
    setSlot(value: Slot): BootSlot;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): BootSlot.AsObject;
    static toObject(includeInstance: boolean, msg: BootSlot): BootSlot.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: BootSlot, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): BootSlot;
    static deserializeBinaryFromReader(message: BootSlot, reader: jspb.BinaryReader): BootSlot;
}

export namespace BootSlot {
    export type AsObject = {
        slot: Slot,
    }
}

export class DeviceStatus extends jspb.Message { 
    getMessage(): string;
    setMessage(value: string): DeviceStatus;
    getCode(): StatusCode;
    setCode(value: StatusCode): DeviceStatus;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): DeviceStatus.AsObject;
    static toObject(includeInstance: boolean, msg: DeviceStatus): DeviceStatus.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: DeviceStatus, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): DeviceStatus;
    static deserializeBinaryFromReader(message: DeviceStatus, reader: jspb.BinaryReader): DeviceStatus;
}

export namespace DeviceStatus {
    export type AsObject = {
        message: string,
        code: StatusCode,
    }
}

export class DnsServerEntry extends jspb.Message { 
    getAddress(): string;
    setAddress(value: string): DnsServerEntry;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): DnsServerEntry.AsObject;
    static toObject(includeInstance: boolean, msg: DnsServerEntry): DnsServerEntry.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: DnsServerEntry, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): DnsServerEntry;
    static deserializeBinaryFromReader(message: DnsServerEntry, reader: jspb.BinaryReader): DnsServerEntry;
}

export namespace DnsServerEntry {
    export type AsObject = {
        address: string,
    }
}

export class SearchDomainEntry extends jspb.Message { 
    getSearchdomain(): string;
    setSearchdomain(value: string): SearchDomainEntry;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): SearchDomainEntry.AsObject;
    static toObject(includeInstance: boolean, msg: SearchDomainEntry): SearchDomainEntry.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: SearchDomainEntry, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): SearchDomainEntry;
    static deserializeBinaryFromReader(message: SearchDomainEntry, reader: jspb.BinaryReader): SearchDomainEntry;
}

export namespace SearchDomainEntry {
    export type AsObject = {
        searchdomain: string,
    }
}

export class NetworkIpv4Config extends jspb.Message { 
    getStaticaddress(): string;
    setStaticaddress(value: string): NetworkIpv4Config;
    getSubnetmask(): string;
    setSubnetmask(value: string): NetworkIpv4Config;
    getDefaultgateway(): string;
    setDefaultgateway(value: string): NetworkIpv4Config;
    getPolicy(): IPAssignmentPolicy;
    setPolicy(value: IPAssignmentPolicy): NetworkIpv4Config;
    clearDnsserveraddressesList(): void;
    getDnsserveraddressesList(): Array<DnsServerEntry>;
    setDnsserveraddressesList(value: Array<DnsServerEntry>): NetworkIpv4Config;
    addDnsserveraddresses(value?: DnsServerEntry, index?: number): DnsServerEntry;
    clearSearchdomainsList(): void;
    getSearchdomainsList(): Array<SearchDomainEntry>;
    setSearchdomainsList(value: Array<SearchDomainEntry>): NetworkIpv4Config;
    addSearchdomains(value?: SearchDomainEntry, index?: number): SearchDomainEntry;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): NetworkIpv4Config.AsObject;
    static toObject(includeInstance: boolean, msg: NetworkIpv4Config): NetworkIpv4Config.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: NetworkIpv4Config, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): NetworkIpv4Config;
    static deserializeBinaryFromReader(message: NetworkIpv4Config, reader: jspb.BinaryReader): NetworkIpv4Config;
}

export namespace NetworkIpv4Config {
    export type AsObject = {
        staticaddress: string,
        subnetmask: string,
        defaultgateway: string,
        policy: IPAssignmentPolicy,
        dnsserveraddressesList: Array<DnsServerEntry.AsObject>,
        searchdomainsList: Array<SearchDomainEntry.AsObject>,
    }
}

export class Temperature extends jspb.Message { 
    getName(): string;
    setName(value: string): Temperature;
    getValue(): number;
    setValue(value: number): Temperature;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Temperature.AsObject;
    static toObject(includeInstance: boolean, msg: Temperature): Temperature.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Temperature, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Temperature;
    static deserializeBinaryFromReader(message: Temperature, reader: jspb.BinaryReader): Temperature;
}

export namespace Temperature {
    export type AsObject = {
        name: string,
        value: number,
    }
}

export class Temperatures extends jspb.Message { 
    clearTemperaturesList(): void;
    getTemperaturesList(): Array<Temperature>;
    setTemperaturesList(value: Array<Temperature>): Temperatures;
    addTemperatures(value?: Temperature, index?: number): Temperature;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Temperatures.AsObject;
    static toObject(includeInstance: boolean, msg: Temperatures): Temperatures.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Temperatures, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Temperatures;
    static deserializeBinaryFromReader(message: Temperatures, reader: jspb.BinaryReader): Temperatures;
}

export namespace Temperatures {
    export type AsObject = {
        temperaturesList: Array<Temperature.AsObject>,
    }
}

export class CNNStatus extends jspb.Message { 
    getCode(): StatusCode;
    setCode(value: StatusCode): CNNStatus;

    hasFbeStatus(): boolean;
    clearFbeStatus(): void;
    getFbeStatus(): FBEStatus | undefined;
    setFbeStatus(value?: FBEStatus): CNNStatus;

    hasAzStatus(): boolean;
    clearAzStatus(): void;
    getAzStatus(): AZStatus | undefined;
    setAzStatus(value?: AZStatus): CNNStatus;
    getEnabled(): boolean;
    setEnabled(value: boolean): CNNStatus;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): CNNStatus.AsObject;
    static toObject(includeInstance: boolean, msg: CNNStatus): CNNStatus.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: CNNStatus, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): CNNStatus;
    static deserializeBinaryFromReader(message: CNNStatus, reader: jspb.BinaryReader): CNNStatus;
}

export namespace CNNStatus {
    export type AsObject = {
        code: StatusCode,
        fbeStatus?: FBEStatus.AsObject,
        azStatus?: AZStatus.AsObject,
        enabled: boolean,
    }
}

export class FBEStatus extends jspb.Message { 
    getFbeEnabled(): boolean;
    setFbeEnabled(value: boolean): FBEStatus;
    getNumIterations(): number;
    setNumIterations(value: number): FBEStatus;
    getNumWeightsCalculated(): number;
    setNumWeightsCalculated(value: number): FBEStatus;
    getCurrentFaceWeight(): number;
    setCurrentFaceWeight(value: number): FBEStatus;
    clearPerFaceWeightList(): void;
    getPerFaceWeightList(): Array<number>;
    setPerFaceWeightList(value: Array<number>): FBEStatus;
    addPerFaceWeight(value: number, index?: number): number;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): FBEStatus.AsObject;
    static toObject(includeInstance: boolean, msg: FBEStatus): FBEStatus.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: FBEStatus, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): FBEStatus;
    static deserializeBinaryFromReader(message: FBEStatus, reader: jspb.BinaryReader): FBEStatus;
}

export namespace FBEStatus {
    export type AsObject = {
        fbeEnabled: boolean,
        numIterations: number,
        numWeightsCalculated: number,
        currentFaceWeight: number,
        perFaceWeightList: Array<number>,
    }
}

export class AZStatus extends jspb.Message { 
    getAzEnabled(): boolean;
    setAzEnabled(value: boolean): AZStatus;
    getNetworkConfigured(): boolean;
    setNetworkConfigured(value: boolean): AZStatus;
    getTensorCount(): number;
    setTensorCount(value: number): AZStatus;
    getFramesApplied(): number;
    setFramesApplied(value: number): AZStatus;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AZStatus.AsObject;
    static toObject(includeInstance: boolean, msg: AZStatus): AZStatus.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AZStatus, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AZStatus;
    static deserializeBinaryFromReader(message: AZStatus, reader: jspb.BinaryReader): AZStatus;
}

export namespace AZStatus {
    export type AsObject = {
        azEnabled: boolean,
        networkConfigured: boolean,
        tensorCount: number,
        framesApplied: number,
    }
}

export class MulticamExposureStatus extends jspb.Message { 
    getCode(): StatusCode;
    setCode(value: StatusCode): MulticamExposureStatus;
    getEnabled(): boolean;
    setEnabled(value: boolean): MulticamExposureStatus;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MulticamExposureStatus.AsObject;
    static toObject(includeInstance: boolean, msg: MulticamExposureStatus): MulticamExposureStatus.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MulticamExposureStatus, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MulticamExposureStatus;
    static deserializeBinaryFromReader(message: MulticamExposureStatus, reader: jspb.BinaryReader): MulticamExposureStatus;
}

export namespace MulticamExposureStatus {
    export type AsObject = {
        code: StatusCode,
        enabled: boolean,
    }
}

export class MulticamWhitebalanceStatus extends jspb.Message { 
    getCode(): StatusCode;
    setCode(value: StatusCode): MulticamWhitebalanceStatus;
    getEnabled(): boolean;
    setEnabled(value: boolean): MulticamWhitebalanceStatus;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MulticamWhitebalanceStatus.AsObject;
    static toObject(includeInstance: boolean, msg: MulticamWhitebalanceStatus): MulticamWhitebalanceStatus.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MulticamWhitebalanceStatus, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MulticamWhitebalanceStatus;
    static deserializeBinaryFromReader(message: MulticamWhitebalanceStatus, reader: jspb.BinaryReader): MulticamWhitebalanceStatus;
}

export namespace MulticamWhitebalanceStatus {
    export type AsObject = {
        code: StatusCode,
        enabled: boolean,
    }
}

export class TimestampingStatus extends jspb.Message { 
    getCode(): StatusCode;
    setCode(value: StatusCode): TimestampingStatus;
    getEnabled(): boolean;
    setEnabled(value: boolean): TimestampingStatus;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): TimestampingStatus.AsObject;
    static toObject(includeInstance: boolean, msg: TimestampingStatus): TimestampingStatus.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: TimestampingStatus, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): TimestampingStatus;
    static deserializeBinaryFromReader(message: TimestampingStatus, reader: jspb.BinaryReader): TimestampingStatus;
}

export namespace TimestampingStatus {
    export type AsObject = {
        code: StatusCode,
        enabled: boolean,
    }
}

export class LogFile extends jspb.Message { 
    getFile(): LogFiles;
    setFile(value: LogFiles): LogFile;
    getKeepLog(): boolean;
    setKeepLog(value: boolean): LogFile;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): LogFile.AsObject;
    static toObject(includeInstance: boolean, msg: LogFile): LogFile.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: LogFile, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): LogFile;
    static deserializeBinaryFromReader(message: LogFile, reader: jspb.BinaryReader): LogFile;
}

export namespace LogFile {
    export type AsObject = {
        file: LogFiles,
        keepLog: boolean,
    }
}

export class FakeDetections extends jspb.Message { 
    getMode(): Mode;
    setMode(value: Mode): FakeDetections;
    getNumFakeDetections(): number;
    setNumFakeDetections(value: number): FakeDetections;
    getFeature(): Feature;
    setFeature(value: Feature): FakeDetections;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): FakeDetections.AsObject;
    static toObject(includeInstance: boolean, msg: FakeDetections): FakeDetections.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: FakeDetections, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): FakeDetections;
    static deserializeBinaryFromReader(message: FakeDetections, reader: jspb.BinaryReader): FakeDetections;
}

export namespace FakeDetections {
    export type AsObject = {
        mode: Mode,
        numFakeDetections: number,
        feature: Feature,
    }
}

export class LogVerbosity extends jspb.Message { 
    getVerbosity(): LogVerbosity.Verbosity;
    setVerbosity(value: LogVerbosity.Verbosity): LogVerbosity;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): LogVerbosity.AsObject;
    static toObject(includeInstance: boolean, msg: LogVerbosity): LogVerbosity.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: LogVerbosity, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): LogVerbosity;
    static deserializeBinaryFromReader(message: LogVerbosity, reader: jspb.BinaryReader): LogVerbosity;
}

export namespace LogVerbosity {
    export type AsObject = {
        verbosity: LogVerbosity.Verbosity,
    }

    export enum Verbosity {
    NONE = 0,
    ERROR = 1,
    WARNING = 2,
    INFO = 3,
    DEBUG = 4,
    DEBUG1 = 5,
    DEBUG2 = 6,
    DEBUG3 = 7,
    }

}

export class MemoryLogState extends jspb.Message { 
    getLogState(): Mode;
    setLogState(value: Mode): MemoryLogState;
    getLogIntervalS(): number;
    setLogIntervalS(value: number): MemoryLogState;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MemoryLogState.AsObject;
    static toObject(includeInstance: boolean, msg: MemoryLogState): MemoryLogState.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MemoryLogState, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MemoryLogState;
    static deserializeBinaryFromReader(message: MemoryLogState, reader: jspb.BinaryReader): MemoryLogState;
}

export namespace MemoryLogState {
    export type AsObject = {
        logState: Mode,
        logIntervalS: number,
    }
}

export class CnnFeature extends jspb.Message { 
    getMode(): Mode;
    setMode(value: Mode): CnnFeature;
    getFeature(): Feature;
    setFeature(value: Feature): CnnFeature;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): CnnFeature.AsObject;
    static toObject(includeInstance: boolean, msg: CnnFeature): CnnFeature.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: CnnFeature, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): CnnFeature;
    static deserializeBinaryFromReader(message: CnnFeature, reader: jspb.BinaryReader): CnnFeature;
}

export namespace CnnFeature {
    export type AsObject = {
        mode: Mode,
        feature: Feature,
    }
}

export class MulticamExposure extends jspb.Message { 
    getMode(): Mode;
    setMode(value: Mode): MulticamExposure;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MulticamExposure.AsObject;
    static toObject(includeInstance: boolean, msg: MulticamExposure): MulticamExposure.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MulticamExposure, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MulticamExposure;
    static deserializeBinaryFromReader(message: MulticamExposure, reader: jspb.BinaryReader): MulticamExposure;
}

export namespace MulticamExposure {
    expo