@smart-cloud/tollingvision/dist/index.d.ts

TypeScript client for [Tolling Vision](https://tollingvision.com/).

import * as grpcWeb from 'grpc-web';
import * as jspb from 'google-protobuf';

declare class Point extends jspb.Message {
  getX(): number;
  setX(value: number): Point;

  getY(): number;
  setY(value: number): Point;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Point.AsObject;
  static toObject(includeInstance: boolean, msg: Point): Point.AsObject;
  static serializeBinaryToWriter(message: Point, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Point;
  static deserializeBinaryFromReader(message: Point, reader: jspb.BinaryReader): Point;
}

declare namespace Point {
  export type AsObject = {
    x: number,
    y: number,
  }
}

declare class Region extends jspb.Message {
  getPointList(): Array<Point>;
  setPointList(value: Array<Point>): Region;
  clearPointList(): Region;
  addPoint(value?: Point, index?: number): Point;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Region.AsObject;
  static toObject(includeInstance: boolean, msg: Region): Region.AsObject;
  static serializeBinaryToWriter(message: Region, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Region;
  static deserializeBinaryFromReader(message: Region, reader: jspb.BinaryReader): Region;
}

declare namespace Region {
  export type AsObject = {
    pointList: Array<Point.AsObject>,
  }
}

declare class Quadrilateral extends jspb.Message {
  getTopLeft(): Point | undefined;
  setTopLeft(value?: Point): Quadrilateral;
  hasTopLeft(): boolean;
  clearTopLeft(): Quadrilateral;

  getTopRight(): Point | undefined;
  setTopRight(value?: Point): Quadrilateral;
  hasTopRight(): boolean;
  clearTopRight(): Quadrilateral;

  getBottomLeft(): Point | undefined;
  setBottomLeft(value?: Point): Quadrilateral;
  hasBottomLeft(): boolean;
  clearBottomLeft(): Quadrilateral;

  getBottomRight(): Point | undefined;
  setBottomRight(value?: Point): Quadrilateral;
  hasBottomRight(): boolean;
  clearBottomRight(): Quadrilateral;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Quadrilateral.AsObject;
  static toObject(includeInstance: boolean, msg: Quadrilateral): Quadrilateral.AsObject;
  static serializeBinaryToWriter(message: Quadrilateral, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Quadrilateral;
  static deserializeBinaryFromReader(message: Quadrilateral, reader: jspb.BinaryReader): Quadrilateral;
}

declare namespace Quadrilateral {
  export type AsObject = {
    topLeft?: Point.AsObject,
    topRight?: Point.AsObject,
    bottomLeft?: Point.AsObject,
    bottomRight?: Point.AsObject,
  }
}

declare class Color extends jspb.Message {
  getRed(): number;
  setRed(value: number): Color;

  getGreen(): number;
  setGreen(value: number): Color;

  getBlue(): number;
  setBlue(value: number): Color;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Color.AsObject;
  static toObject(includeInstance: boolean, msg: Color): Color.AsObject;
  static serializeBinaryToWriter(message: Color, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Color;
  static deserializeBinaryFromReader(message: Color, reader: jspb.BinaryReader): Color;
}

declare namespace Color {
  export type AsObject = {
    red: number,
    green: number,
    blue: number,
  }
}

declare class PlateChar extends jspb.Message {
  getCode(): number;
  setCode(value: number): PlateChar;

  getConfidence(): number;
  setConfidence(value: number): PlateChar;

  getPosition(): Quadrilateral | undefined;
  setPosition(value?: Quadrilateral): PlateChar;
  hasPosition(): boolean;
  clearPosition(): PlateChar;

  getColor(): Color | undefined;
  setColor(value?: Color): PlateChar;
  hasColor(): boolean;
  clearColor(): PlateChar;

  getBackgroundColor(): Color | undefined;
  setBackgroundColor(value?: Color): PlateChar;
  hasBackgroundColor(): boolean;
  clearBackgroundColor(): PlateChar;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): PlateChar.AsObject;
  static toObject(includeInstance: boolean, msg: PlateChar): PlateChar.AsObject;
  static serializeBinaryToWriter(message: PlateChar, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): PlateChar;
  static deserializeBinaryFromReader(message: PlateChar, reader: jspb.BinaryReader): PlateChar;
}

declare namespace PlateChar {
  export type AsObject = {
    code: number,
    confidence: number,
    position?: Quadrilateral.AsObject,
    color?: Color.AsObject,
    backgroundColor?: Color.AsObject,
  }
}

declare class Dimensions extends jspb.Message {
  getWidth(): number;
  setWidth(value: number): Dimensions;

  getHeight(): number;
  setHeight(value: number): Dimensions;

  getLength(): number;
  setLength(value: number): Dimensions;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Dimensions.AsObject;
  static toObject(includeInstance: boolean, msg: Dimensions): Dimensions.AsObject;
  static serializeBinaryToWriter(message: Dimensions, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Dimensions;
  static deserializeBinaryFromReader(message: Dimensions, reader: jspb.BinaryReader): Dimensions;
}

declare namespace Dimensions {
  export type AsObject = {
    width: number,
    height: number,
    length: number,
  }
}

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

  getName(): string;
  setName(value: string): Image;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Image.AsObject;
  static toObject(includeInstance: boolean, msg: Image): Image.AsObject;
  static serializeBinaryToWriter(message: Image, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Image;
  static deserializeBinaryFromReader(message: Image, reader: jspb.BinaryReader): Image;
}

declare namespace Image {
  export type AsObject = {
    data: Uint8Array | string,
    name: string,
  }
}

declare class Plate extends jspb.Message {
  getText(): string;
  setText(value: string): Plate;

  getCountry(): string;
  setCountry(value: string): Plate;

  getState(): string;
  setState(value: string): Plate;

  getCategory(): string;
  setCategory(value: string): Plate;

  getConfidence(): number;
  setConfidence(value: number): Plate;

  getPosition(): Quadrilateral | undefined;
  setPosition(value?: Quadrilateral): Plate;
  hasPosition(): boolean;
  clearPosition(): Plate;

  getWidth(): number;
  setWidth(value: number): Plate;

  getHeight(): number;
  setHeight(value: number): Plate;

  getProcessingTime(): number;
  setProcessingTime(value: number): Plate;

  getSeparatedText(): string;
  setSeparatedText(value: string): Plate;

  getPlateTypeConfidence(): number;
  setPlateTypeConfidence(value: number): Plate;

  getTextConfidence(): number;
  setTextConfidence(value: number): Plate;

  getCharacterList(): Array<PlateChar>;
  setCharacterList(value: Array<PlateChar>): Plate;
  clearCharacterList(): Plate;
  addCharacter(value?: PlateChar, index?: number): PlateChar;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Plate.AsObject;
  static toObject(includeInstance: boolean, msg: Plate): Plate.AsObject;
  static serializeBinaryToWriter(message: Plate, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Plate;
  static deserializeBinaryFromReader(message: Plate, reader: jspb.BinaryReader): Plate;
}

declare namespace Plate {
  export type AsObject = {
    text: string,
    country: string,
    state: string,
    category: string,
    confidence: number,
    position?: Quadrilateral.AsObject,
    width: number,
    height: number,
    processingTime: number,
    separatedText: string,
    plateTypeConfidence: number,
    textConfidence: number,
    characterList: Array<PlateChar.AsObject>,
  }
}

declare class Mmr extends jspb.Message {
  getMake(): string;
  setMake(value: string): Mmr;

  getModel(): string;
  setModel(value: string): Mmr;

  getGeneration(): string;
  setGeneration(value: string): Mmr;

  getColor(): Color | undefined;
  setColor(value?: Color): Mmr;
  hasColor(): boolean;
  clearColor(): Mmr;

  getColorName(): string;
  setColorName(value: string): Mmr;

  getStandardColorName(): string;
  setStandardColorName(value: string): Mmr;

  getCategory(): string;
  setCategory(value: string): Mmr;

  getBodyType(): string;
  setBodyType(value: string): Mmr;

  getViewPoint(): string;
  setViewPoint(value: string): Mmr;

  getMakeConfidence(): number;
  setMakeConfidence(value: number): Mmr;

  getModelConfidence(): number;
  setModelConfidence(value: number): Mmr;

  getGenerationConfidence(): number;
  setGenerationConfidence(value: number): Mmr;

  getColorConfidence(): number;
  setColorConfidence(value: number): Mmr;

  getCategoryConfidence(): number;
  setCategoryConfidence(value: number): Mmr;

  getBodyTypeConfidence(): number;
  setBodyTypeConfidence(value: number): Mmr;

  getViewPointConfidence(): number;
  setViewPointConfidence(value: number): Mmr;

  getProcessingTime(): number;
  setProcessingTime(value: number): Mmr;

  getDimensions(): Dimensions | undefined;
  setDimensions(value?: Dimensions): Mmr;
  hasDimensions(): boolean;
  clearDimensions(): Mmr;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Mmr.AsObject;
  static toObject(includeInstance: boolean, msg: Mmr): Mmr.AsObject;
  static serializeBinaryToWriter(message: Mmr, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Mmr;
  static deserializeBinaryFromReader(message: Mmr, reader: jspb.BinaryReader): Mmr;
}

declare namespace Mmr {
  export type AsObject = {
    make: string,
    model: string,
    generation: string,
    color?: Color.AsObject,
    colorName: string,
    standardColorName: string,
    category: string,
    bodyType: string,
    viewPoint: string,
    makeConfidence: number,
    modelConfidence: number,
    generationConfidence: number,
    colorConfidence: number,
    categoryConfidence: number,
    bodyTypeConfidence: number,
    viewPointConfidence: number,
    processingTime: number,
    dimensions?: Dimensions.AsObject,
  }
}

declare class Sign extends jspb.Message {
  getText(): string;
  setText(value: string): Sign;

  getType(): SignType;
  setType(value: SignType): Sign;

  getConfidence(): number;
  setConfidence(value: number): Sign;

  getPosition(): Quadrilateral | undefined;
  setPosition(value?: Quadrilateral): Sign;
  hasPosition(): boolean;
  clearPosition(): Sign;

  getWidth(): number;
  setWidth(value: number): Sign;

  getHeight(): number;
  setHeight(value: number): Sign;

  getProcessingTime(): number;
  setProcessingTime(value: number): Sign;

  getCharacterList(): Array<PlateChar>;
  setCharacterList(value: Array<PlateChar>): Sign;
  clearCharacterList(): Sign;
  addCharacter(value?: PlateChar, index?: number): PlateChar;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Sign.AsObject;
  static toObject(includeInstance: boolean, msg: Sign): Sign.AsObject;
  static serializeBinaryToWriter(message: Sign, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Sign;
  static deserializeBinaryFromReader(message: Sign, reader: jspb.BinaryReader): Sign;
}

declare namespace Sign {
  export type AsObject = {
    text: string,
    type: SignType,
    confidence: number,
    position?: Quadrilateral.AsObject,
    width: number,
    height: number,
    processingTime: number,
    characterList: Array<PlateChar.AsObject>,
  }
}

declare class Vehicle extends jspb.Message {
  getPlate(): Plate | undefined;
  setPlate(value?: Plate): Vehicle;
  hasPlate(): boolean;
  clearPlate(): Vehicle;

  getAlternativeList(): Array<Plate>;
  setAlternativeList(value: Array<Plate>): Vehicle;
  clearAlternativeList(): Vehicle;
  addAlternative(value?: Plate, index?: number): Plate;

  getMmr(): Mmr | undefined;
  setMmr(value?: Mmr): Vehicle;
  hasMmr(): boolean;
  clearMmr(): Vehicle;

  getSignList(): Array<Sign>;
  setSignList(value: Array<Sign>): Vehicle;
  clearSignList(): Vehicle;
  addSign(value?: Sign, index?: number): Sign;

  getFrame(): Quadrilateral | undefined;
  setFrame(value?: Quadrilateral): Vehicle;
  hasFrame(): boolean;
  clearFrame(): Vehicle;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Vehicle.AsObject;
  static toObject(includeInstance: boolean, msg: Vehicle): Vehicle.AsObject;
  static serializeBinaryToWriter(message: Vehicle, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Vehicle;
  static deserializeBinaryFromReader(message: Vehicle, reader: jspb.BinaryReader): Vehicle;
}

declare namespace Vehicle {
  export type AsObject = {
    plate?: Plate.AsObject,
    alternativeList: Array<Plate.AsObject>,
    mmr?: Mmr.AsObject,
    signList: Array<Sign.AsObject>,
    frame?: Quadrilateral.AsObject,
  }
}

declare class KeyValuePair extends jspb.Message {
  getKey(): string;
  setKey(value: string): KeyValuePair;

  getValue(): string;
  setValue(value: string): KeyValuePair;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): KeyValuePair.AsObject;
  static toObject(includeInstance: boolean, msg: KeyValuePair): KeyValuePair.AsObject;
  static serializeBinaryToWriter(message: KeyValuePair, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): KeyValuePair;
  static deserializeBinaryFromReader(message: KeyValuePair, reader: jspb.BinaryReader): KeyValuePair;
}

declare namespace KeyValuePair {
  export type AsObject = {
    key: string,
    value: string,
  }
}

declare class LicenseService extends jspb.Message {
  getName(): string;
  setName(value: string): LicenseService;

  getAddress(): string;
  setAddress(value: string): LicenseService;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): LicenseService.AsObject;
  static toObject(includeInstance: boolean, msg: LicenseService): LicenseService.AsObject;
  static serializeBinaryToWriter(message: LicenseService, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): LicenseService;
  static deserializeBinaryFromReader(message: LicenseService, reader: jspb.BinaryReader): LicenseService;
}

declare namespace LicenseService {
  export type AsObject = {
    name: string,
    address: string,
  }
}

declare class LicenseServiceStatus extends jspb.Message {
  getService(): LicenseService | undefined;
  setService(value?: LicenseService): LicenseServiceStatus;
  hasService(): boolean;
  clearService(): LicenseServiceStatus;

  getLastError(): string;
  setLastError(value: string): LicenseServiceStatus;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): LicenseServiceStatus.AsObject;
  static toObject(includeInstance: boolean, msg: LicenseServiceStatus): LicenseServiceStatus.AsObject;
  static serializeBinaryToWriter(message: LicenseServiceStatus, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): LicenseServiceStatus;
  static deserializeBinaryFromReader(message: LicenseServiceStatus, reader: jspb.BinaryReader): LicenseServiceStatus;
}

declare namespace LicenseServiceStatus {
  export type AsObject = {
    service?: LicenseService.AsObject,
    lastError: string,
  }
}

declare class SearchRequest extends jspb.Message {
  getPlateRecognition(): boolean;
  setPlateRecognition(value: boolean): SearchRequest;
  hasPlateRecognition(): boolean;
  clearPlateRecognition(): SearchRequest;

  getMakeAndModelRecognition(): boolean;
  setMakeAndModelRecognition(value: boolean): SearchRequest;

  getSignRecognition(): boolean;
  setSignRecognition(value: boolean): SearchRequest;

  getInternationalRecognition(): boolean;
  setInternationalRecognition(value: boolean): SearchRequest;

  getResampling(): boolean;
  setResampling(value: boolean): SearchRequest;
  hasResampling(): boolean;
  clearResampling(): SearchRequest;

  getResultsWithoutPlateType(): boolean;
  setResultsWithoutPlateType(value: boolean): SearchRequest;

  getLocation(): string;
  setLocation(value: string): SearchRequest;

  getImage(): Image | undefined;
  setImage(value?: Image): SearchRequest;
  hasImage(): boolean;
  clearImage(): SearchRequest;

  getMaxSearch(): number;
  setMaxSearch(value: number): SearchRequest;

  getMaxRotation(): number;
  setMaxRotation(value: number): SearchRequest;

  getMaxCharacterSize(): number;
  setMaxCharacterSize(value: number): SearchRequest;

  getRegionList(): Array<Region>;
  setRegionList(value: Array<Region>): SearchRequest;
  clearRegionList(): SearchRequest;
  addRegion(value?: Region, index?: number): Region;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SearchRequest.AsObject;
  static toObject(includeInstance: boolean, msg: SearchRequest): SearchRequest.AsObject;
  static serializeBinaryToWriter(message: SearchRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SearchRequest;
  static deserializeBinaryFromReader(message: SearchRequest, reader: jspb.BinaryReader): SearchRequest;
}

declare namespace SearchRequest {
  export type AsObject = {
    plateRecognition?: boolean,
    makeAndModelRecognition: boolean,
    signRecognition: boolean,
    internationalRecognition: boolean,
    resampling?: boolean,
    resultsWithoutPlateType: boolean,
    location: string,
    image?: Image.AsObject,
    maxSearch: number,
    maxRotation: number,
    maxCharacterSize: number,
    regionList: Array<Region.AsObject>,
  }

  export enum PlateRecognitionCase { 
    _PLATE_RECOGNITION_NOT_SET = 0,
    PLATE_RECOGNITION = 1,
  }

  export enum ResamplingCase { 
    _RESAMPLING_NOT_SET = 0,
    RESAMPLING = 5,
  }
}

declare class EventRequest extends jspb.Message {
  getSignRecognition(): boolean;
  setSignRecognition(value: boolean): EventRequest;

  getInternationalRecognition(): boolean;
  setInternationalRecognition(value: boolean): EventRequest;

  getResampling(): boolean;
  setResampling(value: boolean): EventRequest;
  hasResampling(): boolean;
  clearResampling(): EventRequest;

  getResultsWithoutPlateType(): boolean;
  setResultsWithoutPlateType(value: boolean): EventRequest;

  getLocation(): string;
  setLocation(value: string): EventRequest;

  getFrontImageList(): Array<Image>;
  setFrontImageList(value: Array<Image>): EventRequest;
  clearFrontImageList(): EventRequest;
  addFrontImage(value?: Image, index?: number): Image;

  getRearImageList(): Array<Image>;
  setRearImageList(value: Array<Image>): EventRequest;
  clearRearImageList(): EventRequest;
  addRearImage(value?: Image, index?: number): Image;

  getOverviewImageList(): Array<Image>;
  setOverviewImageList(value: Array<Image>): EventRequest;
  clearOverviewImageList(): EventRequest;
  addOverviewImage(value?: Image, index?: number): Image;

  getMaxSearch(): number;
  setMaxSearch(value: number): EventRequest;

  getMaxRotation(): number;
  setMaxRotation(value: number): EventRequest;

  getMaxCharacterSize(): number;
  setMaxCharacterSize(value: number): EventRequest;

  getRegionList(): Array<Region>;
  setRegionList(value: Array<Region>): EventRequest;
  clearRegionList(): EventRequest;
  addRegion(value?: Region, index?: number): Region;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): EventRequest.AsObject;
  static toObject(includeInstance: boolean, msg: EventRequest): EventRequest.AsObject;
  static serializeBinaryToWriter(message: EventRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): EventRequest;
  static deserializeBinaryFromReader(message: EventRequest, reader: jspb.BinaryReader): EventRequest;
}

declare namespace EventRequest {
  export type AsObject = {
    signRecognition: boolean,
    internationalRecognition: boolean,
    resampling?: boolean,
    resultsWithoutPlateType: boolean,
    location: string,
    frontImageList: Array<Image.AsObject>,
    rearImageList: Array<Image.AsObject>,
    overviewImageList: Array<Image.AsObject>,
    maxSearch: number,
    maxRotation: number,
    maxCharacterSize: number,
    regionList: Array<Region.AsObject>,
  }

  export enum ResamplingCase { 
    _RESAMPLING_NOT_SET = 0,
    RESAMPLING = 3,
  }
}

declare class ServerStatusRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ServerStatusRequest.AsObject;
  static toObject(includeInstance: boolean, msg: ServerStatusRequest): ServerStatusRequest.AsObject;
  static serializeBinaryToWriter(message: ServerStatusRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ServerStatusRequest;
  static deserializeBinaryFromReader(message: ServerStatusRequest, reader: jspb.BinaryReader): ServerStatusRequest;
}

declare namespace ServerStatusRequest {
  export type AsObject = {
  }
}

declare class LicenseServiceStatusRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): LicenseServiceStatusRequest.AsObject;
  static toObject(includeInstance: boolean, msg: LicenseServiceStatusRequest): LicenseServiceStatusRequest.AsObject;
  static serializeBinaryToWriter(message: LicenseServiceStatusRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): LicenseServiceStatusRequest;
  static deserializeBinaryFromReader(message: LicenseServiceStatusRequest, reader: jspb.BinaryReader): LicenseServiceStatusRequest;
}

declare namespace LicenseServiceStatusRequest {
  export type AsObject = {
  }
}

declare class ErrorResponse$1 extends jspb.Message {
  getRequestId(): string;
  setRequestId(value: string): ErrorResponse$1;

  getCode(): Error;
  setCode(value: Error): ErrorResponse$1;

  getNode(): string;
  setNode(value: string): ErrorResponse$1;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ErrorResponse$1.AsObject;
  static toObject(includeInstance: boolean, msg: ErrorResponse$1): ErrorResponse$1.AsObject;
  static serializeBinaryToWriter(message: ErrorResponse$1, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ErrorResponse$1;
  static deserializeBinaryFromReader(message: ErrorResponse$1, reader: jspb.BinaryReader): ErrorResponse$1;
}

declare namespace ErrorResponse$1 {
  export type AsObject = {
    requestId: string,
    code: Error,
    node: string,
  }
}

declare class SearchResponse extends jspb.Message {
  getRequestId(): string;
  setRequestId(value: string): SearchResponse;

  getNode(): string;
  setNode(value: string): SearchResponse;

  getStatus(): Status;
  setStatus(value: Status): SearchResponse;

  getQueueingTime(): number;
  setQueueingTime(value: number): SearchResponse;

  getRecognitionTime(): number;
  setRecognitionTime(value: number): SearchResponse;

  getInputImageOrientation(): number;
  setInputImageOrientation(value: number): SearchResponse;

  getResultList(): Array<Vehicle>;
  setResultList(value: Array<Vehicle>): SearchResponse;
  clearResultList(): SearchResponse;
  addResult(value?: Vehicle, index?: number): Vehicle;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SearchResponse.AsObject;
  static toObject(includeInstance: boolean, msg: SearchResponse): SearchResponse.AsObject;
  static serializeBinaryToWriter(message: SearchResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SearchResponse;
  static deserializeBinaryFromReader(message: SearchResponse, reader: jspb.BinaryReader): SearchResponse;
}

declare namespace SearchResponse {
  export type AsObject = {
    requestId: string,
    node: string,
    status: Status,
    queueingTime: number,
    recognitionTime: number,
    inputImageOrientation: number,
    resultList: Array<Vehicle.AsObject>,
  }
}

declare class EventResult extends jspb.Message {
  getNode(): string;
  setNode(value: string): EventResult;

  getFrontPlate(): Plate | undefined;
  setFrontPlate(value?: Plate): EventResult;
  hasFrontPlate(): boolean;
  clearFrontPlate(): EventResult;

  getFrontPlateAlternativeList(): Array<Plate>;
  setFrontPlateAlternativeList(value: Array<Plate>): EventResult;
  clearFrontPlateAlternativeList(): EventResult;
  addFrontPlateAlternative(value?: Plate, index?: number): Plate;

  getRearPlate(): Plate | undefined;
  setRearPlate(value?: Plate): EventResult;
  hasRearPlate(): boolean;
  clearRearPlate(): EventResult;

  getRearPlateAlternativeList(): Array<Plate>;
  setRearPlateAlternativeList(value: Array<Plate>): EventResult;
  clearRearPlateAlternativeList(): EventResult;
  addRearPlateAlternative(value?: Plate, index?: number): Plate;

  getMmr(): Mmr | undefined;
  setMmr(value?: Mmr): EventResult;
  hasMmr(): boolean;
  clearMmr(): EventResult;

  getMmrAlternativeList(): Array<Mmr>;
  setMmrAlternativeList(value: Array<Mmr>): EventResult;
  clearMmrAlternativeList(): EventResult;
  addMmrAlternative(value?: Mmr, index?: number): Mmr;

  getSignList(): Array<Sign>;
  setSignList(value: Array<Sign>): EventResult;
  clearSignList(): EventResult;
  addSign(value?: Sign, index?: number): Sign;

  getProcessingTime(): number;
  setProcessingTime(value: number): EventResult;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): EventResult.AsObject;
  static toObject(includeInstance: boolean, msg: EventResult): EventResult.AsObject;
  static serializeBinaryToWriter(message: EventResult, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): EventResult;
  static deserializeBinaryFromReader(message: EventResult, reader: jspb.BinaryReader): EventResult;
}

declare namespace EventResult {
  export type AsObject = {
    node: string,
    frontPlate?: Plate.AsObject,
    frontPlateAlternativeList: Array<Plate.AsObject>,
    rearPlate?: Plate.AsObject,
    rearPlateAlternativeList: Array<Plate.AsObject>,
    mmr?: Mmr.AsObject,
    mmrAlternativeList: Array<Mmr.AsObject>,
    signList: Array<Sign.AsObject>,
    processingTime: number,
  }
}

declare class PartialResult extends jspb.Message {
  getResultType(): ResultType;
  setResultType(value: ResultType): PartialResult;

  getResultIndex(): number;
  setResultIndex(value: number): PartialResult;

  getError(): ErrorResponse$1 | undefined;
  setError(value?: ErrorResponse$1): PartialResult;
  hasError(): boolean;
  clearError(): PartialResult;

  getResult(): SearchResponse | undefined;
  setResult(value?: SearchResponse): PartialResult;
  hasResult(): boolean;
  clearResult(): PartialResult;

  getResponseCase(): PartialResult.ResponseCase;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): PartialResult.AsObject;
  static toObject(includeInstance: boolean, msg: PartialResult): PartialResult.AsObject;
  static serializeBinaryToWriter(message: PartialResult, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): PartialResult;
  static deserializeBinaryFromReader(message: PartialResult, reader: jspb.BinaryReader): PartialResult;
}

declare namespace PartialResult {
  export type AsObject = {
    resultType: ResultType,
    resultIndex: number,
    error?: ErrorResponse$1.AsObject,
    result?: SearchResponse.AsObject,
  }

  export enum ResponseCase { 
    RESPONSE_NOT_SET = 0,
    ERROR = 3,
    RESULT = 4,
  }
}

declare class EventResponse extends jspb.Message {
  getEventId(): string;
  setEventId(value: string): EventResponse;

  getNode(): string;
  setNode(value: string): EventResponse;

  getPartialResult(): PartialResult | undefined;
  setPartialResult(value?: PartialResult): EventResponse;
  hasPartialResult(): boolean;
  clearPartialResult(): EventResponse;

  getEventResult(): EventResult | undefined;
  setEventResult(value?: EventResult): EventResponse;
  hasEventResult(): boolean;
  clearEventResult(): EventResponse;

  getResponseCase(): EventResponse.ResponseCase;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): EventResponse.AsObject;
  static toObject(includeInstance: boolean, msg: EventResponse): EventResponse.AsObject;
  static serializeBinaryToWriter(message: EventResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): EventResponse;
  static deserializeBinaryFromReader(message: EventResponse, reader: jspb.BinaryReader): EventResponse;
}

declare namespace EventResponse {
  export type AsObject = {
    eventId: string,
    node: string,
    partialResult?: PartialResult.AsObject,
    eventResult?: EventResult.AsObject,
  }

  export enum ResponseCase { 
    RESPONSE_NOT_SET = 0,
    PARTIAL_RESULT = 3,
    EVENT_RESULT = 4,
  }
}

declare class ServerStatusResponse extends jspb.Message {
  getNode(): string;
  setNode(value: string): ServerStatusResponse;

  getEntryList(): Array<KeyValuePair>;
  setEntryList(value: Array<KeyValuePair>): ServerStatusResponse;
  clearEntryList(): ServerStatusResponse;
  addEntry(value?: KeyValuePair, index?: number): KeyValuePair;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ServerStatusResponse.AsObject;
  static toObject(includeInstance: boolean, msg: ServerStatusResponse): ServerStatusResponse.AsObject;
  static serializeBinaryToWriter(message: ServerStatusResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ServerStatusResponse;
  static deserializeBinaryFromReader(message: ServerStatusResponse, reader: jspb.BinaryReader): ServerStatusResponse;
}

declare namespace ServerStatusResponse {
  export type AsObject = {
    node: string,
    entryList: Array<KeyValuePair.AsObject>,
  }
}

declare class LicenseServiceStatusResponse extends jspb.Message {
  getNode(): string;
  setNode(value: string): LicenseServiceStatusResponse;

  getStatusList(): Array<LicenseServiceStatus>;
  setStatusList(value: Array<LicenseServiceStatus>): LicenseServiceStatusResponse;
  clearStatusList(): LicenseServiceStatusResponse;
  addStatus(value?: LicenseServiceStatus, index?: number): LicenseServiceStatus;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): LicenseServiceStatusResponse.AsObject;
  static toObject(includeInstance: boolean, msg: LicenseServiceStatusResponse): LicenseServiceStatusResponse.AsObject;
  static serializeBinaryToWriter(message: LicenseServiceStatusResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): LicenseServiceStatusResponse;
  static deserializeBinaryFromReader(message: LicenseServiceStatusResponse, reader: jspb.BinaryReader): LicenseServiceStatusResponse;
}

declare namespace LicenseServiceStatusResponse {
  export type AsObject = {
    node: string,
    statusList: Array<LicenseServiceStatus.AsObject>,
  }
}

declare enum Status { 
  QUEUEING = 0,
  PROCESSING = 1,
  RESULT = 2,
}
declare enum ResultType { 
  FRONT = 0,
  REAR = 1,
  OVERVIEW = 2,
}
declare enum Error { 
  EMPTY_IMAGE = 0,
  INVALID_IMAGE_FORMAT = 1,
  INVALID_MAX_SEARCH = 2,
  INVALID_MAX_ROTATION = 3,
  INVALID_MAX_CHARACTER_SIZE = 4,
  TOO_MANY_REQUESTS = 5,
  TIMEOUT_OCCURRED = 6,
  INTERNAL_ERROR = 7,
  FORBIDDEN = 8,
  LIMIT_EXCEEDED = 9,
}
declare enum SignType { 
  GENERAL = 0,
  IMO = 1,
  A = 2,
  EMPTY = 3,
}

/**
 * @fileoverview gRPC-Web generated client stub for com.smartcloudsolutions.tollingvision
 * @enhanceable
 * @public
 */

declare class TollingVisionServiceClient {
    client_: grpcWeb.AbstractClientBase;
    hostname_: string;
    credentials_: null | {
        [index: string]: string;
    };
    options_: null | {
        [index: string]: any;
    };
    constructor(hostname: string, credentials?: null | {
        [index: string]: string;
    }, options?: null | {
        [index: string]: any;
    });
    methodDescriptorsearch: any;
    search(request: SearchRequest, metadata?: grpcWeb.Metadata): grpcWeb.ClientReadableStream<SearchResponse>;
    methodDescriptoranalyze: any;
    analyze(request: EventRequest, metadata?: grpcWeb.Metadata): grpcWeb.ClientReadableStream<EventResponse>;
    methodDescriptorstatus: any;
    status(request: ServerStatusRequest, metadata?: grpcWeb.Metadata | null): Promise<ServerStatusResponse>;
    status(request: ServerStatusRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: ServerStatusResponse) => void): grpcWeb.ClientReadableStream<ServerStatusResponse>;
    methodDescriptorwatch: any;
    watch(request: LicenseServiceStatusRequest, metadata?: grpcWeb.Metadata): grpcWeb.ClientReadableStream<LicenseServiceStatusResponse>;
}

declare class HealthCheckRequest extends jspb.Message {
  getService(): string;
  setService(value: string): HealthCheckRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): HealthCheckRequest.AsObject;
  static toObject(includeInstance: boolean, msg: HealthCheckRequest): HealthCheckRequest.AsObject;
  static serializeBinaryToWriter(message: HealthCheckRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): HealthCheckRequest;
  static deserializeBinaryFromReader(message: HealthCheckRequest, reader: jspb.BinaryReader): HealthCheckRequest;
}

declare namespace HealthCheckRequest {
  export type AsObject = {
    service: string,
  }
}

declare class HealthCheckResponse extends jspb.Message {
  getStatus(): HealthCheckResponse.ServingStatus;
  setStatus(value: HealthCheckResponse.ServingStatus): HealthCheckResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): HealthCheckResponse.AsObject;
  static toObject(includeInstance: boolean, msg: HealthCheckResponse): HealthCheckResponse.AsObject;
  static serializeBinaryToWriter(message: HealthCheckResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): HealthCheckResponse;
  static deserializeBinaryFromReader(message: HealthCheckResponse, reader: jspb.BinaryReader): HealthCheckResponse;
}

declare namespace HealthCheckResponse {
  export type AsObject = {
    status: HealthCheckResponse.ServingStatus,
  }

  export enum ServingStatus { 
    UNKNOWN = 0,
    SERVING = 1,
    NOT_SERVING = 2,
    SERVICE_UNKNOWN = 3,
  }
}

/**
 * @fileoverview gRPC-Web generated client stub for grpc.health.v1
 * @enhanceable
 * @public
 */

declare class HealthClient {
    client_: grpcWeb.AbstractClientBase;
    hostname_: string;
    credentials_: null | {
        [index: string]: string;
    };
    options_: null | {
        [index: string]: any;
    };
    constructor(hostname: string, credentials?: null | {
        [index: string]: string;
    }, options?: null | {
        [index: string]: any;
    });
    methodDescriptorCheck: any;
    check(request: HealthCheckRequest, metadata?: grpcWeb.Metadata | null): Promise<HealthCheckResponse>;
    check(request: HealthCheckRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: HealthCheckResponse) => void): grpcWeb.ClientReadableStream<HealthCheckResponse>;
    methodDescriptorWatch: any;
    watch(request: HealthCheckRequest, metadata?: grpcWeb.Metadata): grpcWeb.ClientReadableStream<HealthCheckResponse>;
}

/**
 * @fileoverview gRPC-Web generated client stub for grpc.reflection.v1
 * @enhanceable
 * @public
 */

declare class ServerReflectionClient {
    client_: grpcWeb.AbstractClientBase;
    hostname_: string;
    credentials_: null | {
        [index: string]: string;
    };
    options_: null | {
        [index: string]: any;
    };
    constructor(hostname: string, credentials?: null | {
        [index: string]: string;
    }, options?: null | {
        [index: string]: any;
    });
}

declare class ServerReflectionRequest extends jspb.Message {
  getHost(): string;
  setHost(value: string): ServerReflectionRequest;

  getFileByFilename(): string;
  setFileByFilename(value: string): ServerReflectionRequest;

  getFileContainingSymbol(): string;
  setFileContainingSymbol(value: string): ServerReflectionRequest;

  getFileContainingExtension(): ExtensionRequest | undefined;
  setFileContainingExtension(value?: ExtensionRequest): ServerReflectionRequest;
  hasFileContainingExtension(): boolean;
  clearFileContainingExtension(): ServerReflectionRequest;

  getAllExtensionNumbersOfType(): string;
  setAllExtensionNumbersOfType(value: string): ServerReflectionRequest;

  getListServices(): string;
  setListServices(value: string): ServerReflectionRequest;

  getMessageRequestCase(): ServerReflectionRequest.MessageRequestCase;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ServerReflectionRequest.AsObject;
  static toObject(includeInstance: boolean, msg: ServerReflectionRequest): ServerReflectionRequest.AsObject;
  static serializeBinaryToWriter(message: ServerReflectionRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ServerReflectionRequest;
  static deserializeBinaryFromReader(message: ServerReflectionRequest, reader: jspb.BinaryReader): ServerReflectionRequest;
}

declare namespace ServerReflectionRequest {
  export type AsObject = {
    host: string,
    fileByFilename: string,
    fileContainingSymbol: string,
    fileContainingExtension?: ExtensionRequest.AsObject,
    allExtensionNumbersOfType: string,
    listServices: string,
  }

  export enum MessageRequestCase { 
    MESSAGE_REQUEST_NOT_SET = 0,
    FILE_BY_FILENAME = 3,
    FILE_CONTAINING_SYMBOL = 4,
    FILE_CONTAINING_EXTENSION = 5,
    ALL_EXTENSION_NUMBERS_OF_TYPE = 6,
    LIST_SERVICES = 7,
  }
}

declare class ExtensionRequest extends jspb.Message {
  getContainingType(): string;
  setContainingType(value: string): ExtensionRequest;

  getExtensionNumber(): number;
  setExtensionNumber(value: number): ExtensionRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ExtensionRequest.AsObject;
  static toObject(includeInstance: boolean, msg: ExtensionRequest): ExtensionRequest.AsObject;
  static serializeBinaryToWriter(message: ExtensionRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ExtensionRequest;
  static deserializeBinaryFromReader(message: ExtensionRequest, reader: jspb.BinaryReader): ExtensionRequest;
}

declare namespace ExtensionRequest {
  export type AsObject = {
    containingType: string,
    extensionNumber: number,
  }
}

declare class ServerReflectionResponse extends jspb.Message {
  getValidHost(): string;
  setValidHost(value: string): ServerReflectionResponse;

  getOriginalRequest(): ServerReflectionRequest | undefined;
  setOriginalRequest(value?: ServerReflectionRequest): ServerReflectionResponse;
  hasOriginalRequest(): boolean;
  clearOriginalRequest(): ServerReflectionResponse;

  getFileDescriptorResponse(): FileDescriptorResponse | undefined;
  setFileDescriptorResponse(value?: FileDescriptorResponse): ServerReflectionResponse;
  hasFileDescriptorResponse(): boolean;
  clearFileDescriptorResponse(): ServerReflectionResponse;

  getAllExtensionNumbersResponse(): ExtensionNumberResponse | undefined;
  setAllExtensionNumbersResponse(value?: ExtensionNumberResponse): ServerReflectionResponse;
  hasAllExtensionNumbersResponse(): boolean;
  clearAllExtensionNumbersResponse(): ServerReflectionResponse;

  getListServicesResponse(): ListServiceResponse | undefined;
  setListServicesResponse(value?: ListServiceResponse): ServerReflectionResponse;
  hasListServicesResponse(): boolean;
  clearListServicesResponse(): ServerReflectionResponse;

  getErrorResponse(): ErrorResponse | undefined;
  setErrorResponse(value?: ErrorResponse): ServerReflectionResponse;
  hasErrorResponse(): boolean;
  clearErrorResponse(): ServerReflectionResponse;

  getMessageResponseCase(): ServerReflectionResponse.MessageResponseCase;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ServerReflectionResponse.AsObject;
  static toObject(includeInstance: boolean, msg: ServerReflectionResponse): ServerReflectionResponse.AsObject;
  static serializeBinaryToWriter(message: ServerReflectionResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ServerReflectionResponse;
  static deserializeBinaryFromReader(message: ServerReflectionResponse, reader: jspb.BinaryReader): ServerReflectionResponse;
}

declare namespace ServerReflectionResponse {
  export type AsObject = {
    validHost: string,
    originalRequest?: ServerReflectionRequest.AsObject,
    fileDescriptorResponse?: FileDescriptorResponse.AsObject,
    allExtensionNumbersResponse?: ExtensionNumberResponse.AsObject,
    listServicesResponse?: ListServiceResponse.AsObject,
    errorResponse?: ErrorResponse.AsObject,
  }

  export enum MessageResponseCase { 
    MESSAGE_RESPONSE_NOT_SET = 0,
    FILE_DESCRIPTOR_RESPONSE = 4,
    ALL_EXTENSION_NUMBERS_RESPONSE = 5,
    LIST_SERVICES_RESPONSE = 6,
    ERROR_RESPONSE = 7,
  }
}

declare class FileDescriptorResponse extends jspb.Message {
  getFileDescriptorProtoList(): Array<Uint8Array | string>;
  setFileDescriptorProtoList(value: Array<Uint8Array | string>): FileDescriptorResponse;
  clearFileDescriptorProtoList(): FileDescriptorResponse;
  addFileDescriptorProto(value: Uint8Array | string, index?: number): FileDescriptorResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): FileDescriptorResponse.AsObject;
  static toObject(includeInstance: boolean, msg: FileDescriptorResponse): FileDescriptorResponse.AsObject;
  static serializeBinaryToWriter(message: FileDescriptorResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): FileDescriptorResponse;
  static deserializeBinaryFromReader(message: FileDescriptorResponse, reader: jspb.BinaryReader): FileDescriptorResponse;
}

declare namespace FileDescriptorResponse {
  export type AsObject = {
    fileDescriptorProtoList: Array<Uint8Array | string>,
  }
}

declare class ExtensionNumberResponse extends jspb.Message {
  getBaseTypeName(): string;
  setBaseTypeName(value: string): ExtensionNumberResponse;

  getExtensionNumberList(): Array<number>;
  setExtensionNumberList(value: Array<number>): ExtensionNumberResponse;
  clearExtensionNumberList(): ExtensionNumberResponse;
  addExtensionNumber(value: number, index?: number): ExtensionNumberResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ExtensionNumberResponse.AsObject;
  static toObject(includeInstance: boolean, msg: ExtensionNumberResponse): ExtensionNumberResponse.AsObject;
  static serializeBinaryToWriter(message: ExtensionNumberResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ExtensionNumberResponse;
  static deserializeBinaryFromReader(message: ExtensionNumberResponse, reader: jspb.BinaryReader): ExtensionNumberResponse;
}

declare namespace ExtensionNumberResponse {
  export type AsObject = {
    baseTypeName: string,
    extensionNumberList: Array<number>,
  }
}

declare class ListServiceResponse extends jspb.Message {
  getServiceList(): Array<ServiceResponse>;
  setServiceList(value: Array<ServiceResponse>): ListServiceResponse;
  clearServiceList(): ListServiceResponse;
  addService(value?: ServiceResponse, index?: number): ServiceResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ListServiceResponse.AsObject;
  static toObject(includeInstance: boolean, msg: ListServiceResponse): ListServiceResponse.AsObject;
  static serializeBinaryToWriter(message: ListServiceResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ListServiceResponse;
  static deserializeBinaryFromReader(message: ListServiceResponse, reader: jspb.BinaryReader): ListServiceResponse;
}

declare namespace ListServiceResponse {
  export type AsObject = {
    serviceList: Array<ServiceResponse.AsObject>,
  }
}

declare class ServiceResponse extends jspb.Message {
  getName(): string;
  setName(value: string): ServiceResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ServiceResponse.AsObject;
  static toObject(includeInstance: boolean, msg: ServiceResponse): ServiceResponse.AsObject;
  static serializeBinaryToWriter(message: ServiceResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ServiceResponse;
  static deserializeBinaryFromReader(message: ServiceResponse, reader: jspb.BinaryReader): ServiceResponse;
}

declare namespace ServiceResponse {
  export type AsObject = {
    name: string,
  }
}

declare class ErrorResponse extends jspb.Message {
  getErrorCode(): number;
  setErrorCode(value: number): ErrorResponse;

  getErrorMessage(): string;
  setErrorMessage(value: string): ErrorResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ErrorResponse.AsObject;
  static toObject(includeInstance: boolean, msg: ErrorResponse): ErrorResponse.AsObject;
  static serializeBinaryToWriter(message: ErrorResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ErrorResponse;
  static deserializeBinaryFromReader(message: ErrorResponse, reader: jspb.BinaryReader): ErrorResponse;
}

declare namespace ErrorResponse {
  export type AsObject = {
    errorCode: number,
    errorMessage: string,
  }
}

export { Color, Error, ErrorResponse$1 as ErrorResponse, EventRequest, EventResponse, EventResult, HealthCheckRequest, HealthCheckResponse, HealthClient, Image, LicenseService, LicenseServiceStatus, LicenseServiceStatusRequest, LicenseServiceStatusResponse, Mmr, PartialResult, Plate, Point, Quadrilateral, Region, ResultType, SearchRequest, SearchResponse, ServerReflectionClient, ServerReflectionRequest, ServerReflectionResponse, ServerStatusRequest, ServerStatusResponse, Sign, SignType, Status, TollingVisionServiceClient, Vehicle };