// 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 {
    export type AsObject = {
        mode: Mode,
    }
}

export class AllowedDeviationEV extends jspb.Message { 
    getDeviationEv(): number;
    setDeviationEv(value: number): AllowedDeviationEV;

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

export namespace AllowedDeviationEV {
    export type AsObject = {
        deviationEv: number,
    }
}

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

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

export namespace MulticamWhitebalance {
    export type AsObject = {
        mode: Mode,
    }
}

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

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

export namespace Timestamping {
    export type AsObject = {
        mode: Mode,
    }
}

export class PeopleCountResponse extends jspb.Message { 
    getCount(): number;
    setCount(value: number): PeopleCountResponse;

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

export namespace PeopleCountResponse {
    export type AsObject = {
        count: number,
    }
}

export class Uptime extends jspb.Message { 
    getUptime(): number;
    setUptime(value: number): Uptime;

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

export namespace Uptime {
    export type AsObject = {
        uptime: number,
    }
}

export class Timezone extends jspb.Message { 
    getTimezone(): string;
    setTimezone(value: string): Timezone;

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

export namespace Timezone {
    export type AsObject = {
        timezone: string,
    }
}

export class Brightness extends jspb.Message { 
    getBrightness(): number;
    setBrightness(value: number): Brightness;

    hasRange(): boolean;
    clearRange(): void;
    getRange(): Range | undefined;
    setRange(value?: Range): Brightness;
    getDefaultBrightness(): number;
    setDefaultBrightness(value: number): Brightness;

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

export namespace Brightness {
    export type AsObject = {
        brightness: number,
        range?: Range.AsObject,
        defaultBrightness: number,
    }
}

export class Saturation extends jspb.Message { 
    getSaturation(): number;
    setSaturation(value: number): Saturation;

    hasRange(): boolean;
    clearRange(): void;
    getRange(): Range | undefined;
    setRange(value?: Range): Saturation;
    getDefaultSaturation(): number;
    setDefaultSaturation(value: number): Saturation;

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

export namespace Saturation {
    export type AsObject = {
        saturation: number,
        range?: Range.AsObject,
        defaultSaturation: number,
    }
}

export class PerspectiveCorrectionSettings extends jspb.Message { 
    getType(): PerspectiveCorrectionType;
    setType(value: PerspectiveCorrectionType): PerspectiveCorrectionSettings;

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

export namespace PerspectiveCorrectionSettings {
    export type AsObject = {
        type: PerspectiveCorrectionType,
    }
}

export class OverlayFeatureMessage extends jspb.Message { 
    getFeature(): OverlayFeature;
    setFeature(value: OverlayFeature): OverlayFeatureMessage;
    getState(): OverlayState;
    setState(value: OverlayState): OverlayFeatureMessage;

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

export namespace OverlayFeatureMessage {
    export type AsObject = {
        feature: OverlayFeature,
        state: OverlayState,
    }
}

export class OverlayFeatureStatus extends jspb.Message { 

    hasDeviceStatus(): boolean;
    clearDeviceStatus(): void;
    getDeviceStatus(): DeviceStatus | undefined;
    setDeviceStatus(value?: DeviceStatus): OverlayFeatureStatus;
    clearStatusListList(): void;
    getStatusListList(): Array<OverlayFeatureMessage>;
    setStatusListList(value: Array<OverlayFeatureMessage>): OverlayFeatureStatus;
    addStatusList(value?: OverlayFeatureMessage, index?: number): OverlayFeatureMessage;

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

export namespace OverlayFeatureStatus {
    export type AsObject = {
        deviceStatus?: DeviceStatus.AsObject,
        statusListList: Array<OverlayFeatureMessage.AsObject>,
    }
}

export class Setting extends jspb.Message { 
    getSettingType(): SettingType;
    setSettingType(value: SettingType): Setting;
    getSettingCtrl(): SettingCtrl;
    setSettingCtrl(value: SettingCtrl): Setting;

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

export namespace Setting {
    export type AsObject = {
        settingType: SettingType,
        settingCtrl: SettingCtrl,
    }
}

export class TestCommandMessage extends jspb.Message { 
    getTestCommand(): TestCommand;
    setTestCommand(value: TestCommand): TestCommandMessage;

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

export namespace TestCommandMessage {
    export type AsObject = {
        testCommand: TestCommand,
    }
}

export class Camera extends jspb.Message { 
    getIpaddress(): string;
    setIpaddress(value: string): Camera;
    getSerial(): string;
    setSerial(value: string): Camera;

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

export namespace Camera {
    export type AsObject = {
        ipaddress: string,
        serial: string,
    }
}

export class DirectorSetting extends jspb.Message { 
    getKey(): DirectorSettingType;
    setKey(value: DirectorSettingType): DirectorSetting;
    getValue(): string;
    setValue(value: string): DirectorSetting;

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

export namespace DirectorSetting {
    export type AsObject = {
        key: DirectorSettingType,
        value: string,
    }
}

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

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

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

export class ConnectedCameraStatusList extends jspb.Message { 
    clearCamerasList(): void;
    getCamerasList(): Array<ConnectedCameraStatus>;
    setCamerasList(value: Array<ConnectedCameraStatus>): ConnectedCameraStatusList;
    addCameras(value?: ConnectedCameraStatus, index?: number): ConnectedCameraStatus;

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

export namespace ConnectedCameraStatusList {
    export type AsObject = {
        camerasList: Array<ConnectedCameraStatus.AsObject>,
    }
}

export class Blend extends jspb.Message { 
    getFirst(): string;
    setFirst(value: string): Blend;
    getSecond(): string;
    setSecond(value: string): Blend;
    getHow(): string;
    setHow(value: string): Blend;

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

export namespace Blend {
    export type AsObject = {
        first: string,
        second: string,
        how: string,
    }
}

export class ConnectedCameraStatus extends jspb.Message { 
    getSerial(): string;
    setSerial(value: string): ConnectedCameraStatus;
    getLastSeenTimestamp(): number;
    setLastSeenTimestamp(value: number): ConnectedCameraStatus;
    getDirectorStatus(): DirectorStatus;
    setDirectorStatus(value: DirectorStatus): ConnectedCameraStatus;
    getAvailability(): Availability;
    setAvailability(value: Availability): ConnectedCameraStatus;

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

export namespace ConnectedCameraStatus {
    export type AsObject = {
        serial: string,
        lastSeenTimestamp: number,
        directorStatus: DirectorStatus,
        availability: Availability,
    }
}

export class DirectorState extends jspb.Message { 
    getSuspended(): boolean;
    setSuspended(value: boolean): DirectorState;

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

export namespace DirectorState {
    export type AsObject = {
        suspended: boolean,
    }
}

export class DirectorMode extends jspb.Message { 
    getMode(): string;
    setMode(value: string): DirectorMode;

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

export namespace DirectorMode {
    export type AsObject = {
        mode: string,
    }
}

export class DirectorModes extends jspb.Message { 
    clearModesList(): void;
    getModesList(): Array<DirectorMode>;
    setModesList(value: Array<DirectorMode>): DirectorModes;
    addModes(value?: DirectorMode, index?: number): DirectorMode;

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

export namespace DirectorModes {
    export type AsObject = {
        modesList: Array<DirectorMode.AsObject>,
    }
}

export class CameraList extends jspb.Message { 
    clearCamerasList(): void;
    getCamerasList(): Array<Camera>;
    setCamerasList(value: Array<Camera>): CameraList;
    addCameras(value?: Camera, index?: number): Camera;

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

export namespace CameraList {
    export type AsObject = {
        camerasList: Array<Camera.AsObject>,
    }
}

export class SpeakerStatus extends jspb.Message { 
    getSampleRate(): number;
    setSampleRate(value: number): SpeakerStatus;
    getPeakLevel(): Uint8Array | string;
    getPeakLevel_asU8(): Uint8Array;
    getPeakLevel_asB64(): string;
    setPeakLevel(value: Uint8Array | string): SpeakerStatus;

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

export namespace SpeakerStatus {
    export type AsObject = {
        sampleRate: number,
        peakLevel: Uint8Array | string,
    }
}

export class GetFeatures extends jspb.Message { 
    clearGetfeaturesList(): void;
    getGetfeaturesList(): Array<GetFeatures.getFeature>;
    setGetfeaturesList(value: Array<GetFeatures.getFeature>): GetFeatures;
    addGetfeatures(value?: GetFeatures.getFeature, index?: number): GetFeatures.getFeature;

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

export namespace GetFeatures {
    export type AsObject = {
        getfeaturesList: Array<GetFeatures.getFeature.AsObject>,
    }


    export class getFeature extends jspb.Message { 
        getFeature(): Feature;
        setFeature(value: Feature): getFeature;
        getEnabled(): boolean;
        setEnabled(value: boolean): getFeature;
        getSupported(): boolean;
        setSupported(value: boolean): getFeature;

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

    export namespace getFeature {
        export type AsObject = {
            feature: Feature,
            enabled: boolean,
            supported: boolean,
        }
    }

}

export class ExposureValues extends jspb.Message { 
    getLinEv(): number;
    setLinEv(value: number): ExposureValues;
    getIntegrationTimeMs(): number;
    setIntegrationTimeMs(value: number): ExposureValues;
    getGain(): number;
    setGain(value: number): ExposureValues;
    getUseExternalExposure(): boolean;
    setUseExternalExposure(value: boolean): ExposureValues;
    getMinLinEv(): number;
    setMinLinEv(value: number): ExposureValues;
    getMaxLinEv(): number;
    setMaxLinEv(value: number): ExposureValues;
    getIsMedianCamera(): boolean;
    setIsMedianCamera(value: boolean): ExposureValues;

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

export namespace ExposureValues {
    export type AsObject = {
        linEv: number,
        integrationTimeMs: number,
        gain: number,
        useExternalExposure: boolean,
        minLinEv: number,
        maxLinEv: number,
        isMedianCamera: boolean,
    }
}

export class SetCommandRequest extends jspb.Message { 

    hasGuid(): boolean;
    clearGuid(): void;
    getGuid(): Uint8Array | string;
    getGuid_asU8(): Uint8Array;
    getGuid_asB64(): string;
    setGuid(value: Uint8Array | string): SetCommandRequest;

    hasControl(): boolean;
    clearControl(): void;
    getControl(): number | undefined;
    setControl(value: number): SetCommandRequest;

    hasPayload(): boolean;
    clearPayload(): void;
    getPayload(): Uint8Array | string;
    getPayload_asU8(): Uint8Array;
    getPayload_asB64(): string;
    setPayload(value: Uint8Array | string): SetCommandRequest;

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

export namespace SetCommandRequest {
    export type AsObject = {
        guid: Uint8Array | string,
        control?: number,
        payload: Uint8Array | string,
    }
}

export class SetCommandResponse extends jspb.Message { 

    hasStatusCode(): boolean;
    clearStatusCode(): void;
    getStatusCode(): StatusCode | undefined;
    setStatusCode(value: StatusCode): SetCommandResponse;

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

export namespace SetCommandResponse {
    export type AsObject = {
        statusCode?: StatusCode,
    }
}

export class GetCommandRequest extends jspb.Message { 

    hasGuid(): boolean;
    clearGuid(): void;
    getGuid(): Uint8Array | string;
    getGuid_asU8(): Uint8Array;
    getGuid_asB64(): string;
    setGuid(value: Uint8Array | string): GetCommandRequest;

    hasControl(): boolean;
    clearControl(): void;
    getControl(): number | undefined;
    setControl(value: number): GetCommandRequest;

    hasFunction(): boolean;
    clearFunction(): void;
    getFunction(): GetCommandRequest.GetFunction | undefined;
    setFunction(value: GetCommandRequest.GetFunction): GetCommandRequest;

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

export namespace GetCommandRequest {
    export type AsObject = {
        guid: Uint8Array | string,
        control?: number,
        pb_function?: GetCommandRequest.GetFunction,
    }

    export enum GetFunction {
    UNKNOWN = 0,
    CUR = 1,
    MIN = 2,
    MAX = 3,
    DEF = 4,
    RES = 5,
    LEN = 6,
    INFO = 7,
    }

}

export class GetCommandResponse extends jspb.Message { 

    hasStatusCode(): boolean;
    clearStatusCode(): void;
    getStatusCode(): StatusCode | undefined;
    setStatusCode(value: StatusCode): GetCommandResponse;

    hasPayload(): boolean;
    clearPayload(): void;
    getPayload(): Uint8Array | string;
    getPayload_asU8(): Uint8Array;
    getPayload_asB64(): string;
    setPayload(value: Uint8Array | string): GetCommandResponse;

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

export namespace GetCommandResponse {
    export type AsObject = {
        statusCode?: StatusCode,
        payload: Uint8Array | string,
    }
}

export class MjpegRateSettings extends jspb.Message { 
    getKbitrate(): number;
    setKbitrate(value: number): MjpegRateSettings;

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

export namespace MjpegRateSettings {
    export type AsObject = {
        kbitrate: number,
    }
}

export class Orientation extends jspb.Message { 
    getDirection(): Direction;
    setDirection(value: Direction): Orientation;

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

export namespace Orientation {
    export type AsObject = {
        direction: Direction,
    }
}

export class FeatureConfigRequest extends jspb.Message { 
    getFeature(): Feature;
    setFeature(value: Feature): FeatureConfigRequest;

    hasFramerConfig(): boolean;
    clearFramerConfig(): void;
    getFramerConfig(): FramerConfig | undefined;
    setFramerConfig(value?: FramerConfig): FeatureConfigRequest;

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

export namespace FeatureConfigRequest {
    export type AsObject = {
        feature: Feature,
        framerConfig?: FramerConfig.AsObject,
    }
}

export class FramerConfig extends jspb.Message { 
    getImageWidth(): number;
    setImageWidth(value: number): FramerConfig;
    getImageHeight(): number;
    setImageHeight(value: number): FramerConfig;
    getMinFrameChangeTime(): number;
    setMinFrameChangeTime(value: number): FramerConfig;
    getMinFrameDelta(): number;
    setMinFrameDelta(value: number): FramerConfig;
    getFrameAvgLimit(): number;
    setFrameAvgLimit(value: number): FramerConfig;
    getNoPredictionLimit(): number;
    setNoPredictionLimit(value: number): FramerConfig;
    getVarianceThreshold(): number;
    setVarianceThreshold(value: number): FramerConfig;
    getMaxZoom(): number;
    setMaxZoom(value: number): FramerConfig;
    getPersonMaxZoom(): number;
    setPersonMaxZoom(value: number): FramerConfig;
    getMaxSpeedThreshold(): number;
    setMaxSpeedThreshold(value: number): FramerConfig;
    getHeadScaleFactor(): number;
    setHeadScaleFactor(value: number): FramerConfig;
    getPersonHeadScaleFactor(): number;
    setPersonHeadScaleFactor(value: number): FramerConfig;
    getHistoryMode(): string;
    setHistoryMode(value: string): FramerConfig;
    getWidthScale(): number;
    setWidthScale(value: number): FramerConfig;
    getHeightScale(): number;
    setHeightScale(value: number): FramerConfig;
    getPersonWidthScale(): number;
    setPersonWidthScale(value: number): FramerConfig;
    getPersonHeightScale(): number;
    setPersonHeightScale(value: number): FramerConfig;

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

export namespace FramerConfig {
    export type AsObject = {
        imageWidth: number,
        imageHeight: number,
        minFrameChangeTime: number,
        minFrameDelta: number,
        frameAvgLimit: number,
        noPredictionLimit: number,
        varianceThreshold: number,
        maxZoom: number,
        personMaxZoom: number,
        maxSpeedThreshold: number,
        headScaleFactor: number,
        personHeadScaleFactor: number,
        historyMode: string,
        widthScale: number,
        heightScale: number,
        personWidthScale: number,
        personHeightScale: number,
    }
}

export class PlazaConfig extends jspb.Message { 
    getInitHitStreak(): number;
    setInitHitStreak(value: number): PlazaConfig;
    getStateChangeTimeThreshold(): number;
    setStateChangeTimeThreshold(value: number): PlazaConfig;
    getStateChangeThreshold(): number;
    setStateChangeThreshold(value: number): PlazaConfig;
    getMajorChangesThreshold(): number;
    setMajorChangesThreshold(value: number): PlazaConfig;

    hasClusterConfig(): boolean;
    clearClusterConfig(): void;
    getClusterConfig(): ClusterConfig | undefined;
    setClusterConfig(value?: ClusterConfig): PlazaConfig;

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

export namespace PlazaConfig {
    export type AsObject = {
        initHitStreak: number,
        stateChangeTimeThreshold: number,
        stateChangeThreshold: number,
        majorChangesThreshold: number,
        clusterConfig?: ClusterConfig.AsObject,
    }
}

export class ClusterConfig extends jspb.Message { 
    getSplitThresholdHigh(): number;
    setSplitThresholdHigh(value: number): ClusterConfig;
    getSplitThresholdLow(): number;
    setSplitThresholdLow(value: number): ClusterConfig;
    getStopThreshold(): number;
    setStopThreshold(value: number): ClusterConfig;

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

export namespace ClusterConfig {
    export type AsObject = {
        splitThresholdHigh: number,
        splitThresholdLow: number,
        stopThreshold: number,
    }
}

export class FocusArea extends jspb.Message { 
    getLeft(): number;
    setLeft(value: number): FocusArea;
    getRight(): number;
    setRight(value: number): FocusArea;
    getDepth(): number;
    setDepth(value: number): FocusArea;

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

export namespace FocusArea {
    export type AsObject = {
        left: number,
        right: number,
        depth: number,
    }
}

export class PersonCoords extends jspb.Message { 
    getId(): number;
    setId(value: number): PersonCoords;
    getX(): number;
    setX(value: number): PersonCoords;
    getY(): number;
    setY(value: number): PersonCoords;
    getIsInside(): boolean;
    setIsInside(value: boolean): PersonCoords;

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

export namespace PersonCoords {
    export type AsObject = {
        id: number,
        x: number,
        y: number,
        isInside: boolean,
    }
}

export class FocusAreaPersonListReply extends jspb.Message { 
    clearPersonCoordsList(): void;
    getPersonCoordsList(): Array<PersonCoords>;
    setPersonCoordsList(value: Array<PersonCoords>): FocusAreaPersonListReply;
    addPersonCoords(value?: PersonCoords, index?: number): PersonCoords;

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

export namespace FocusAreaPersonListReply {
    export type AsObject = {
        personCoordsList: Array<PersonCoords.AsObject>,
    }
}

export enum VerificationFormat {
    UNDEFINED = 0,
    MD5SUM = 1,
}

export enum VideoType {
    MAIN = 0,
    PREVIEW = 1,
    MAINVIEW = 2,
}

export enum VersionState {
    UNKNOWNVERSIONSTATE = 0,
    VERIFIED = 1,
    UNVERIFIED = 2,
    RECOVERY = 3,
}

export enum LEDState {
    PASSIVE = 0,
    ACTIVE = 1,
    HELLO = 2,
    ERROR = 3,
    UNUSED = 4,
}

export enum StatusCode {
    UNKNOWN = 0,
    OK = 1,
    FAILED = 2,
}

export enum Slot {
    A = 0,
    B = 1,
    C = 2,
    UNKNOWNSLOT = 3,
}

export enum IPAssignmentPolicy {
    UNCHANGED = 0,
    DHCP = 1,
    STATIC = 2,
}

export enum LogFiles {
    APP = 0,
    MYRIAD = 1,
    DMESG = 2,
    MEMORY = 3,
}

export enum Mode {
    START = 0,
    STOP = 1,
}

export enum Feature {
    FACEBASEDEXPOSURE = 0,
    AUTOZOOM = 1,
    DETECTOR = 2,
    SPEAKERFRAMING = 3,
    DIRECTOR = 4,
    MANUALFRAMING = 5,
    PEOPLECOUNT = 6,
    PEOPLECOUNTALWAYSON = 7,
    GALLERYVIEW = 8,
    NONE = 9,
    FOCUSMODE = 10,
    PERSPECTIVECORRECTION = 11,
}

export enum PerspectiveCorrectionType {
    UNKNOWNPERSPECTIVECORRECTIONTYPE = 0,
    NOCORRECTION = 1,
    AUTOTILTCORRECTION = 2,
    AUTOFRAMINGCORRECTION = 3,
    AUTOTILTANDFRAMINGCORRECTION = 4,
}

export enum OverlayFeature {
    UNKNOWNOVERLAYFEATURE = 0,
    ANGLEGRID = 1,
    DOA = 2,
}

export enum OverlayState {
    UNKNOWNOVERLAYSTATE = 0,
    DISABLED = 1,
    ENABLED = 2,
}

export enum SettingType {
    UNKNOWNSETTINGTYPE = 0,
    PERSISTENTPTZ = 1,
    IMAGEADJUSTMENTS = 2,
}

export enum SettingCtrl {
    UNKNOWNSETTINGCTRL = 0,
    SET = 1,
    CLEAR = 2,
    RESTORE = 3,
}

export enum TestCommand {
    NORMALBOOT = 0,
    FASTBOOTONCE = 1,
    FASTBOOT = 2,
}

export enum DirectorSettingType {
    UNKNOWNDIRECTORSETTINGTYPE = 0,
    CENTERCAMERA = 1,
}

export enum DirectorStatus {
    PRIMARY = 0,
    SECONDARY = 1,
    NOTCONNECTED = 2,
}

export enum Availability {
    OPERATIONAL = 0,
    DISCONNECTED = 1,
    DEGRADED = 2,
}

export enum MeetControl {
    MEET_CONTROL_UNKNOWN = 0,
    MEET_CONTROL_FRAME_STRATEGY = 1,
    MEET_CONTROL_REFRAME = 2,
    MEET_CONTROL_OCCUPANCY_COUNTING_TOGGLE = 3,
    MEET_CONTROL_OCCUPANCY_COUNTING_READ = 4,
    MEET_CONTROL_STATUS_INFO = 5,
    MEET_CONTROL_STATUS_RESET = 6,
    MEET_CONTROL_PRESETS = 7,
    MEET_CONTROL_PAN_TILT_ABSOLUTE = 8,
    MEET_CONTROL_PAN_TILT_RELATIVE = 9,
}

export enum Direction {
    NORMAL = 0,
    UPSIDEDOWN = 1,
    AUTO = 2,
}