@norskvideo/norsk-api 0.0.322

package/lib/media_grpc_pb.js

@@ -0,0 +1,1731 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+'use strict';
+var grpc = require('@grpc/grpc-js');
+var media_pb = require('./media_pb.js');
+var shared_common_pb = require('./shared/common_pb.js');
+var google_protobuf_timestamp_pb = require('@bufbuild/protobuf');
+var google_protobuf_empty_pb = require('@bufbuild/protobuf');
+
+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.toBinary());
+}
+
+function deserialize_google_protobuf_Empty(buffer_arg) {
+  return google_protobuf_empty_pb.Empty.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioBuildMultichannelEvent(arg) {
+  if (!(arg instanceof media_pb.AudioBuildMultichannelEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioBuildMultichannelEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioBuildMultichannelEvent(buffer_arg) {
+  return media_pb.AudioBuildMultichannelEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioBuildMultichannelMessage(arg) {
+  if (!(arg instanceof media_pb.AudioBuildMultichannelMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioBuildMultichannelMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioBuildMultichannelMessage(buffer_arg) {
+  return media_pb.AudioBuildMultichannelMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioEncoderEvent(arg) {
+  if (!(arg instanceof media_pb.AudioEncoderEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioEncoderEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioEncoderEvent(buffer_arg) {
+  return media_pb.AudioEncoderEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioEncoderMessage(arg) {
+  if (!(arg instanceof media_pb.AudioEncoderMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioEncoderMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioEncoderMessage(buffer_arg) {
+  return media_pb.AudioEncoderMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioGainEvent(arg) {
+  if (!(arg instanceof media_pb.AudioGainEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioGainEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioGainEvent(buffer_arg) {
+  return media_pb.AudioGainEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioGainMessage(arg) {
+  if (!(arg instanceof media_pb.AudioGainMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioGainMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioGainMessage(buffer_arg) {
+  return media_pb.AudioGainMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioLevelsEvent(arg) {
+  if (!(arg instanceof media_pb.AudioLevelsEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioLevelsEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioLevelsEvent(buffer_arg) {
+  return media_pb.AudioLevelsEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioLevelsMessage(arg) {
+  if (!(arg instanceof media_pb.AudioLevelsMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioLevelsMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioLevelsMessage(buffer_arg) {
+  return media_pb.AudioLevelsMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioMatrixMixerEvent(arg) {
+  if (!(arg instanceof media_pb.AudioMatrixMixerEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioMatrixMixerEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioMatrixMixerEvent(buffer_arg) {
+  return media_pb.AudioMatrixMixerEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioMatrixMixerMessage(arg) {
+  if (!(arg instanceof media_pb.AudioMatrixMixerMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioMatrixMixerMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioMatrixMixerMessage(buffer_arg) {
+  return media_pb.AudioMatrixMixerMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioMixerEvent(arg) {
+  if (!(arg instanceof media_pb.AudioMixerEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioMixerEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioMixerEvent(buffer_arg) {
+  return media_pb.AudioMixerEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioMixerMessage(arg) {
+  if (!(arg instanceof media_pb.AudioMixerMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioMixerMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioMixerMessage(buffer_arg) {
+  return media_pb.AudioMixerMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioSignalGeneratorConfiguration(arg) {
+  if (!(arg instanceof media_pb.AudioSignalGeneratorConfiguration)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioSignalGeneratorConfiguration');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioSignalGeneratorConfiguration(buffer_arg) {
+  return media_pb.AudioSignalGeneratorConfiguration.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioSignalGeneratorEvent(arg) {
+  if (!(arg instanceof media_pb.AudioSignalGeneratorEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioSignalGeneratorEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioSignalGeneratorEvent(buffer_arg) {
+  return media_pb.AudioSignalGeneratorEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioSplitMultichannelEvent(arg) {
+  if (!(arg instanceof media_pb.AudioSplitMultichannelEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioSplitMultichannelEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioSplitMultichannelEvent(buffer_arg) {
+  return media_pb.AudioSplitMultichannelEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AudioSplitMultichannelMessage(arg) {
+  if (!(arg instanceof media_pb.AudioSplitMultichannelMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioSplitMultichannelMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AudioSplitMultichannelMessage(buffer_arg) {
+  return media_pb.AudioSplitMultichannelMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AwsTranscribeEvent(arg) {
+  if (!(arg instanceof media_pb.AwsTranscribeEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AwsTranscribeEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AwsTranscribeEvent(buffer_arg) {
+  return media_pb.AwsTranscribeEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_AwsTranscribeMessage(arg) {
+  if (!(arg instanceof media_pb.AwsTranscribeMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AwsTranscribeMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_AwsTranscribeMessage(buffer_arg) {
+  return media_pb.AwsTranscribeMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_BlockingCallRef(arg) {
+  if (!(arg instanceof media_pb.BlockingCallRef)) {
+    throw new Error('Expected argument of type norsk.api.media.BlockingCallRef');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_BlockingCallRef(buffer_arg) {
+  return media_pb.BlockingCallRef.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_BrowserInputEvent(arg) {
+  if (!(arg instanceof media_pb.BrowserInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.BrowserInputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_BrowserInputEvent(buffer_arg) {
+  return media_pb.BrowserInputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_BrowserInputMessage(arg) {
+  if (!(arg instanceof media_pb.BrowserInputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.BrowserInputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_BrowserInputMessage(buffer_arg) {
+  return media_pb.BrowserInputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_ChaosMonkeyEvent(arg) {
+  if (!(arg instanceof media_pb.ChaosMonkeyEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.ChaosMonkeyEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_ChaosMonkeyEvent(buffer_arg) {
+  return media_pb.ChaosMonkeyEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_ChaosMonkeyMessage(arg) {
+  if (!(arg instanceof media_pb.ChaosMonkeyMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.ChaosMonkeyMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_ChaosMonkeyMessage(buffer_arg) {
+  return media_pb.ChaosMonkeyMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_ComposeVideoMessage(arg) {
+  if (!(arg instanceof media_pb.ComposeVideoMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.ComposeVideoMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_ComposeVideoMessage(buffer_arg) {
+  return media_pb.ComposeVideoMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_ComposeVideoSourceEvent(arg) {
+  if (!(arg instanceof media_pb.ComposeVideoSourceEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.ComposeVideoSourceEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_ComposeVideoSourceEvent(buffer_arg) {
+  return media_pb.ComposeVideoSourceEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_DeckLinkCardIndex(arg) {
+  if (!(arg instanceof media_pb.DeckLinkCardIndex)) {
+    throw new Error('Expected argument of type norsk.api.media.DeckLinkCardIndex');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_DeckLinkCardIndex(buffer_arg) {
+  return media_pb.DeckLinkCardIndex.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_DeckLinkDisplayModes(arg) {
+  if (!(arg instanceof media_pb.DeckLinkDisplayModes)) {
+    throw new Error('Expected argument of type norsk.api.media.DeckLinkDisplayModes');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_DeckLinkDisplayModes(buffer_arg) {
+  return media_pb.DeckLinkDisplayModes.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_DeckLinkInputEvent(arg) {
+  if (!(arg instanceof media_pb.DeckLinkInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.DeckLinkInputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_DeckLinkInputEvent(buffer_arg) {
+  return media_pb.DeckLinkInputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_DeckLinkInputMessage(arg) {
+  if (!(arg instanceof media_pb.DeckLinkInputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.DeckLinkInputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_DeckLinkInputMessage(buffer_arg) {
+  return media_pb.DeckLinkInputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HardSwitcherEvent(arg) {
+  if (!(arg instanceof media_pb.HardSwitcherEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.HardSwitcherEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HardSwitcherEvent(buffer_arg) {
+  return media_pb.HardSwitcherEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HardSwitcherMessage(arg) {
+  if (!(arg instanceof media_pb.HardSwitcherMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.HardSwitcherMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HardSwitcherMessage(buffer_arg) {
+  return media_pb.HardSwitcherMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_Hardware(arg) {
+  if (!(arg instanceof media_pb.Hardware)) {
+    throw new Error('Expected argument of type norsk.api.media.Hardware');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_Hardware(buffer_arg) {
+  return media_pb.Hardware.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HlsAudioMessage(arg) {
+  if (!(arg instanceof media_pb.HlsAudioMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.HlsAudioMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HlsAudioMessage(buffer_arg) {
+  return media_pb.HlsAudioMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HlsMasterMessage(arg) {
+  if (!(arg instanceof media_pb.HlsMasterMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.HlsMasterMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HlsMasterMessage(buffer_arg) {
+  return media_pb.HlsMasterMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HlsMasterPushMessage(arg) {
+  if (!(arg instanceof media_pb.HlsMasterPushMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.HlsMasterPushMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HlsMasterPushMessage(buffer_arg) {
+  return media_pb.HlsMasterPushMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HlsOutputEvent(arg) {
+  if (!(arg instanceof media_pb.HlsOutputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.HlsOutputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HlsOutputEvent(buffer_arg) {
+  return media_pb.HlsOutputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HlsTsAudioMessage(arg) {
+  if (!(arg instanceof media_pb.HlsTsAudioMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.HlsTsAudioMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HlsTsAudioMessage(buffer_arg) {
+  return media_pb.HlsTsAudioMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HlsTsAudioPushMessage(arg) {
+  if (!(arg instanceof media_pb.HlsTsAudioPushMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.HlsTsAudioPushMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HlsTsAudioPushMessage(buffer_arg) {
+  return media_pb.HlsTsAudioPushMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HlsTsCombinedPushMessage(arg) {
+  if (!(arg instanceof media_pb.HlsTsCombinedPushMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.HlsTsCombinedPushMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HlsTsCombinedPushMessage(buffer_arg) {
+  return media_pb.HlsTsCombinedPushMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HlsTsVideoMessage(arg) {
+  if (!(arg instanceof media_pb.HlsTsVideoMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.HlsTsVideoMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HlsTsVideoMessage(buffer_arg) {
+  return media_pb.HlsTsVideoMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HlsTsVideoPushMessage(arg) {
+  if (!(arg instanceof media_pb.HlsTsVideoPushMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.HlsTsVideoPushMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HlsTsVideoPushMessage(buffer_arg) {
+  return media_pb.HlsTsVideoPushMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HlsVideoMessage(arg) {
+  if (!(arg instanceof media_pb.HlsVideoMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.HlsVideoMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HlsVideoMessage(buffer_arg) {
+  return media_pb.HlsVideoMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HlsWebVttMessage(arg) {
+  if (!(arg instanceof media_pb.HlsWebVttMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.HlsWebVttMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HlsWebVttMessage(buffer_arg) {
+  return media_pb.HlsWebVttMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_HlsWebVttPushMessage(arg) {
+  if (!(arg instanceof media_pb.HlsWebVttPushMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.HlsWebVttPushMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_HlsWebVttPushMessage(buffer_arg) {
+  return media_pb.HlsWebVttPushMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_ImageFileInputConfiguration(arg) {
+  if (!(arg instanceof media_pb.ImageFileInputConfiguration)) {
+    throw new Error('Expected argument of type norsk.api.media.ImageFileInputConfiguration');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_ImageFileInputConfiguration(buffer_arg) {
+  return media_pb.ImageFileInputConfiguration.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_ImageFileInputEvent(arg) {
+  if (!(arg instanceof media_pb.ImageFileInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.ImageFileInputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_ImageFileInputEvent(buffer_arg) {
+  return media_pb.ImageFileInputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_M3u8MediaInputMessage(arg) {
+  if (!(arg instanceof media_pb.M3u8MediaInputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.M3u8MediaInputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_M3u8MediaInputMessage(buffer_arg) {
+  return media_pb.M3u8MediaInputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_MetadataOverrideEvent(arg) {
+  if (!(arg instanceof media_pb.MetadataOverrideEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.MetadataOverrideEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_MetadataOverrideEvent(buffer_arg) {
+  return media_pb.MetadataOverrideEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_MetadataOverrideMessage(arg) {
+  if (!(arg instanceof media_pb.MetadataOverrideMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.MetadataOverrideMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_MetadataOverrideMessage(buffer_arg) {
+  return media_pb.MetadataOverrideMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_Mp4FileInputEvent(arg) {
+  if (!(arg instanceof media_pb.Mp4FileInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.Mp4FileInputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_Mp4FileInputEvent(buffer_arg) {
+  return media_pb.Mp4FileInputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_Mp4FileInputMessage(arg) {
+  if (!(arg instanceof media_pb.Mp4FileInputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.Mp4FileInputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_Mp4FileInputMessage(buffer_arg) {
+  return media_pb.Mp4FileInputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_Mp4FileOutputEvent(arg) {
+  if (!(arg instanceof media_pb.Mp4FileOutputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.Mp4FileOutputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_Mp4FileOutputEvent(buffer_arg) {
+  return media_pb.Mp4FileOutputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_Mp4FileOutputMessage(arg) {
+  if (!(arg instanceof media_pb.Mp4FileOutputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.Mp4FileOutputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_Mp4FileOutputMessage(buffer_arg) {
+  return media_pb.Mp4FileOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_NorskStatusEvent(arg) {
+  if (!(arg instanceof media_pb.NorskStatusEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.NorskStatusEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_NorskStatusEvent(buffer_arg) {
+  return media_pb.NorskStatusEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_RtmpInputEvent(arg) {
+  if (!(arg instanceof media_pb.RtmpInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.RtmpInputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_RtmpInputEvent(buffer_arg) {
+  return media_pb.RtmpInputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_RtmpInputMessage(arg) {
+  if (!(arg instanceof media_pb.RtmpInputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.RtmpInputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_RtmpInputMessage(buffer_arg) {
+  return media_pb.RtmpInputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_RtmpOutputEvent(arg) {
+  if (!(arg instanceof media_pb.RtmpOutputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.RtmpOutputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_RtmpOutputEvent(buffer_arg) {
+  return media_pb.RtmpOutputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_RtmpOutputMessage(arg) {
+  if (!(arg instanceof media_pb.RtmpOutputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.RtmpOutputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_RtmpOutputMessage(buffer_arg) {
+  return media_pb.RtmpOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_RtpInputEvent(arg) {
+  if (!(arg instanceof media_pb.RtpInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.RtpInputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_RtpInputEvent(buffer_arg) {
+  return media_pb.RtpInputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_RtpInputMessage(arg) {
+  if (!(arg instanceof media_pb.RtpInputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.RtpInputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_RtpInputMessage(buffer_arg) {
+  return media_pb.RtpInputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_SmoothSwitcherEvent(arg) {
+  if (!(arg instanceof media_pb.SmoothSwitcherEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.SmoothSwitcherEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_SmoothSwitcherEvent(buffer_arg) {
+  return media_pb.SmoothSwitcherEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_SmoothSwitcherMessage(arg) {
+  if (!(arg instanceof media_pb.SmoothSwitcherMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.SmoothSwitcherMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_SmoothSwitcherMessage(buffer_arg) {
+  return media_pb.SmoothSwitcherMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_SrtInputEvent(arg) {
+  if (!(arg instanceof media_pb.SrtInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.SrtInputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_SrtInputEvent(buffer_arg) {
+  return media_pb.SrtInputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_SrtInputMessage(arg) {
+  if (!(arg instanceof media_pb.SrtInputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.SrtInputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_SrtInputMessage(buffer_arg) {
+  return media_pb.SrtInputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_SrtOutputEvent(arg) {
+  if (!(arg instanceof media_pb.SrtOutputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.SrtOutputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_SrtOutputEvent(buffer_arg) {
+  return media_pb.SrtOutputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_SrtOutputMessage(arg) {
+  if (!(arg instanceof media_pb.SrtOutputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.SrtOutputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_SrtOutputMessage(buffer_arg) {
+  return media_pb.SrtOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_StreamKeyOverrideEvent(arg) {
+  if (!(arg instanceof media_pb.StreamKeyOverrideEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamKeyOverrideEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_StreamKeyOverrideEvent(buffer_arg) {
+  return media_pb.StreamKeyOverrideEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_StreamKeyOverrideMessage(arg) {
+  if (!(arg instanceof media_pb.StreamKeyOverrideMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamKeyOverrideMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_StreamKeyOverrideMessage(buffer_arg) {
+  return media_pb.StreamKeyOverrideMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_StreamStatsEvent(arg) {
+  if (!(arg instanceof media_pb.StreamStatsEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamStatsEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_StreamStatsEvent(buffer_arg) {
+  return media_pb.StreamStatsEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_StreamStatsMessage(arg) {
+  if (!(arg instanceof media_pb.StreamStatsMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamStatsMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_StreamStatsMessage(buffer_arg) {
+  return media_pb.StreamStatsMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_SyncEvent(arg) {
+  if (!(arg instanceof media_pb.SyncEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.SyncEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_SyncEvent(buffer_arg) {
+  return media_pb.SyncEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_SyncMessage(arg) {
+  if (!(arg instanceof media_pb.SyncMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.SyncMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_SyncMessage(buffer_arg) {
+  return media_pb.SyncMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_TestCardVideoGeneratorEvent(arg) {
+  if (!(arg instanceof media_pb.TestCardVideoGeneratorEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.TestCardVideoGeneratorEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_TestCardVideoGeneratorEvent(buffer_arg) {
+  return media_pb.TestCardVideoGeneratorEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_TestCardVideoGeneratorMessage(arg) {
+  if (!(arg instanceof media_pb.TestCardVideoGeneratorMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.TestCardVideoGeneratorMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_TestCardVideoGeneratorMessage(buffer_arg) {
+  return media_pb.TestCardVideoGeneratorMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_TimestampNudgerEvent(arg) {
+  if (!(arg instanceof media_pb.TimestampNudgerEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.TimestampNudgerEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_TimestampNudgerEvent(buffer_arg) {
+  return media_pb.TimestampNudgerEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_TimestampNudgerMessage(arg) {
+  if (!(arg instanceof media_pb.TimestampNudgerMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.TimestampNudgerMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_TimestampNudgerMessage(buffer_arg) {
+  return media_pb.TimestampNudgerMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_TsFileInputMessage(arg) {
+  if (!(arg instanceof media_pb.TsFileInputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.TsFileInputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_TsFileInputMessage(buffer_arg) {
+  return media_pb.TsFileInputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_TsFileOutputEvent(arg) {
+  if (!(arg instanceof media_pb.TsFileOutputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.TsFileOutputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_TsFileOutputEvent(buffer_arg) {
+  return media_pb.TsFileOutputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_TsFileOutputMessage(arg) {
+  if (!(arg instanceof media_pb.TsFileOutputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.TsFileOutputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_TsFileOutputMessage(buffer_arg) {
+  return media_pb.TsFileOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_TsInputEvent(arg) {
+  if (!(arg instanceof media_pb.TsInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.TsInputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_TsInputEvent(buffer_arg) {
+  return media_pb.TsInputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_TsUdpOutputEvent(arg) {
+  if (!(arg instanceof media_pb.TsUdpOutputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.TsUdpOutputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_TsUdpOutputEvent(buffer_arg) {
+  return media_pb.TsUdpOutputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_TsUdpOutputMessage(arg) {
+  if (!(arg instanceof media_pb.TsUdpOutputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.TsUdpOutputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_TsUdpOutputMessage(buffer_arg) {
+  return media_pb.TsUdpOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_UdpTsInputMessage(arg) {
+  if (!(arg instanceof media_pb.UdpTsInputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.UdpTsInputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_UdpTsInputMessage(buffer_arg) {
+  return media_pb.UdpTsInputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_ValidationResponse(arg) {
+  if (!(arg instanceof media_pb.ValidationResponse)) {
+    throw new Error('Expected argument of type norsk.api.media.ValidationResponse');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_ValidationResponse(buffer_arg) {
+  return media_pb.ValidationResponse.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_ValidationResponseAck(arg) {
+  if (!(arg instanceof media_pb.ValidationResponseAck)) {
+    throw new Error('Expected argument of type norsk.api.media.ValidationResponseAck');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_ValidationResponseAck(buffer_arg) {
+  return media_pb.ValidationResponseAck.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_VideoEncodeLadderEvent(arg) {
+  if (!(arg instanceof media_pb.VideoEncodeLadderEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.VideoEncodeLadderEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_VideoEncodeLadderEvent(buffer_arg) {
+  return media_pb.VideoEncodeLadderEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_VideoEncodeLadderMessage(arg) {
+  if (!(arg instanceof media_pb.VideoEncodeLadderMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.VideoEncodeLadderMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_VideoEncodeLadderMessage(buffer_arg) {
+  return media_pb.VideoEncodeLadderMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_VideoTransformEvent(arg) {
+  if (!(arg instanceof media_pb.VideoTransformEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.VideoTransformEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_VideoTransformEvent(buffer_arg) {
+  return media_pb.VideoTransformEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_VideoTransformMessage(arg) {
+  if (!(arg instanceof media_pb.VideoTransformMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.VideoTransformMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_VideoTransformMessage(buffer_arg) {
+  return media_pb.VideoTransformMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_WebRTCBrowserDuplexEvent(arg) {
+  if (!(arg instanceof media_pb.WebRTCBrowserDuplexEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.WebRTCBrowserDuplexEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_WebRTCBrowserDuplexEvent(buffer_arg) {
+  return media_pb.WebRTCBrowserDuplexEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_WebRTCLocalOutputMessage(arg) {
+  if (!(arg instanceof media_pb.WebRTCLocalOutputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.WebRTCLocalOutputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_WebRTCLocalOutputMessage(buffer_arg) {
+  return media_pb.WebRTCLocalOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_WebRTCWhipOutputEvent(arg) {
+  if (!(arg instanceof media_pb.WebRTCWhipOutputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.WebRTCWhipOutputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_WebRTCWhipOutputEvent(buffer_arg) {
+  return media_pb.WebRTCWhipOutputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_WebRTCWhipOutputMessage(arg) {
+  if (!(arg instanceof media_pb.WebRTCWhipOutputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.WebRTCWhipOutputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_WebRTCWhipOutputMessage(buffer_arg) {
+  return media_pb.WebRTCWhipOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_WebVttFileInputConfiguration(arg) {
+  if (!(arg instanceof media_pb.WebVttFileInputConfiguration)) {
+    throw new Error('Expected argument of type norsk.api.media.WebVttFileInputConfiguration');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_WebVttFileInputConfiguration(buffer_arg) {
+  return media_pb.WebVttFileInputConfiguration.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_WebVttFileInputEvent(arg) {
+  if (!(arg instanceof media_pb.WebVttFileInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.WebVttFileInputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_WebVttFileInputEvent(buffer_arg) {
+  return media_pb.WebVttFileInputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_WhipInputEvent(arg) {
+  if (!(arg instanceof media_pb.WhipInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.WhipInputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_WhipInputEvent(buffer_arg) {
+  return media_pb.WhipInputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_WhipInputMessage(arg) {
+  if (!(arg instanceof media_pb.WhipInputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.WhipInputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_WhipInputMessage(buffer_arg) {
+  return media_pb.WhipInputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+
+var MediaService = exports.MediaService = {
+  createStatusChannel: {
+    path: '/norsk.api.media.Media/CreateStatusChannel',
+    requestStream: false,
+    responseStream: true,
+    requestType: google_protobuf_empty_pb.Empty,
+    responseType: media_pb.NorskStatusEvent,
+    requestSerialize: serialize_google_protobuf_Empty,
+    requestDeserialize: deserialize_google_protobuf_Empty,
+    responseSerialize: serialize_norsk_api_media_NorskStatusEvent,
+    responseDeserialize: deserialize_norsk_api_media_NorskStatusEvent,
+  },
+  createWebVttFileInput: {
+    path: '/norsk.api.media.Media/CreateWebVttFileInput',
+    requestStream: false,
+    responseStream: true,
+    requestType: media_pb.WebVttFileInputConfiguration,
+    responseType: media_pb.WebVttFileInputEvent,
+    requestSerialize: serialize_norsk_api_media_WebVttFileInputConfiguration,
+    requestDeserialize: deserialize_norsk_api_media_WebVttFileInputConfiguration,
+    responseSerialize: serialize_norsk_api_media_WebVttFileInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_WebVttFileInputEvent,
+  },
+  // *
+// Creates an RTMP ingest Media Node.  On creation, the Media Node is idle
+// and your code <b>must</b> send an <ref>RtmpInputConfiguration</ref>
+// message to configure the RTMP server.  When a remote client connects, an
+// <ref>RtmpConnection</ref> message is sent, which the code can choose to
+// accept &ndash; by sending an <ref>RtmpConnectionAccept</ref> message or
+// reject &ndash; by sending an <ref>RtmpConnectionReject</ref> message.
+// Once a connection is established, Norsk will continue to send appropriate
+// <ref>RtmpInputEvent</ref> messages as events occur.
+createRtmpInput: {
+    path: '/norsk.api.media.Media/CreateRtmpInput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.RtmpInputMessage,
+    responseType: media_pb.RtmpInputEvent,
+    requestSerialize: serialize_norsk_api_media_RtmpInputMessage,
+    requestDeserialize: deserialize_norsk_api_media_RtmpInputMessage,
+    responseSerialize: serialize_norsk_api_media_RtmpInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_RtmpInputEvent,
+  },
+  createTsFileInput: {
+    path: '/norsk.api.media.Media/CreateTsFileInput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.TsFileInputMessage,
+    responseType: media_pb.TsInputEvent,
+    requestSerialize: serialize_norsk_api_media_TsFileInputMessage,
+    requestDeserialize: deserialize_norsk_api_media_TsFileInputMessage,
+    responseSerialize: serialize_norsk_api_media_TsInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_TsInputEvent,
+  },
+  createTestCardVideoGenerator: {
+    path: '/norsk.api.media.Media/CreateTestCardVideoGenerator',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.TestCardVideoGeneratorMessage,
+    responseType: media_pb.TestCardVideoGeneratorEvent,
+    requestSerialize: serialize_norsk_api_media_TestCardVideoGeneratorMessage,
+    requestDeserialize: deserialize_norsk_api_media_TestCardVideoGeneratorMessage,
+    responseSerialize: serialize_norsk_api_media_TestCardVideoGeneratorEvent,
+    responseDeserialize: deserialize_norsk_api_media_TestCardVideoGeneratorEvent,
+  },
+  createDeckLinkInput: {
+    path: '/norsk.api.media.Media/CreateDeckLinkInput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.DeckLinkInputMessage,
+    responseType: media_pb.DeckLinkInputEvent,
+    requestSerialize: serialize_norsk_api_media_DeckLinkInputMessage,
+    requestDeserialize: deserialize_norsk_api_media_DeckLinkInputMessage,
+    responseSerialize: serialize_norsk_api_media_DeckLinkInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_DeckLinkInputEvent,
+  },
+  // *
+// Creates a video source from a static image file on disk (e.g. PNG, JPEG)
+createImageFileInput: {
+    path: '/norsk.api.media.Media/CreateImageFileInput',
+    requestStream: false,
+    responseStream: true,
+    requestType: media_pb.ImageFileInputConfiguration,
+    responseType: media_pb.ImageFileInputEvent,
+    requestSerialize: serialize_norsk_api_media_ImageFileInputConfiguration,
+    requestDeserialize: deserialize_norsk_api_media_ImageFileInputConfiguration,
+    responseSerialize: serialize_norsk_api_media_ImageFileInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_ImageFileInputEvent,
+  },
+  // *
+// Creates a video source from a Mp4 file on disk
+createMp4FileInput: {
+    path: '/norsk.api.media.Media/CreateMp4FileInput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.Mp4FileInputMessage,
+    responseType: media_pb.Mp4FileInputEvent,
+    requestSerialize: serialize_norsk_api_media_Mp4FileInputMessage,
+    requestDeserialize: deserialize_norsk_api_media_Mp4FileInputMessage,
+    responseSerialize: serialize_norsk_api_media_Mp4FileInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_Mp4FileInputEvent,
+  },
+  createAudioSignalGenerator: {
+    path: '/norsk.api.media.Media/CreateAudioSignalGenerator',
+    requestStream: false,
+    responseStream: true,
+    requestType: media_pb.AudioSignalGeneratorConfiguration,
+    responseType: media_pb.AudioSignalGeneratorEvent,
+    requestSerialize: serialize_norsk_api_media_AudioSignalGeneratorConfiguration,
+    requestDeserialize: deserialize_norsk_api_media_AudioSignalGeneratorConfiguration,
+    responseSerialize: serialize_norsk_api_media_AudioSignalGeneratorEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioSignalGeneratorEvent,
+  },
+  createBrowserInput: {
+    path: '/norsk.api.media.Media/CreateBrowserInput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.BrowserInputMessage,
+    responseType: media_pb.BrowserInputEvent,
+    requestSerialize: serialize_norsk_api_media_BrowserInputMessage,
+    requestDeserialize: deserialize_norsk_api_media_BrowserInputMessage,
+    responseSerialize: serialize_norsk_api_media_BrowserInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_BrowserInputEvent,
+  },
+  createWhipInput: {
+    path: '/norsk.api.media.Media/CreateWhipInput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.WhipInputMessage,
+    responseType: media_pb.WhipInputEvent,
+    requestSerialize: serialize_norsk_api_media_WhipInputMessage,
+    requestDeserialize: deserialize_norsk_api_media_WhipInputMessage,
+    responseSerialize: serialize_norsk_api_media_WhipInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_WhipInputEvent,
+  },
+  createSrtInput: {
+    path: '/norsk.api.media.Media/CreateSrtInput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.SrtInputMessage,
+    responseType: media_pb.SrtInputEvent,
+    requestSerialize: serialize_norsk_api_media_SrtInputMessage,
+    requestDeserialize: deserialize_norsk_api_media_SrtInputMessage,
+    responseSerialize: serialize_norsk_api_media_SrtInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_SrtInputEvent,
+  },
+  createUdpTsInput: {
+    path: '/norsk.api.media.Media/CreateUdpTsInput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.UdpTsInputMessage,
+    responseType: media_pb.TsInputEvent,
+    requestSerialize: serialize_norsk_api_media_UdpTsInputMessage,
+    requestDeserialize: deserialize_norsk_api_media_UdpTsInputMessage,
+    responseSerialize: serialize_norsk_api_media_TsInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_TsInputEvent,
+  },
+  createM3u8MediaInput: {
+    path: '/norsk.api.media.Media/CreateM3u8MediaInput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.M3u8MediaInputMessage,
+    responseType: media_pb.TsInputEvent,
+    requestSerialize: serialize_norsk_api_media_M3u8MediaInputMessage,
+    requestDeserialize: deserialize_norsk_api_media_M3u8MediaInputMessage,
+    responseSerialize: serialize_norsk_api_media_TsInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_TsInputEvent,
+  },
+  createTimestampNudger: {
+    path: '/norsk.api.media.Media/CreateTimestampNudger',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.TimestampNudgerMessage,
+    responseType: media_pb.TimestampNudgerEvent,
+    requestSerialize: serialize_norsk_api_media_TimestampNudgerMessage,
+    requestDeserialize: deserialize_norsk_api_media_TimestampNudgerMessage,
+    responseSerialize: serialize_norsk_api_media_TimestampNudgerEvent,
+    responseDeserialize: deserialize_norsk_api_media_TimestampNudgerEvent,
+  },
+  createVideoEncodeLadder: {
+    path: '/norsk.api.media.Media/CreateVideoEncodeLadder',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.VideoEncodeLadderMessage,
+    responseType: media_pb.VideoEncodeLadderEvent,
+    requestSerialize: serialize_norsk_api_media_VideoEncodeLadderMessage,
+    requestDeserialize: deserialize_norsk_api_media_VideoEncodeLadderMessage,
+    responseSerialize: serialize_norsk_api_media_VideoEncodeLadderEvent,
+    responseDeserialize: deserialize_norsk_api_media_VideoEncodeLadderEvent,
+  },
+  createVideoTransform: {
+    path: '/norsk.api.media.Media/CreateVideoTransform',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.VideoTransformMessage,
+    responseType: media_pb.VideoTransformEvent,
+    requestSerialize: serialize_norsk_api_media_VideoTransformMessage,
+    requestDeserialize: deserialize_norsk_api_media_VideoTransformMessage,
+    responseSerialize: serialize_norsk_api_media_VideoTransformEvent,
+    responseDeserialize: deserialize_norsk_api_media_VideoTransformEvent,
+  },
+  createChaosMonkey: {
+    path: '/norsk.api.media.Media/CreateChaosMonkey',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.ChaosMonkeyMessage,
+    responseType: media_pb.ChaosMonkeyEvent,
+    requestSerialize: serialize_norsk_api_media_ChaosMonkeyMessage,
+    requestDeserialize: deserialize_norsk_api_media_ChaosMonkeyMessage,
+    responseSerialize: serialize_norsk_api_media_ChaosMonkeyEvent,
+    responseDeserialize: deserialize_norsk_api_media_ChaosMonkeyEvent,
+  },
+  createAudioEncoder: {
+    path: '/norsk.api.media.Media/CreateAudioEncoder',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.AudioEncoderMessage,
+    responseType: media_pb.AudioEncoderEvent,
+    requestSerialize: serialize_norsk_api_media_AudioEncoderMessage,
+    requestDeserialize: deserialize_norsk_api_media_AudioEncoderMessage,
+    responseSerialize: serialize_norsk_api_media_AudioEncoderEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioEncoderEvent,
+  },
+  // *
+// Create a Media Node composing multiple sources into one, eg to construct
+// overlays, picture-in-picture or split-screen video.
+// <br/><br/>
+// Individual sources may be cropped or scaled as part of this process
+createComposeVideo: {
+    path: '/norsk.api.media.Media/CreateComposeVideo',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.ComposeVideoMessage,
+    responseType: media_pb.ComposeVideoSourceEvent,
+    requestSerialize: serialize_norsk_api_media_ComposeVideoMessage,
+    requestDeserialize: deserialize_norsk_api_media_ComposeVideoMessage,
+    responseSerialize: serialize_norsk_api_media_ComposeVideoSourceEvent,
+    responseDeserialize: deserialize_norsk_api_media_ComposeVideoSourceEvent,
+  },
+  createAudioMixer: {
+    path: '/norsk.api.media.Media/CreateAudioMixer',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.AudioMixerMessage,
+    responseType: media_pb.AudioMixerEvent,
+    requestSerialize: serialize_norsk_api_media_AudioMixerMessage,
+    requestDeserialize: deserialize_norsk_api_media_AudioMixerMessage,
+    responseSerialize: serialize_norsk_api_media_AudioMixerEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioMixerEvent,
+  },
+  createAudioMatrixMixer: {
+    path: '/norsk.api.media.Media/CreateAudioMatrixMixer',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.AudioMatrixMixerMessage,
+    responseType: media_pb.AudioMatrixMixerEvent,
+    requestSerialize: serialize_norsk_api_media_AudioMatrixMixerMessage,
+    requestDeserialize: deserialize_norsk_api_media_AudioMatrixMixerMessage,
+    responseSerialize: serialize_norsk_api_media_AudioMatrixMixerEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioMatrixMixerEvent,
+  },
+  createAudioGain: {
+    path: '/norsk.api.media.Media/CreateAudioGain',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.AudioGainMessage,
+    responseType: media_pb.AudioGainEvent,
+    requestSerialize: serialize_norsk_api_media_AudioGainMessage,
+    requestDeserialize: deserialize_norsk_api_media_AudioGainMessage,
+    responseSerialize: serialize_norsk_api_media_AudioGainEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioGainEvent,
+  },
+  createAudioBuildMultichannel: {
+    path: '/norsk.api.media.Media/CreateAudioBuildMultichannel',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.AudioBuildMultichannelMessage,
+    responseType: media_pb.AudioBuildMultichannelEvent,
+    requestSerialize: serialize_norsk_api_media_AudioBuildMultichannelMessage,
+    requestDeserialize: deserialize_norsk_api_media_AudioBuildMultichannelMessage,
+    responseSerialize: serialize_norsk_api_media_AudioBuildMultichannelEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioBuildMultichannelEvent,
+  },
+  createAudioSplitMultichannel: {
+    path: '/norsk.api.media.Media/CreateAudioSplitMultichannel',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.AudioSplitMultichannelMessage,
+    responseType: media_pb.AudioSplitMultichannelEvent,
+    requestSerialize: serialize_norsk_api_media_AudioSplitMultichannelMessage,
+    requestDeserialize: deserialize_norsk_api_media_AudioSplitMultichannelMessage,
+    responseSerialize: serialize_norsk_api_media_AudioSplitMultichannelEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioSplitMultichannelEvent,
+  },
+  // *
+// Create a Media Node performing transcription into subtitles using the
+// Amazon Transcribe AWS service.
+createAwsTranscribe: {
+    path: '/norsk.api.media.Media/CreateAwsTranscribe',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.AwsTranscribeMessage,
+    responseType: media_pb.AwsTranscribeEvent,
+    requestSerialize: serialize_norsk_api_media_AwsTranscribeMessage,
+    requestDeserialize: deserialize_norsk_api_media_AwsTranscribeMessage,
+    responseSerialize: serialize_norsk_api_media_AwsTranscribeEvent,
+    responseDeserialize: deserialize_norsk_api_media_AwsTranscribeEvent,
+  },
+  createHlsVideoOutput: {
+    path: '/norsk.api.media.Media/CreateHlsVideoOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.HlsVideoMessage,
+    responseType: media_pb.HlsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_HlsVideoMessage,
+    requestDeserialize: deserialize_norsk_api_media_HlsVideoMessage,
+    responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
+  },
+  createHlsTsVideoOutput: {
+    path: '/norsk.api.media.Media/CreateHlsTsVideoOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.HlsTsVideoMessage,
+    responseType: media_pb.HlsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_HlsTsVideoMessage,
+    requestDeserialize: deserialize_norsk_api_media_HlsTsVideoMessage,
+    responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
+  },
+  createHlsTsVideoPushOutput: {
+    path: '/norsk.api.media.Media/CreateHlsTsVideoPushOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.HlsTsVideoPushMessage,
+    responseType: media_pb.HlsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_HlsTsVideoPushMessage,
+    requestDeserialize: deserialize_norsk_api_media_HlsTsVideoPushMessage,
+    responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
+  },
+  createHlsAudioOutput: {
+    path: '/norsk.api.media.Media/CreateHlsAudioOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.HlsAudioMessage,
+    responseType: media_pb.HlsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_HlsAudioMessage,
+    requestDeserialize: deserialize_norsk_api_media_HlsAudioMessage,
+    responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
+  },
+  createHlsTsAudioOutput: {
+    path: '/norsk.api.media.Media/CreateHlsTsAudioOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.HlsTsAudioMessage,
+    responseType: media_pb.HlsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_HlsTsAudioMessage,
+    requestDeserialize: deserialize_norsk_api_media_HlsTsAudioMessage,
+    responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
+  },
+  createHlsWebVttOutput: {
+    path: '/norsk.api.media.Media/CreateHlsWebVttOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.HlsWebVttMessage,
+    responseType: media_pb.HlsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_HlsWebVttMessage,
+    requestDeserialize: deserialize_norsk_api_media_HlsWebVttMessage,
+    responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
+  },
+  createHlsWebVttPushOutput: {
+    path: '/norsk.api.media.Media/CreateHlsWebVttPushOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.HlsWebVttPushMessage,
+    responseType: media_pb.HlsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_HlsWebVttPushMessage,
+    requestDeserialize: deserialize_norsk_api_media_HlsWebVttPushMessage,
+    responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
+  },
+  createHlsTsAudioPushOutput: {
+    path: '/norsk.api.media.Media/CreateHlsTsAudioPushOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.HlsTsAudioPushMessage,
+    responseType: media_pb.HlsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_HlsTsAudioPushMessage,
+    requestDeserialize: deserialize_norsk_api_media_HlsTsAudioPushMessage,
+    responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
+  },
+  createHlsTsCombinedPushOutput: {
+    path: '/norsk.api.media.Media/CreateHlsTsCombinedPushOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.HlsTsCombinedPushMessage,
+    responseType: media_pb.HlsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_HlsTsCombinedPushMessage,
+    requestDeserialize: deserialize_norsk_api_media_HlsTsCombinedPushMessage,
+    responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
+  },
+  createHlsMasterOutput: {
+    path: '/norsk.api.media.Media/CreateHlsMasterOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.HlsMasterMessage,
+    responseType: media_pb.HlsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_HlsMasterMessage,
+    requestDeserialize: deserialize_norsk_api_media_HlsMasterMessage,
+    responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
+  },
+  createHlsMasterPushOutput: {
+    path: '/norsk.api.media.Media/CreateHlsMasterPushOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.HlsMasterPushMessage,
+    responseType: media_pb.HlsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_HlsMasterPushMessage,
+    requestDeserialize: deserialize_norsk_api_media_HlsMasterPushMessage,
+    responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
+  },
+  createLocalWebRTCOutput: {
+    path: '/norsk.api.media.Media/CreateLocalWebRTCOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.WebRTCLocalOutputMessage,
+    responseType: media_pb.WebRTCBrowserDuplexEvent,
+    requestSerialize: serialize_norsk_api_media_WebRTCLocalOutputMessage,
+    requestDeserialize: deserialize_norsk_api_media_WebRTCLocalOutputMessage,
+    responseSerialize: serialize_norsk_api_media_WebRTCBrowserDuplexEvent,
+    responseDeserialize: deserialize_norsk_api_media_WebRTCBrowserDuplexEvent,
+  },
+  createWebRTCWhipOutput: {
+    path: '/norsk.api.media.Media/CreateWebRTCWhipOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.WebRTCWhipOutputMessage,
+    responseType: media_pb.WebRTCWhipOutputEvent,
+    requestSerialize: serialize_norsk_api_media_WebRTCWhipOutputMessage,
+    requestDeserialize: deserialize_norsk_api_media_WebRTCWhipOutputMessage,
+    responseSerialize: serialize_norsk_api_media_WebRTCWhipOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_WebRTCWhipOutputEvent,
+  },
+  createTsUdpOutput: {
+    path: '/norsk.api.media.Media/CreateTsUdpOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.TsUdpOutputMessage,
+    responseType: media_pb.TsUdpOutputEvent,
+    requestSerialize: serialize_norsk_api_media_TsUdpOutputMessage,
+    requestDeserialize: deserialize_norsk_api_media_TsUdpOutputMessage,
+    responseSerialize: serialize_norsk_api_media_TsUdpOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_TsUdpOutputEvent,
+  },
+  createSrtOutput: {
+    path: '/norsk.api.media.Media/CreateSrtOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.SrtOutputMessage,
+    responseType: media_pb.SrtOutputEvent,
+    requestSerialize: serialize_norsk_api_media_SrtOutputMessage,
+    requestDeserialize: deserialize_norsk_api_media_SrtOutputMessage,
+    responseSerialize: serialize_norsk_api_media_SrtOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_SrtOutputEvent,
+  },
+  createRtmpOutput: {
+    path: '/norsk.api.media.Media/CreateRtmpOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.RtmpOutputMessage,
+    responseType: media_pb.RtmpOutputEvent,
+    requestSerialize: serialize_norsk_api_media_RtmpOutputMessage,
+    requestDeserialize: deserialize_norsk_api_media_RtmpOutputMessage,
+    responseSerialize: serialize_norsk_api_media_RtmpOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_RtmpOutputEvent,
+  },
+  createTsFileOutput: {
+    path: '/norsk.api.media.Media/CreateTsFileOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.TsFileOutputMessage,
+    responseType: media_pb.TsFileOutputEvent,
+    requestSerialize: serialize_norsk_api_media_TsFileOutputMessage,
+    requestDeserialize: deserialize_norsk_api_media_TsFileOutputMessage,
+    responseSerialize: serialize_norsk_api_media_TsFileOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_TsFileOutputEvent,
+  },
+  createMp4FileOutput: {
+    path: '/norsk.api.media.Media/CreateMp4FileOutput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.Mp4FileOutputMessage,
+    responseType: media_pb.Mp4FileOutputEvent,
+    requestSerialize: serialize_norsk_api_media_Mp4FileOutputMessage,
+    requestDeserialize: deserialize_norsk_api_media_Mp4FileOutputMessage,
+    responseSerialize: serialize_norsk_api_media_Mp4FileOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_Mp4FileOutputEvent,
+  },
+  createHardSwitcher: {
+    path: '/norsk.api.media.Media/CreateHardSwitcher',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.HardSwitcherMessage,
+    responseType: media_pb.HardSwitcherEvent,
+    requestSerialize: serialize_norsk_api_media_HardSwitcherMessage,
+    requestDeserialize: deserialize_norsk_api_media_HardSwitcherMessage,
+    responseSerialize: serialize_norsk_api_media_HardSwitcherEvent,
+    responseDeserialize: deserialize_norsk_api_media_HardSwitcherEvent,
+  },
+  createSmoothSwitcher: {
+    path: '/norsk.api.media.Media/CreateSmoothSwitcher',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.SmoothSwitcherMessage,
+    responseType: media_pb.SmoothSwitcherEvent,
+    requestSerialize: serialize_norsk_api_media_SmoothSwitcherMessage,
+    requestDeserialize: deserialize_norsk_api_media_SmoothSwitcherMessage,
+    responseSerialize: serialize_norsk_api_media_SmoothSwitcherEvent,
+    responseDeserialize: deserialize_norsk_api_media_SmoothSwitcherEvent,
+  },
+  createStreamKeyOverride: {
+    path: '/norsk.api.media.Media/CreateStreamKeyOverride',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.StreamKeyOverrideMessage,
+    responseType: media_pb.StreamKeyOverrideEvent,
+    requestSerialize: serialize_norsk_api_media_StreamKeyOverrideMessage,
+    requestDeserialize: deserialize_norsk_api_media_StreamKeyOverrideMessage,
+    responseSerialize: serialize_norsk_api_media_StreamKeyOverrideEvent,
+    responseDeserialize: deserialize_norsk_api_media_StreamKeyOverrideEvent,
+  },
+  createMetadataOverride: {
+    path: '/norsk.api.media.Media/CreateMetadataOverride',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.MetadataOverrideMessage,
+    responseType: media_pb.MetadataOverrideEvent,
+    requestSerialize: serialize_norsk_api_media_MetadataOverrideMessage,
+    requestDeserialize: deserialize_norsk_api_media_MetadataOverrideMessage,
+    responseSerialize: serialize_norsk_api_media_MetadataOverrideEvent,
+    responseDeserialize: deserialize_norsk_api_media_MetadataOverrideEvent,
+  },
+  createSync: {
+    path: '/norsk.api.media.Media/CreateSync',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.SyncMessage,
+    responseType: media_pb.SyncEvent,
+    requestSerialize: serialize_norsk_api_media_SyncMessage,
+    requestDeserialize: deserialize_norsk_api_media_SyncMessage,
+    responseSerialize: serialize_norsk_api_media_SyncEvent,
+    responseDeserialize: deserialize_norsk_api_media_SyncEvent,
+  },
+  createStreamStats: {
+    path: '/norsk.api.media.Media/CreateStreamStats',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.StreamStatsMessage,
+    responseType: media_pb.StreamStatsEvent,
+    requestSerialize: serialize_norsk_api_media_StreamStatsMessage,
+    requestDeserialize: deserialize_norsk_api_media_StreamStatsMessage,
+    responseSerialize: serialize_norsk_api_media_StreamStatsEvent,
+    responseDeserialize: deserialize_norsk_api_media_StreamStatsEvent,
+  },
+  createAudioLevels: {
+    path: '/norsk.api.media.Media/CreateAudioLevels',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.AudioLevelsMessage,
+    responseType: media_pb.AudioLevelsEvent,
+    requestSerialize: serialize_norsk_api_media_AudioLevelsMessage,
+    requestDeserialize: deserialize_norsk_api_media_AudioLevelsMessage,
+    responseSerialize: serialize_norsk_api_media_AudioLevelsEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioLevelsEvent,
+  },
+  createRtpInput: {
+    path: '/norsk.api.media.Media/CreateRtpInput',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.RtpInputMessage,
+    responseType: media_pb.RtpInputEvent,
+    requestSerialize: serialize_norsk_api_media_RtpInputMessage,
+    requestDeserialize: deserialize_norsk_api_media_RtpInputMessage,
+    responseSerialize: serialize_norsk_api_media_RtpInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_RtpInputEvent,
+  },
+  hardwareInfo: {
+    path: '/norsk.api.media.Media/HardwareInfo',
+    requestStream: false,
+    responseStream: false,
+    requestType: google_protobuf_empty_pb.Empty,
+    responseType: media_pb.Hardware,
+    requestSerialize: serialize_google_protobuf_Empty,
+    requestDeserialize: deserialize_google_protobuf_Empty,
+    responseSerialize: serialize_norsk_api_media_Hardware,
+    responseDeserialize: deserialize_norsk_api_media_Hardware,
+  },
+  // rpc TimeInfo(google.protobuf.Empty) returns (TimeInfo) {};
+//
+enumDeckLinkDisplayModes: {
+    path: '/norsk.api.media.Media/EnumDeckLinkDisplayModes',
+    requestStream: false,
+    responseStream: false,
+    requestType: media_pb.DeckLinkCardIndex,
+    responseType: media_pb.DeckLinkDisplayModes,
+    requestSerialize: serialize_norsk_api_media_DeckLinkCardIndex,
+    requestDeserialize: deserialize_norsk_api_media_DeckLinkCardIndex,
+    responseSerialize: serialize_norsk_api_media_DeckLinkDisplayModes,
+    responseDeserialize: deserialize_norsk_api_media_DeckLinkDisplayModes,
+  },
+  unblockCall: {
+    path: '/norsk.api.media.Media/UnblockCall',
+    requestStream: false,
+    responseStream: false,
+    requestType: media_pb.BlockingCallRef,
+    responseType: google_protobuf_empty_pb.Empty,
+    requestSerialize: serialize_norsk_api_media_BlockingCallRef,
+    requestDeserialize: deserialize_norsk_api_media_BlockingCallRef,
+    responseSerialize: serialize_google_protobuf_Empty,
+    responseDeserialize: deserialize_google_protobuf_Empty,
+  },
+  sendValidationResponse: {
+    path: '/norsk.api.media.Media/SendValidationResponse',
+    requestStream: false,
+    responseStream: false,
+    requestType: media_pb.ValidationResponse,
+    responseType: media_pb.ValidationResponseAck,
+    requestSerialize: serialize_norsk_api_media_ValidationResponse,
+    requestDeserialize: deserialize_norsk_api_media_ValidationResponse,
+    responseSerialize: serialize_norsk_api_media_ValidationResponseAck,
+    responseDeserialize: deserialize_norsk_api_media_ValidationResponseAck,
+  },
+};
+
+exports.MediaClient = grpc.makeGenericClientConstructor(MediaService);