@huddly/camera-proto/lib/api/huddly_grpc_pb.js

An npm package describing the protobuf api for huddly network cameras

// GENERATED CODE -- DO NOT EDIT!

'use strict';
var grpc = require('@grpc/grpc-js');
var api_huddly_pb = require('../api/huddly_pb.js');
var google_protobuf_empty_pb = require('google-protobuf/google/protobuf/empty_pb.js');
var google_protobuf_timestamp_pb = require('google-protobuf/google/protobuf/timestamp_pb.js');

function serialize_google_protobuf_Empty(arg) {
  if (!(arg instanceof google_protobuf_empty_pb.Empty)) {
    throw new Error('Expected argument of type google.protobuf.Empty');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_google_protobuf_Empty(buffer_arg) {
  return google_protobuf_empty_pb.Empty.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_google_protobuf_Timestamp(arg) {
  if (!(arg instanceof google_protobuf_timestamp_pb.Timestamp)) {
    throw new Error('Expected argument of type google.protobuf.Timestamp');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_google_protobuf_Timestamp(buffer_arg) {
  return google_protobuf_timestamp_pb.Timestamp.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_AllowedDeviationEV(arg) {
  if (!(arg instanceof api_huddly_pb.AllowedDeviationEV)) {
    throw new Error('Expected argument of type huddly.AllowedDeviationEV');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_AllowedDeviationEV(buffer_arg) {
  return api_huddly_pb.AllowedDeviationEV.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Bbox(arg) {
  if (!(arg instanceof api_huddly_pb.Bbox)) {
    throw new Error('Expected argument of type huddly.Bbox');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Bbox(buffer_arg) {
  return api_huddly_pb.Bbox.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Blend(arg) {
  if (!(arg instanceof api_huddly_pb.Blend)) {
    throw new Error('Expected argument of type huddly.Blend');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Blend(buffer_arg) {
  return api_huddly_pb.Blend.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_BootSlot(arg) {
  if (!(arg instanceof api_huddly_pb.BootSlot)) {
    throw new Error('Expected argument of type huddly.BootSlot');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_BootSlot(buffer_arg) {
  return api_huddly_pb.BootSlot.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Brightness(arg) {
  if (!(arg instanceof api_huddly_pb.Brightness)) {
    throw new Error('Expected argument of type huddly.Brightness');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Brightness(buffer_arg) {
  return api_huddly_pb.Brightness.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_CNNStatus(arg) {
  if (!(arg instanceof api_huddly_pb.CNNStatus)) {
    throw new Error('Expected argument of type huddly.CNNStatus');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_CNNStatus(buffer_arg) {
  return api_huddly_pb.CNNStatus.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Camera(arg) {
  if (!(arg instanceof api_huddly_pb.Camera)) {
    throw new Error('Expected argument of type huddly.Camera');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Camera(buffer_arg) {
  return api_huddly_pb.Camera.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_CameraList(arg) {
  if (!(arg instanceof api_huddly_pb.CameraList)) {
    throw new Error('Expected argument of type huddly.CameraList');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_CameraList(buffer_arg) {
  return api_huddly_pb.CameraList.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Chunk(arg) {
  if (!(arg instanceof api_huddly_pb.Chunk)) {
    throw new Error('Expected argument of type huddly.Chunk');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Chunk(buffer_arg) {
  return api_huddly_pb.Chunk.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_CnnFeature(arg) {
  if (!(arg instanceof api_huddly_pb.CnnFeature)) {
    throw new Error('Expected argument of type huddly.CnnFeature');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_CnnFeature(buffer_arg) {
  return api_huddly_pb.CnnFeature.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_ConnectedCameraStatusList(arg) {
  if (!(arg instanceof api_huddly_pb.ConnectedCameraStatusList)) {
    throw new Error('Expected argument of type huddly.ConnectedCameraStatusList');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_ConnectedCameraStatusList(buffer_arg) {
  return api_huddly_pb.ConnectedCameraStatusList.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_CropIndexStatusResponse(arg) {
  if (!(arg instanceof api_huddly_pb.CropIndexStatusResponse)) {
    throw new Error('Expected argument of type huddly.CropIndexStatusResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_CropIndexStatusResponse(buffer_arg) {
  return api_huddly_pb.CropIndexStatusResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_CurrentPtzCrop(arg) {
  if (!(arg instanceof api_huddly_pb.CurrentPtzCrop)) {
    throw new Error('Expected argument of type huddly.CurrentPtzCrop');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_CurrentPtzCrop(buffer_arg) {
  return api_huddly_pb.CurrentPtzCrop.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Detections(arg) {
  if (!(arg instanceof api_huddly_pb.Detections)) {
    throw new Error('Expected argument of type huddly.Detections');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Detections(buffer_arg) {
  return api_huddly_pb.Detections.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_DeviceName(arg) {
  if (!(arg instanceof api_huddly_pb.DeviceName)) {
    throw new Error('Expected argument of type huddly.DeviceName');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_DeviceName(buffer_arg) {
  return api_huddly_pb.DeviceName.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_DeviceStatus(arg) {
  if (!(arg instanceof api_huddly_pb.DeviceStatus)) {
    throw new Error('Expected argument of type huddly.DeviceStatus');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_DeviceStatus(buffer_arg) {
  return api_huddly_pb.DeviceStatus.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_DeviceVersion(arg) {
  if (!(arg instanceof api_huddly_pb.DeviceVersion)) {
    throw new Error('Expected argument of type huddly.DeviceVersion');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_DeviceVersion(buffer_arg) {
  return api_huddly_pb.DeviceVersion.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_DirectorMode(arg) {
  if (!(arg instanceof api_huddly_pb.DirectorMode)) {
    throw new Error('Expected argument of type huddly.DirectorMode');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_DirectorMode(buffer_arg) {
  return api_huddly_pb.DirectorMode.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_DirectorModes(arg) {
  if (!(arg instanceof api_huddly_pb.DirectorModes)) {
    throw new Error('Expected argument of type huddly.DirectorModes');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_DirectorModes(buffer_arg) {
  return api_huddly_pb.DirectorModes.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_DirectorSetting(arg) {
  if (!(arg instanceof api_huddly_pb.DirectorSetting)) {
    throw new Error('Expected argument of type huddly.DirectorSetting');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_DirectorSetting(buffer_arg) {
  return api_huddly_pb.DirectorSetting.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_DirectorState(arg) {
  if (!(arg instanceof api_huddly_pb.DirectorState)) {
    throw new Error('Expected argument of type huddly.DirectorState');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_DirectorState(buffer_arg) {
  return api_huddly_pb.DirectorState.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_ExposureValues(arg) {
  if (!(arg instanceof api_huddly_pb.ExposureValues)) {
    throw new Error('Expected argument of type huddly.ExposureValues');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_ExposureValues(buffer_arg) {
  return api_huddly_pb.ExposureValues.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_FakeDetections(arg) {
  if (!(arg instanceof api_huddly_pb.FakeDetections)) {
    throw new Error('Expected argument of type huddly.FakeDetections');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_FakeDetections(buffer_arg) {
  return api_huddly_pb.FakeDetections.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_FeatureConfigRequest(arg) {
  if (!(arg instanceof api_huddly_pb.FeatureConfigRequest)) {
    throw new Error('Expected argument of type huddly.FeatureConfigRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_FeatureConfigRequest(buffer_arg) {
  return api_huddly_pb.FeatureConfigRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_File(arg) {
  if (!(arg instanceof api_huddly_pb.File)) {
    throw new Error('Expected argument of type huddly.File');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_File(buffer_arg) {
  return api_huddly_pb.File.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_FocusArea(arg) {
  if (!(arg instanceof api_huddly_pb.FocusArea)) {
    throw new Error('Expected argument of type huddly.FocusArea');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_FocusArea(buffer_arg) {
  return api_huddly_pb.FocusArea.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_FocusAreaPersonListReply(arg) {
  if (!(arg instanceof api_huddly_pb.FocusAreaPersonListReply)) {
    throw new Error('Expected argument of type huddly.FocusAreaPersonListReply');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_FocusAreaPersonListReply(buffer_arg) {
  return api_huddly_pb.FocusAreaPersonListReply.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Frame(arg) {
  if (!(arg instanceof api_huddly_pb.Frame)) {
    throw new Error('Expected argument of type huddly.Frame');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Frame(buffer_arg) {
  return api_huddly_pb.Frame.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_GetCommandRequest(arg) {
  if (!(arg instanceof api_huddly_pb.GetCommandRequest)) {
    throw new Error('Expected argument of type huddly.GetCommandRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_GetCommandRequest(buffer_arg) {
  return api_huddly_pb.GetCommandRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_GetCommandResponse(arg) {
  if (!(arg instanceof api_huddly_pb.GetCommandResponse)) {
    throw new Error('Expected argument of type huddly.GetCommandResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_GetCommandResponse(buffer_arg) {
  return api_huddly_pb.GetCommandResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_GetFeatures(arg) {
  if (!(arg instanceof api_huddly_pb.GetFeatures)) {
    throw new Error('Expected argument of type huddly.GetFeatures');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_GetFeatures(buffer_arg) {
  return api_huddly_pb.GetFeatures.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_IndexedTransitions(arg) {
  if (!(arg instanceof api_huddly_pb.IndexedTransitions)) {
    throw new Error('Expected argument of type huddly.IndexedTransitions');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_IndexedTransitions(buffer_arg) {
  return api_huddly_pb.IndexedTransitions.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_IndexedTransitionsResponse(arg) {
  if (!(arg instanceof api_huddly_pb.IndexedTransitionsResponse)) {
    throw new Error('Expected argument of type huddly.IndexedTransitionsResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_IndexedTransitionsResponse(buffer_arg) {
  return api_huddly_pb.IndexedTransitionsResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_LEDControl(arg) {
  if (!(arg instanceof api_huddly_pb.LEDControl)) {
    throw new Error('Expected argument of type huddly.LEDControl');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_LEDControl(buffer_arg) {
  return api_huddly_pb.LEDControl.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_LogFile(arg) {
  if (!(arg instanceof api_huddly_pb.LogFile)) {
    throw new Error('Expected argument of type huddly.LogFile');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_LogFile(buffer_arg) {
  return api_huddly_pb.LogFile.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_LogVerbosity(arg) {
  if (!(arg instanceof api_huddly_pb.LogVerbosity)) {
    throw new Error('Expected argument of type huddly.LogVerbosity');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_LogVerbosity(buffer_arg) {
  return api_huddly_pb.LogVerbosity.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_MemoryLogState(arg) {
  if (!(arg instanceof api_huddly_pb.MemoryLogState)) {
    throw new Error('Expected argument of type huddly.MemoryLogState');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_MemoryLogState(buffer_arg) {
  return api_huddly_pb.MemoryLogState.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_MjpegRateSettings(arg) {
  if (!(arg instanceof api_huddly_pb.MjpegRateSettings)) {
    throw new Error('Expected argument of type huddly.MjpegRateSettings');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_MjpegRateSettings(buffer_arg) {
  return api_huddly_pb.MjpegRateSettings.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_MulticamExposure(arg) {
  if (!(arg instanceof api_huddly_pb.MulticamExposure)) {
    throw new Error('Expected argument of type huddly.MulticamExposure');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_MulticamExposure(buffer_arg) {
  return api_huddly_pb.MulticamExposure.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_MulticamExposureStatus(arg) {
  if (!(arg instanceof api_huddly_pb.MulticamExposureStatus)) {
    throw new Error('Expected argument of type huddly.MulticamExposureStatus');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_MulticamExposureStatus(buffer_arg) {
  return api_huddly_pb.MulticamExposureStatus.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_MulticamWhitebalance(arg) {
  if (!(arg instanceof api_huddly_pb.MulticamWhitebalance)) {
    throw new Error('Expected argument of type huddly.MulticamWhitebalance');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_MulticamWhitebalance(buffer_arg) {
  return api_huddly_pb.MulticamWhitebalance.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_MulticamWhitebalanceStatus(arg) {
  if (!(arg instanceof api_huddly_pb.MulticamWhitebalanceStatus)) {
    throw new Error('Expected argument of type huddly.MulticamWhitebalanceStatus');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_MulticamWhitebalanceStatus(buffer_arg) {
  return api_huddly_pb.MulticamWhitebalanceStatus.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_NetworkIpv4Config(arg) {
  if (!(arg instanceof api_huddly_pb.NetworkIpv4Config)) {
    throw new Error('Expected argument of type huddly.NetworkIpv4Config');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_NetworkIpv4Config(buffer_arg) {
  return api_huddly_pb.NetworkIpv4Config.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_OptionCertificates(arg) {
  if (!(arg instanceof api_huddly_pb.OptionCertificates)) {
    throw new Error('Expected argument of type huddly.OptionCertificates');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_OptionCertificates(buffer_arg) {
  return api_huddly_pb.OptionCertificates.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Orientation(arg) {
  if (!(arg instanceof api_huddly_pb.Orientation)) {
    throw new Error('Expected argument of type huddly.Orientation');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Orientation(buffer_arg) {
  return api_huddly_pb.Orientation.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_OverlayFeatureMessage(arg) {
  if (!(arg instanceof api_huddly_pb.OverlayFeatureMessage)) {
    throw new Error('Expected argument of type huddly.OverlayFeatureMessage');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_OverlayFeatureMessage(buffer_arg) {
  return api_huddly_pb.OverlayFeatureMessage.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_OverlayFeatureStatus(arg) {
  if (!(arg instanceof api_huddly_pb.OverlayFeatureStatus)) {
    throw new Error('Expected argument of type huddly.OverlayFeatureStatus');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_OverlayFeatureStatus(buffer_arg) {
  return api_huddly_pb.OverlayFeatureStatus.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_PTZ(arg) {
  if (!(arg instanceof api_huddly_pb.PTZ)) {
    throw new Error('Expected argument of type huddly.PTZ');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_PTZ(buffer_arg) {
  return api_huddly_pb.PTZ.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_PTZNormalized(arg) {
  if (!(arg instanceof api_huddly_pb.PTZNormalized)) {
    throw new Error('Expected argument of type huddly.PTZNormalized');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_PTZNormalized(buffer_arg) {
  return api_huddly_pb.PTZNormalized.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_PeopleCountResponse(arg) {
  if (!(arg instanceof api_huddly_pb.PeopleCountResponse)) {
    throw new Error('Expected argument of type huddly.PeopleCountResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_PeopleCountResponse(buffer_arg) {
  return api_huddly_pb.PeopleCountResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_PerspectiveCorrectionSettings(arg) {
  if (!(arg instanceof api_huddly_pb.PerspectiveCorrectionSettings)) {
    throw new Error('Expected argument of type huddly.PerspectiveCorrectionSettings');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_PerspectiveCorrectionSettings(buffer_arg) {
  return api_huddly_pb.PerspectiveCorrectionSettings.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_PlazaConfig(arg) {
  if (!(arg instanceof api_huddly_pb.PlazaConfig)) {
    throw new Error('Expected argument of type huddly.PlazaConfig');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_PlazaConfig(buffer_arg) {
  return api_huddly_pb.PlazaConfig.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Saturation(arg) {
  if (!(arg instanceof api_huddly_pb.Saturation)) {
    throw new Error('Expected argument of type huddly.Saturation');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Saturation(buffer_arg) {
  return api_huddly_pb.Saturation.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_SetCommandRequest(arg) {
  if (!(arg instanceof api_huddly_pb.SetCommandRequest)) {
    throw new Error('Expected argument of type huddly.SetCommandRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_SetCommandRequest(buffer_arg) {
  return api_huddly_pb.SetCommandRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_SetCommandResponse(arg) {
  if (!(arg instanceof api_huddly_pb.SetCommandResponse)) {
    throw new Error('Expected argument of type huddly.SetCommandResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_SetCommandResponse(buffer_arg) {
  return api_huddly_pb.SetCommandResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Setting(arg) {
  if (!(arg instanceof api_huddly_pb.Setting)) {
    throw new Error('Expected argument of type huddly.Setting');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Setting(buffer_arg) {
  return api_huddly_pb.Setting.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Signature(arg) {
  if (!(arg instanceof api_huddly_pb.Signature)) {
    throw new Error('Expected argument of type huddly.Signature');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Signature(buffer_arg) {
  return api_huddly_pb.Signature.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_SingleNormalizedPTZEntry(arg) {
  if (!(arg instanceof api_huddly_pb.SingleNormalizedPTZEntry)) {
    throw new Error('Expected argument of type huddly.SingleNormalizedPTZEntry');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_SingleNormalizedPTZEntry(buffer_arg) {
  return api_huddly_pb.SingleNormalizedPTZEntry.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_SpeakerStatus(arg) {
  if (!(arg instanceof api_huddly_pb.SpeakerStatus)) {
    throw new Error('Expected argument of type huddly.SpeakerStatus');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_SpeakerStatus(buffer_arg) {
  return api_huddly_pb.SpeakerStatus.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Temperatures(arg) {
  if (!(arg instanceof api_huddly_pb.Temperatures)) {
    throw new Error('Expected argument of type huddly.Temperatures');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Temperatures(buffer_arg) {
  return api_huddly_pb.Temperatures.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_TestCommandMessage(arg) {
  if (!(arg instanceof api_huddly_pb.TestCommandMessage)) {
    throw new Error('Expected argument of type huddly.TestCommandMessage');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_TestCommandMessage(buffer_arg) {
  return api_huddly_pb.TestCommandMessage.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Timestamping(arg) {
  if (!(arg instanceof api_huddly_pb.Timestamping)) {
    throw new Error('Expected argument of type huddly.Timestamping');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Timestamping(buffer_arg) {
  return api_huddly_pb.Timestamping.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_TimestampingStatus(arg) {
  if (!(arg instanceof api_huddly_pb.TimestampingStatus)) {
    throw new Error('Expected argument of type huddly.TimestampingStatus');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_TimestampingStatus(buffer_arg) {
  return api_huddly_pb.TimestampingStatus.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Timezone(arg) {
  if (!(arg instanceof api_huddly_pb.Timezone)) {
    throw new Error('Expected argument of type huddly.Timezone');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Timezone(buffer_arg) {
  return api_huddly_pb.Timezone.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_Uptime(arg) {
  if (!(arg instanceof api_huddly_pb.Uptime)) {
    throw new Error('Expected argument of type huddly.Uptime');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_Uptime(buffer_arg) {
  return api_huddly_pb.Uptime.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_UserIdentifier(arg) {
  if (!(arg instanceof api_huddly_pb.UserIdentifier)) {
    throw new Error('Expected argument of type huddly.UserIdentifier');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_UserIdentifier(buffer_arg) {
  return api_huddly_pb.UserIdentifier.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_VerificationRequest(arg) {
  if (!(arg instanceof api_huddly_pb.VerificationRequest)) {
    throw new Error('Expected argument of type huddly.VerificationRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_VerificationRequest(buffer_arg) {
  return api_huddly_pb.VerificationRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_huddly_VideoFormats(arg) {
  if (!(arg instanceof api_huddly_pb.VideoFormats)) {
    throw new Error('Expected argument of type huddly.VideoFormats');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_huddly_VideoFormats(buffer_arg) {
  return api_huddly_pb.VideoFormats.deserializeBinary(new Uint8Array(buffer_arg));
}


var HuddlyServiceService = exports.HuddlyServiceService = {
  upgradeDevice: {
    path: '/huddly.HuddlyService/UpgradeDevice',
    requestStream: true,
    responseStream: false,
    requestType: api_huddly_pb.Chunk,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_Chunk,
    requestDeserialize: deserialize_huddly_Chunk,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  upgradeVerify: {
    path: '/huddly.HuddlyService/UpgradeVerify',
    requestStream: true,
    responseStream: false,
    requestType: api_huddly_pb.Chunk,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_Chunk,
    requestDeserialize: deserialize_huddly_Chunk,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  upgradeImage: {
    path: '/huddly.HuddlyService/UpgradeImage',
    requestStream: true,
    responseStream: false,
    requestType: api_huddly_pb.Chunk,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_Chunk,
    requestDeserialize: deserialize_huddly_Chunk,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  verifyIntegrity: {
    path: '/huddly.HuddlyService/VerifyIntegrity',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.VerificationRequest,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_VerificationRequest,
    requestDeserialize: deserialize_huddly_VerificationRequest,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  reset: {
    path: '/huddly.HuddlyService/Reset',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  getDeviceName: {
    path: '/huddly.HuddlyService/GetDeviceName',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.DeviceName,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_DeviceName,
    responseDeserialize: deserialize_huddly_DeviceName,
  },
  getDeviceVersion: {
    path: '/huddly.HuddlyService/GetDeviceVersion',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.DeviceVersion,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_DeviceVersion,
    responseDeserialize: deserialize_huddly_DeviceVersion,
  },
  getBootloaderVersion: {
    path: '/huddly.HuddlyService/GetBootloaderVersion',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.DeviceVersion,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_DeviceVersion,
    responseDeserialize: deserialize_huddly_DeviceVersion,
  },
  getDevicePackages: {
    path: '/huddly.HuddlyService/GetDevicePackages',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.DeviceVersion,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_DeviceVersion,
    responseDeserialize: deserialize_huddly_DeviceVersion,
  },
  getBootSlot: {
    path: '/huddly.HuddlyService/GetBootSlot',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.BootSlot,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_BootSlot,
    responseDeserialize: deserialize_huddly_BootSlot,
  },
  setBootSlot: {
    path: '/huddly.HuddlyService/SetBootSlot',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.BootSlot,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_BootSlot,
    requestDeserialize: deserialize_huddly_BootSlot,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  upgradeBootLoader: {
    path: '/huddly.HuddlyService/UpgradeBootLoader',
    requestStream: true,
    responseStream: false,
    requestType: api_huddly_pb.Chunk,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_Chunk,
    requestDeserialize: deserialize_huddly_Chunk,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  setNetworkIpv4Config: {
    path: '/huddly.HuddlyService/SetNetworkIpv4Config',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.NetworkIpv4Config,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_NetworkIpv4Config,
    requestDeserialize: deserialize_huddly_NetworkIpv4Config,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  getNetworkIpv4Config: {
    path: '/huddly.HuddlyService/GetNetworkIpv4Config',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.NetworkIpv4Config,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_NetworkIpv4Config,
    responseDeserialize: deserialize_huddly_NetworkIpv4Config,
  },
  setPTZ: {
    path: '/huddly.HuddlyService/SetPTZ',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.PTZ,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_PTZ,
    requestDeserialize: deserialize_huddly_PTZ,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  setPTZNormalized: {
    path: '/huddly.HuddlyService/SetPTZNormalized',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.PTZNormalized,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_PTZNormalized,
    requestDeserialize: deserialize_huddly_PTZNormalized,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  setPan: {
    path: '/huddly.HuddlyService/SetPan',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.SingleNormalizedPTZEntry,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_SingleNormalizedPTZEntry,
    requestDeserialize: deserialize_huddly_SingleNormalizedPTZEntry,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  setTilt: {
    path: '/huddly.HuddlyService/SetTilt',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.SingleNormalizedPTZEntry,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_SingleNormalizedPTZEntry,
    requestDeserialize: deserialize_huddly_SingleNormalizedPTZEntry,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  setZoom: {
    path: '/huddly.HuddlyService/SetZoom',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.SingleNormalizedPTZEntry,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_SingleNormalizedPTZEntry,
    requestDeserialize: deserialize_huddly_SingleNormalizedPTZEntry,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  getPTZ: {
    path: '/huddly.HuddlyService/GetPTZ',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.PTZ,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_PTZ,
    responseDeserialize: deserialize_huddly_PTZ,
  },
  getPTZNormalized: {
    path: '/huddly.HuddlyService/GetPTZNormalized',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.PTZNormalized,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_PTZNormalized,
    responseDeserialize: deserialize_huddly_PTZNormalized,
  },
  getPan: {
    path: '/huddly.HuddlyService/GetPan',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.SingleNormalizedPTZEntry,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_SingleNormalizedPTZEntry,
    responseDeserialize: deserialize_huddly_SingleNormalizedPTZEntry,
  },
  getTilt: {
    path: '/huddly.HuddlyService/GetTilt',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.SingleNormalizedPTZEntry,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_SingleNormalizedPTZEntry,
    responseDeserialize: deserialize_huddly_SingleNormalizedPTZEntry,
  },
  getZoom: {
    path: '/huddly.HuddlyService/GetZoom',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.SingleNormalizedPTZEntry,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_SingleNormalizedPTZEntry,
    responseDeserialize: deserialize_huddly_SingleNormalizedPTZEntry,
  },
  getDetections: {
    path: '/huddly.HuddlyService/GetDetections',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.Detections,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_Detections,
    responseDeserialize: deserialize_huddly_Detections,
  },
  getLogFiles: {
    path: '/huddly.HuddlyService/GetLogFiles',
    requestStream: false,
    responseStream: true,
    requestType: api_huddly_pb.LogFile,
    responseType: api_huddly_pb.Chunk,
    requestSerialize: serialize_huddly_LogFile,
    requestDeserialize: deserialize_huddly_LogFile,
    responseSerialize: serialize_huddly_Chunk,
    responseDeserialize: deserialize_huddly_Chunk,
  },
  eraseLogFile: {
    path: '/huddly.HuddlyService/EraseLogFile',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.LogFile,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_LogFile,
    requestDeserialize: deserialize_huddly_LogFile,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  setLogVerbosity: {
    path: '/huddly.HuddlyService/SetLogVerbosity',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.LogVerbosity,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_LogVerbosity,
    requestDeserialize: deserialize_huddly_LogVerbosity,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  // @HuddlyOnly-NextLine
setMemoryLogState: {
    path: '/huddly.HuddlyService/SetMemoryLogState',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.MemoryLogState,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_MemoryLogState,
    requestDeserialize: deserialize_huddly_MemoryLogState,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  getTemperatures: {
    path: '/huddly.HuddlyService/GetTemperatures',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.Temperatures,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_Temperatures,
    responseDeserialize: deserialize_huddly_Temperatures,
  },
  resetPtzTransition: {
    path: '/huddly.HuddlyService/ResetPtzTransition',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  getCropIndex: {
    path: '/huddly.HuddlyService/GetCropIndex',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.CropIndexStatusResponse,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_CropIndexStatusResponse,
    responseDeserialize: deserialize_huddly_CropIndexStatusResponse,
  },
  ptzTransition: {
    path: '/huddly.HuddlyService/PtzTransition',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.IndexedTransitions,
    responseType: api_huddly_pb.IndexedTransitionsResponse,
    requestSerialize: serialize_huddly_IndexedTransitions,
    requestDeserialize: deserialize_huddly_IndexedTransitions,
    responseSerialize: serialize_huddly_IndexedTransitionsResponse,
    responseDeserialize: deserialize_huddly_IndexedTransitionsResponse,
  },
  getCurrentPtzCrop: {
    path: '/huddly.HuddlyService/GetCurrentPtzCrop',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.CurrentPtzCrop,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_CurrentPtzCrop,
    responseDeserialize: deserialize_huddly_CurrentPtzCrop,
  },
  setCnnFeature: {
    path: '/huddly.HuddlyService/SetCnnFeature',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.CnnFeature,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_CnnFeature,
    requestDeserialize: deserialize_huddly_CnnFeature,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  // @HuddlyOnly-NextLine
getCnnFeatureStatus: {
    path: '/huddly.HuddlyService/GetCnnFeatureStatus',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.CnnFeature,
    responseType: api_huddly_pb.CNNStatus,
    requestSerialize: serialize_huddly_CnnFeature,
    requestDeserialize: deserialize_huddly_CnnFeature,
    responseSerialize: serialize_huddly_CNNStatus,
    responseDeserialize: deserialize_huddly_CNNStatus,
  },
  getUptime: {
    path: '/huddly.HuddlyService/GetUptime',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.Uptime,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_Uptime,
    responseDeserialize: deserialize_huddly_Uptime,
  },
  setTimezone: {
    path: '/huddly.HuddlyService/SetTimezone',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.Timezone,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_Timezone,
    requestDeserialize: deserialize_huddly_Timezone,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  getTimezone: {
    path: '/huddly.HuddlyService/GetTimezone',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.Timezone,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_Timezone,
    responseDeserialize: deserialize_huddly_Timezone,
  },
  setTime: {
    path: '/huddly.HuddlyService/SetTime',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_timestamp_pb.Timestamp,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_google_protobuf_Timestamp,
    requestDeserialize: deserialize_google_protobuf_Timestamp,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  getTime: {
    path: '/huddly.HuddlyService/GetTime',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: google_protobuf_timestamp_pb.Timestamp,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_google_protobuf_Timestamp,
    responseDeserialize: deserialize_google_protobuf_Timestamp,
  },
  setBrightness: {
    path: '/huddly.HuddlyService/SetBrightness',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.Brightness,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_Brightness,
    requestDeserialize: deserialize_huddly_Brightness,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  getBrightness: {
    path: '/huddly.HuddlyService/GetBrightness',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.Brightness,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_Brightness,
    responseDeserialize: deserialize_huddly_Brightness,
  },
  setSaturation: {
    path: '/huddly.HuddlyService/SetSaturation',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.Saturation,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_Saturation,
    requestDeserialize: deserialize_huddly_Saturation,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  getSaturation: {
    path: '/huddly.HuddlyService/GetSaturation',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.Saturation,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_Saturation,
    responseDeserialize: deserialize_huddly_Saturation,
  },
  setOrientation: {
    path: '/huddly.HuddlyService/SetOrientation',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.Orientation,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_Orientation,
    requestDeserialize: deserialize_huddly_Orientation,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  getRawBuffer: {
    path: '/huddly.HuddlyService/GetRawBuffer',
    requestStream: false,
    responseStream: true,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.Chunk,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_Chunk,
    responseDeserialize: deserialize_huddly_Chunk,
  },
  getVideoFormats: {
    path: '/huddly.HuddlyService/GetVideoFormats',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.VideoFormats,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_VideoFormats,
    responseDeserialize: deserialize_huddly_VideoFormats,
  },
  clearSettings: {
    path: '/huddly.HuddlyService/ClearSettings',
    requestStream: false,
    responseStream: false,
    requestType: google_protobuf_empty_pb.Empty,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_google_protobuf_Empty,
    requestDeserialize: deserialize_google_protobuf_Empty,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  setUserIdentifier: {
    path: '/huddly.HuddlyService/SetUserIdentifier',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.UserIdentifier,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_UserIdentifier,
    requestDeserialize: deserialize_huddly_UserIdentifier,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  controlSetting: {
    path: '/huddly.HuddlyService/ControlSetting',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.Setting,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_Setting,
    requestDeserialize: deserialize_huddly_Setting,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  setFrame: {
    path: '/huddly.HuddlyService/SetFrame',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.Bbox,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_Bbox,
    requestDeserialize: deserialize_huddly_Bbox,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_DeviceStatus,
  },
  setFrameSmooth: {
    path: '/huddly.HuddlyService/SetFrameSmooth',
    requestStream: false,
    responseStream: false,
    requestType: api_huddly_pb.Frame,
    responseType: api_huddly_pb.DeviceStatus,
    requestSerialize: serialize_huddly_Frame,
    requestDeserialize: deserialize_huddly_Frame,
    responseSerialize: serialize_huddly_DeviceStatus,
    responseDeserialize: deserialize_huddly_Dev