@norskvideo/norsk-api 0.0.330 → 1.0.331

package/lib/media_grpc_pb.js

@@ -40,26 +40,26 @@ 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');
+function serialize_norsk_api_media_AudioEncodeEvent(arg) {
+  if (!(arg instanceof media_pb.AudioEncodeEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioEncodeEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_AudioEncoderEvent(buffer_arg) {
-  return media_pb.AudioEncoderEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_AudioEncodeEvent(buffer_arg) {
+  return media_pb.AudioEncodeEvent.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');
+function serialize_norsk_api_media_AudioEncodeMessage(arg) {
+  if (!(arg instanceof media_pb.AudioEncodeMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioEncodeMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_AudioEncoderMessage(buffer_arg) {
-  return media_pb.AudioEncoderMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_AudioEncodeMessage(buffer_arg) {
+  return media_pb.AudioEncodeMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_norsk_api_media_AudioGainEvent(arg) {
@@ -84,70 +84,70 @@ 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');
+function serialize_norsk_api_media_AudioMeasureLevelsEvent(arg) {
+  if (!(arg instanceof media_pb.AudioMeasureLevelsEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioMeasureLevelsEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_AudioLevelsEvent(buffer_arg) {
-  return media_pb.AudioLevelsEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_AudioMeasureLevelsEvent(buffer_arg) {
+  return media_pb.AudioMeasureLevelsEvent.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');
+function serialize_norsk_api_media_AudioMeasureLevelsMessage(arg) {
+  if (!(arg instanceof media_pb.AudioMeasureLevelsMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioMeasureLevelsMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_AudioLevelsMessage(buffer_arg) {
-  return media_pb.AudioLevelsMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_AudioMeasureLevelsMessage(buffer_arg) {
+  return media_pb.AudioMeasureLevelsMessage.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');
+function serialize_norsk_api_media_AudioMixEvent(arg) {
+  if (!(arg instanceof media_pb.AudioMixEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioMixEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_AudioMatrixMixerEvent(buffer_arg) {
-  return media_pb.AudioMatrixMixerEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_AudioMixEvent(buffer_arg) {
+  return media_pb.AudioMixEvent.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');
+function serialize_norsk_api_media_AudioMixMatrixEvent(arg) {
+  if (!(arg instanceof media_pb.AudioMixMatrixEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioMixMatrixEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_AudioMatrixMixerMessage(buffer_arg) {
-  return media_pb.AudioMatrixMixerMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_AudioMixMatrixEvent(buffer_arg) {
+  return media_pb.AudioMixMatrixEvent.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');
+function serialize_norsk_api_media_AudioMixMatrixMessage(arg) {
+  if (!(arg instanceof media_pb.AudioMixMatrixMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioMixMatrixMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_AudioMixerEvent(buffer_arg) {
-  return media_pb.AudioMixerEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_AudioMixMatrixMessage(buffer_arg) {
+  return media_pb.AudioMixMatrixMessage.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');
+function serialize_norsk_api_media_AudioMixMessage(arg) {
+  if (!(arg instanceof media_pb.AudioMixMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioMixMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_AudioMixerMessage(buffer_arg) {
-  return media_pb.AudioMixerMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_AudioMixMessage(buffer_arg) {
+  return media_pb.AudioMixMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_norsk_api_media_AudioSignalGeneratorConfiguration(arg) {
@@ -194,26 +194,26 @@ 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');
+function serialize_norsk_api_media_AudioTranscribeAwsEvent(arg) {
+  if (!(arg instanceof media_pb.AudioTranscribeAwsEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioTranscribeAwsEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_AwsTranscribeEvent(buffer_arg) {
-  return media_pb.AwsTranscribeEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_AudioTranscribeAwsEvent(buffer_arg) {
+  return media_pb.AudioTranscribeAwsEvent.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');
+function serialize_norsk_api_media_AudioTranscribeAwsMessage(arg) {
+  if (!(arg instanceof media_pb.AudioTranscribeAwsMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.AudioTranscribeAwsMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_AwsTranscribeMessage(buffer_arg) {
-  return media_pb.AwsTranscribeMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_AudioTranscribeAwsMessage(buffer_arg) {
+  return media_pb.AudioTranscribeAwsMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_norsk_api_media_BlockingCallRef(arg) {
@@ -249,28 +249,6 @@ 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_CmafAudioMessage(arg) {
   if (!(arg instanceof media_pb.CmafAudioMessage)) {
     throw new Error('Expected argument of type norsk.api.media.CmafAudioMessage');
@@ -315,28 +293,6 @@ function deserialize_norsk_api_media_CmafWebVttMessage(buffer_arg) {
   return media_pb.CmafWebVttMessage.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');
@@ -381,26 +337,125 @@ 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');
+function serialize_norsk_api_media_FileImageInputConfiguration(arg) {
+  if (!(arg instanceof media_pb.FileImageInputConfiguration)) {
+    throw new Error('Expected argument of type norsk.api.media.FileImageInputConfiguration');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_FileImageInputConfiguration(buffer_arg) {
+  return media_pb.FileImageInputConfiguration.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_FileImageInputEvent(arg) {
+  if (!(arg instanceof media_pb.FileImageInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.FileImageInputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_FileImageInputEvent(buffer_arg) {
+  return media_pb.FileImageInputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_FileMp4InputEvent(arg) {
+  if (!(arg instanceof media_pb.FileMp4InputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.FileMp4InputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_FileMp4InputEvent(buffer_arg) {
+  return media_pb.FileMp4InputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_FileMp4InputMessage(arg) {
+  if (!(arg instanceof media_pb.FileMp4InputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.FileMp4InputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_FileMp4InputMessage(buffer_arg) {
+  return media_pb.FileMp4InputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_FileMp4OutputEvent(arg) {
+  if (!(arg instanceof media_pb.FileMp4OutputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.FileMp4OutputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_FileMp4OutputEvent(buffer_arg) {
+  return media_pb.FileMp4OutputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_FileMp4OutputMessage(arg) {
+  if (!(arg instanceof media_pb.FileMp4OutputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.FileMp4OutputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_FileMp4OutputMessage(buffer_arg) {
+  return media_pb.FileMp4OutputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_FileTsInputMessage(arg) {
+  if (!(arg instanceof media_pb.FileTsInputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.FileTsInputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_FileTsInputMessage(buffer_arg) {
+  return media_pb.FileTsInputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_FileTsOutputEvent(arg) {
+  if (!(arg instanceof media_pb.FileTsOutputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.FileTsOutputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_FileTsOutputEvent(buffer_arg) {
+  return media_pb.FileTsOutputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_FileTsOutputMessage(arg) {
+  if (!(arg instanceof media_pb.FileTsOutputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.FileTsOutputMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_HardSwitcherEvent(buffer_arg) {
-  return media_pb.HardSwitcherEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_FileTsOutputMessage(buffer_arg) {
+  return media_pb.FileTsOutputMessage.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');
+function serialize_norsk_api_media_FileWebVttInputConfiguration(arg) {
+  if (!(arg instanceof media_pb.FileWebVttInputConfiguration)) {
+    throw new Error('Expected argument of type norsk.api.media.FileWebVttInputConfiguration');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_HardSwitcherMessage(buffer_arg) {
-  return media_pb.HardSwitcherMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_FileWebVttInputConfiguration(buffer_arg) {
+  return media_pb.FileWebVttInputConfiguration.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_FileWebVttInputEvent(arg) {
+  if (!(arg instanceof media_pb.FileWebVttInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.FileWebVttInputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_FileWebVttInputEvent(buffer_arg) {
+  return media_pb.FileWebVttInputEvent.fromBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_norsk_api_media_Hardware(arg) {
@@ -502,28 +557,6 @@ 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');
@@ -535,72 +568,6 @@ 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');
@@ -612,28 +579,6 @@ 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');
@@ -656,48 +601,48 @@ 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');
+function serialize_norsk_api_media_RtmpServerInputEvent(arg) {
+  if (!(arg instanceof media_pb.RtmpServerInputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.RtmpServerInputEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_RtpInputEvent(buffer_arg) {
-  return media_pb.RtpInputEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_RtmpServerInputEvent(buffer_arg) {
+  return media_pb.RtmpServerInputEvent.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');
+function serialize_norsk_api_media_RtmpServerInputMessage(arg) {
+  if (!(arg instanceof media_pb.RtmpServerInputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.RtmpServerInputMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_RtpInputMessage(buffer_arg) {
-  return media_pb.RtpInputMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_RtmpServerInputMessage(buffer_arg) {
+  return media_pb.RtmpServerInputMessage.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');
+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_SmoothSwitcherEvent(buffer_arg) {
-  return media_pb.SmoothSwitcherEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_RtpInputEvent(buffer_arg) {
+  return media_pb.RtpInputEvent.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');
+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_SmoothSwitcherMessage(buffer_arg) {
-  return media_pb.SmoothSwitcherMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_RtpInputMessage(buffer_arg) {
+  return media_pb.RtpInputMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_norsk_api_media_SrtInputEvent(arg) {
@@ -744,6 +689,28 @@ function deserialize_norsk_api_media_SrtOutputMessage(buffer_arg) {
   return media_pb.SrtOutputMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_norsk_api_media_StreamChaosMonkeyEvent(arg) {
+  if (!(arg instanceof media_pb.StreamChaosMonkeyEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamChaosMonkeyEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_StreamChaosMonkeyEvent(buffer_arg) {
+  return media_pb.StreamChaosMonkeyEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_StreamChaosMonkeyMessage(arg) {
+  if (!(arg instanceof media_pb.StreamChaosMonkeyMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamChaosMonkeyMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_StreamChaosMonkeyMessage(buffer_arg) {
+  return media_pb.StreamChaosMonkeyMessage.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');
@@ -766,125 +733,136 @@ 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');
+function serialize_norsk_api_media_StreamMetadataOverrideEvent(arg) {
+  if (!(arg instanceof media_pb.StreamMetadataOverrideEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamMetadataOverrideEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_StreamStatsEvent(buffer_arg) {
-  return media_pb.StreamStatsEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_StreamMetadataOverrideEvent(buffer_arg) {
+  return media_pb.StreamMetadataOverrideEvent.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');
+function serialize_norsk_api_media_StreamMetadataOverrideMessage(arg) {
+  if (!(arg instanceof media_pb.StreamMetadataOverrideMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamMetadataOverrideMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_StreamStatsMessage(buffer_arg) {
-  return media_pb.StreamStatsMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_StreamMetadataOverrideMessage(buffer_arg) {
+  return media_pb.StreamMetadataOverrideMessage.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');
+function serialize_norsk_api_media_StreamStatisticsEvent(arg) {
+  if (!(arg instanceof media_pb.StreamStatisticsEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamStatisticsEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_SyncEvent(buffer_arg) {
-  return media_pb.SyncEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_StreamStatisticsEvent(buffer_arg) {
+  return media_pb.StreamStatisticsEvent.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');
+function serialize_norsk_api_media_StreamStatisticsMessage(arg) {
+  if (!(arg instanceof media_pb.StreamStatisticsMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamStatisticsMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_SyncMessage(buffer_arg) {
-  return media_pb.SyncMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_StreamStatisticsMessage(buffer_arg) {
+  return media_pb.StreamStatisticsMessage.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');
+function serialize_norsk_api_media_StreamSwitchHardEvent(arg) {
+  if (!(arg instanceof media_pb.StreamSwitchHardEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamSwitchHardEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_TestCardVideoGeneratorEvent(buffer_arg) {
-  return media_pb.TestCardVideoGeneratorEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_StreamSwitchHardEvent(buffer_arg) {
+  return media_pb.StreamSwitchHardEvent.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');
+function serialize_norsk_api_media_StreamSwitchHardMessage(arg) {
+  if (!(arg instanceof media_pb.StreamSwitchHardMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamSwitchHardMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_TestCardVideoGeneratorMessage(buffer_arg) {
-  return media_pb.TestCardVideoGeneratorMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_StreamSwitchHardMessage(buffer_arg) {
+  return media_pb.StreamSwitchHardMessage.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');
+function serialize_norsk_api_media_StreamSwitchSmoothEvent(arg) {
+  if (!(arg instanceof media_pb.StreamSwitchSmoothEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamSwitchSmoothEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_TimestampNudgerEvent(buffer_arg) {
-  return media_pb.TimestampNudgerEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_StreamSwitchSmoothEvent(buffer_arg) {
+  return media_pb.StreamSwitchSmoothEvent.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');
+function serialize_norsk_api_media_StreamSwitchSmoothMessage(arg) {
+  if (!(arg instanceof media_pb.StreamSwitchSmoothMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamSwitchSmoothMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_TimestampNudgerMessage(buffer_arg) {
-  return media_pb.TimestampNudgerMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_StreamSwitchSmoothMessage(buffer_arg) {
+  return media_pb.StreamSwitchSmoothMessage.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');
+function serialize_norsk_api_media_StreamSyncEvent(arg) {
+  if (!(arg instanceof media_pb.StreamSyncEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamSyncEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_TsFileInputMessage(buffer_arg) {
-  return media_pb.TsFileInputMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_StreamSyncEvent(buffer_arg) {
+  return media_pb.StreamSyncEvent.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');
+function serialize_norsk_api_media_StreamSyncMessage(arg) {
+  if (!(arg instanceof media_pb.StreamSyncMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamSyncMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_TsFileOutputEvent(buffer_arg) {
-  return media_pb.TsFileOutputEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_StreamSyncMessage(buffer_arg) {
+  return media_pb.StreamSyncMessage.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');
+function serialize_norsk_api_media_StreamTimestampNudgeEvent(arg) {
+  if (!(arg instanceof media_pb.StreamTimestampNudgeEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamTimestampNudgeEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_TsFileOutputMessage(buffer_arg) {
-  return media_pb.TsFileOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_StreamTimestampNudgeEvent(buffer_arg) {
+  return media_pb.StreamTimestampNudgeEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_StreamTimestampNudgeMessage(arg) {
+  if (!(arg instanceof media_pb.StreamTimestampNudgeMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamTimestampNudgeMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_StreamTimestampNudgeMessage(buffer_arg) {
+  return media_pb.StreamTimestampNudgeMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_norsk_api_media_TsInputEvent(arg) {
@@ -898,37 +876,37 @@ 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');
+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_TsUdpOutputEvent(buffer_arg) {
-  return media_pb.TsUdpOutputEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_UdpTsInputMessage(buffer_arg) {
+  return media_pb.UdpTsInputMessage.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');
+function serialize_norsk_api_media_UdpTsOutputEvent(arg) {
+  if (!(arg instanceof media_pb.UdpTsOutputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.UdpTsOutputEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_TsUdpOutputMessage(buffer_arg) {
-  return media_pb.TsUdpOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_UdpTsOutputEvent(buffer_arg) {
+  return media_pb.UdpTsOutputEvent.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');
+function serialize_norsk_api_media_UdpTsOutputMessage(arg) {
+  if (!(arg instanceof media_pb.UdpTsOutputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.UdpTsOutputMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_UdpTsInputMessage(buffer_arg) {
-  return media_pb.UdpTsInputMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_UdpTsOutputMessage(buffer_arg) {
+  return media_pb.UdpTsOutputMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_norsk_api_media_ValidationResponse(arg) {
@@ -953,114 +931,114 @@ 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');
+function serialize_norsk_api_media_VideoComposeMessage(arg) {
+  if (!(arg instanceof media_pb.VideoComposeMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.VideoComposeMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_VideoEncodeLadderEvent(buffer_arg) {
-  return media_pb.VideoEncodeLadderEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_VideoComposeMessage(buffer_arg) {
+  return media_pb.VideoComposeMessage.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');
+function serialize_norsk_api_media_VideoComposeSourceEvent(arg) {
+  if (!(arg instanceof media_pb.VideoComposeSourceEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.VideoComposeSourceEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_VideoEncodeLadderMessage(buffer_arg) {
-  return media_pb.VideoEncodeLadderMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_VideoComposeSourceEvent(buffer_arg) {
+  return media_pb.VideoComposeSourceEvent.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');
+function serialize_norsk_api_media_VideoEncodeEvent(arg) {
+  if (!(arg instanceof media_pb.VideoEncodeEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.VideoEncodeEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_VideoTransformEvent(buffer_arg) {
-  return media_pb.VideoTransformEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_VideoEncodeEvent(buffer_arg) {
+  return media_pb.VideoEncodeEvent.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');
+function serialize_norsk_api_media_VideoEncodeMessage(arg) {
+  if (!(arg instanceof media_pb.VideoEncodeMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.VideoEncodeMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_VideoTransformMessage(buffer_arg) {
-  return media_pb.VideoTransformMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_VideoEncodeMessage(buffer_arg) {
+  return media_pb.VideoEncodeMessage.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');
+function serialize_norsk_api_media_VideoTestCardGeneratorEvent(arg) {
+  if (!(arg instanceof media_pb.VideoTestCardGeneratorEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.VideoTestCardGeneratorEvent');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_WebRTCBrowserDuplexEvent(buffer_arg) {
-  return media_pb.WebRTCBrowserDuplexEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_VideoTestCardGeneratorEvent(buffer_arg) {
+  return media_pb.VideoTestCardGeneratorEvent.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');
+function serialize_norsk_api_media_VideoTestCardGeneratorMessage(arg) {
+  if (!(arg instanceof media_pb.VideoTestCardGeneratorMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.VideoTestCardGeneratorMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_WebRTCLocalOutputMessage(buffer_arg) {
-  return media_pb.WebRTCLocalOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_VideoTestCardGeneratorMessage(buffer_arg) {
+  return media_pb.VideoTestCardGeneratorMessage.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');
+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_WebRTCWhipOutputEvent(buffer_arg) {
-  return media_pb.WebRTCWhipOutputEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_VideoTransformEvent(buffer_arg) {
+  return media_pb.VideoTransformEvent.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');
+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_WebRTCWhipOutputMessage(buffer_arg) {
-  return media_pb.WebRTCWhipOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_VideoTransformMessage(buffer_arg) {
+  return media_pb.VideoTransformMessage.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');
+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_WebVttFileInputConfiguration(buffer_arg) {
-  return media_pb.WebVttFileInputConfiguration.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_WebRTCBrowserDuplexEvent(buffer_arg) {
+  return media_pb.WebRTCBrowserDuplexEvent.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');
+function serialize_norsk_api_media_WebRTCBrowserDuplexMessage(arg) {
+  if (!(arg instanceof media_pb.WebRTCBrowserDuplexMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.WebRTCBrowserDuplexMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_WebVttFileInputEvent(buffer_arg) {
-  return media_pb.WebVttFileInputEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_WebRTCBrowserDuplexMessage(buffer_arg) {
+  return media_pb.WebRTCBrowserDuplexMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_norsk_api_media_WhipInputEvent(arg) {
@@ -1085,6 +1063,28 @@ function deserialize_norsk_api_media_WhipInputMessage(buffer_arg) {
   return media_pb.WhipInputMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_norsk_api_media_WhipOutputEvent(arg) {
+  if (!(arg instanceof media_pb.WhipOutputEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.WhipOutputEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_WhipOutputEvent(buffer_arg) {
+  return media_pb.WhipOutputEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_WhipOutputMessage(arg) {
+  if (!(arg instanceof media_pb.WhipOutputMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.WhipOutputMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_WhipOutputMessage(buffer_arg) {
+  return media_pb.WhipOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
 
 var MediaService = exports.MediaService = {
   createStatusChannel: {
@@ -1098,60 +1098,60 @@ var MediaService = exports.MediaService = {
     responseSerialize: serialize_norsk_api_media_NorskStatusEvent,
     responseDeserialize: deserialize_norsk_api_media_NorskStatusEvent,
   },
-  createWebVttFileInput: {
-    path: '/norsk.api.media.Media/CreateWebVttFileInput',
+  createInputFileWebVtt: {
+    path: '/norsk.api.media.Media/CreateInputFileWebVtt',
     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,
+    requestType: media_pb.FileWebVttInputConfiguration,
+    responseType: media_pb.FileWebVttInputEvent,
+    requestSerialize: serialize_norsk_api_media_FileWebVttInputConfiguration,
+    requestDeserialize: deserialize_norsk_api_media_FileWebVttInputConfiguration,
+    responseSerialize: serialize_norsk_api_media_FileWebVttInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_FileWebVttInputEvent,
   },
   //
 // Creates an RTMP ingest Media Node.  On creation, the Media Node is idle
-// and your code **must** send an `RtmpInputConfiguration`
+// and your code **must** send an `RtmpServerInputConfiguration`
 // message to configure the RTMP server.  When a remote client connects, an
 // `RtmpConnection` message is sent, which the code can choose to
 // accept – by sending an `RtmpConnectionAccept` message or
 // reject – by sending an `RtmpConnectionReject` message.
 // Once a connection is established, Norsk will continue to send appropriate
-// `RtmpInputEvent` messages as events occur.
-createRtmpInput: {
-    path: '/norsk.api.media.Media/CreateRtmpInput',
+// `RtmpServerInputEvent` messages as events occur.
+createInputRtmpServer: {
+    path: '/norsk.api.media.Media/CreateInputRtmpServer',
     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,
+    requestType: media_pb.RtmpServerInputMessage,
+    responseType: media_pb.RtmpServerInputEvent,
+    requestSerialize: serialize_norsk_api_media_RtmpServerInputMessage,
+    requestDeserialize: deserialize_norsk_api_media_RtmpServerInputMessage,
+    responseSerialize: serialize_norsk_api_media_RtmpServerInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_RtmpServerInputEvent,
   },
   // *
 // Read from a Transport Stream file with realtime playback.
-createTsFileInput: {
-    path: '/norsk.api.media.Media/CreateTsFileInput',
+createInputFileTs: {
+    path: '/norsk.api.media.Media/CreateInputFileTs',
     requestStream: true,
     responseStream: true,
-    requestType: media_pb.TsFileInputMessage,
+    requestType: media_pb.FileTsInputMessage,
     responseType: media_pb.TsInputEvent,
-    requestSerialize: serialize_norsk_api_media_TsFileInputMessage,
-    requestDeserialize: deserialize_norsk_api_media_TsFileInputMessage,
+    requestSerialize: serialize_norsk_api_media_FileTsInputMessage,
+    requestDeserialize: deserialize_norsk_api_media_FileTsInputMessage,
     responseSerialize: serialize_norsk_api_media_TsInputEvent,
     responseDeserialize: deserialize_norsk_api_media_TsInputEvent,
   },
-  createTestCardVideoGenerator: {
-    path: '/norsk.api.media.Media/CreateTestCardVideoGenerator',
+  createInputVideoTestCardGenerator: {
+    path: '/norsk.api.media.Media/CreateInputVideoTestCardGenerator',
     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,
+    requestType: media_pb.VideoTestCardGeneratorMessage,
+    responseType: media_pb.VideoTestCardGeneratorEvent,
+    requestSerialize: serialize_norsk_api_media_VideoTestCardGeneratorMessage,
+    requestDeserialize: deserialize_norsk_api_media_VideoTestCardGeneratorMessage,
+    responseSerialize: serialize_norsk_api_media_VideoTestCardGeneratorEvent,
+    responseDeserialize: deserialize_norsk_api_media_VideoTestCardGeneratorEvent,
   },
   // *
 // SDI/HDMI Input using a BlackMagic DeckLink card.
@@ -1162,8 +1162,8 @@ createTsFileInput: {
 // input resolutions and framerates are supported.  The capture format is currently 8-bit only,
 // but 10-bit captures will be supported soon.  All supported audio channels can be captured.
 // At present, additional data such as closed-captions and HDR metadata is not captured.
-createDeckLinkInput: {
-    path: '/norsk.api.media.Media/CreateDeckLinkInput',
+createInputDeckLink: {
+    path: '/norsk.api.media.Media/CreateInputDeckLink',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.DeckLinkInputMessage,
@@ -1175,35 +1175,35 @@ createDeckLinkInput: {
   },
   // *
 // Read an image from a file. Various image formats are supported, see the
-// documentation for `ImageFileInputConfiguration` for more details.
-createImageFileInput: {
-    path: '/norsk.api.media.Media/CreateImageFileInput',
+// documentation for `FileImageInputConfiguration` for more details.
+createInputFileImage: {
+    path: '/norsk.api.media.Media/CreateInputFileImage',
     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,
+    requestType: media_pb.FileImageInputConfiguration,
+    responseType: media_pb.FileImageInputEvent,
+    requestSerialize: serialize_norsk_api_media_FileImageInputConfiguration,
+    requestDeserialize: deserialize_norsk_api_media_FileImageInputConfiguration,
+    responseSerialize: serialize_norsk_api_media_FileImageInputEvent,
+    responseDeserialize: deserialize_norsk_api_media_FileImageInputEvent,
   },
   // *
 // Creates a video source from a Mp4 file on disk
-createMp4FileInput: {
-    path: '/norsk.api.media.Media/CreateMp4FileInput',
+createInputFileMp4: {
+    path: '/norsk.api.media.Media/CreateInputFileMp4',
     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,
+    requestType: media_pb.FileMp4InputMessage,
+    responseType: media_pb.FileMp4InputEvent,
+    requestSerialize: serialize_norsk_api_media_FileMp4InputMessage,
+    requestDeserialize: deserialize_norsk_api_media_FileMp4InputMessage,
+    responseSerialize: serialize_norsk_api_media_FileMp4InputEvent,
+    responseDeserialize: deserialize_norsk_api_media_FileMp4InputEvent,
   },
   // *
 // Generate a test audio signal with a configurable waveform.
-createAudioSignalGenerator: {
-    path: '/norsk.api.media.Media/CreateAudioSignalGenerator',
+createInputAudioSignalGenerator: {
+    path: '/norsk.api.media.Media/CreateInputAudioSignalGenerator',
     requestStream: false,
     responseStream: true,
     requestType: media_pb.AudioSignalGeneratorConfiguration,
@@ -1215,8 +1215,8 @@ createAudioSignalGenerator: {
   },
   // *
 // Video source from rendering an HTML page
-createBrowserInput: {
-    path: '/norsk.api.media.Media/CreateBrowserInput',
+createInputBrowser: {
+    path: '/norsk.api.media.Media/CreateInputBrowser',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.BrowserInputMessage,
@@ -1226,8 +1226,8 @@ createBrowserInput: {
     responseSerialize: serialize_norsk_api_media_BrowserInputEvent,
     responseDeserialize: deserialize_norsk_api_media_BrowserInputEvent,
   },
-  createWhipInput: {
-    path: '/norsk.api.media.Media/CreateWhipInput',
+  createInputWhip: {
+    path: '/norsk.api.media.Media/CreateInputWhip',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.WhipInputMessage,
@@ -1239,8 +1239,8 @@ createBrowserInput: {
   },
   // *
 // Stream from a SRT source
-createSrtInput: {
-    path: '/norsk.api.media.Media/CreateSrtInput',
+createInputSrt: {
+    path: '/norsk.api.media.Media/CreateInputSrt',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.SrtInputMessage,
@@ -1250,8 +1250,8 @@ createSrtInput: {
     responseSerialize: serialize_norsk_api_media_SrtInputEvent,
     responseDeserialize: deserialize_norsk_api_media_SrtInputEvent,
   },
-  createUdpTsInput: {
-    path: '/norsk.api.media.Media/CreateUdpTsInput',
+  createInputUdpTs: {
+    path: '/norsk.api.media.Media/CreateInputUdpTs',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.UdpTsInputMessage,
@@ -1261,8 +1261,8 @@ createSrtInput: {
     responseSerialize: serialize_norsk_api_media_TsInputEvent,
     responseDeserialize: deserialize_norsk_api_media_TsInputEvent,
   },
-  createM3u8MediaInput: {
-    path: '/norsk.api.media.Media/CreateM3u8MediaInput',
+  createInputM3u8Media: {
+    path: '/norsk.api.media.Media/CreateInputM3u8Media',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.M3u8MediaInputMessage,
@@ -1273,6 +1273,19 @@ createSrtInput: {
     responseDeserialize: deserialize_norsk_api_media_TsInputEvent,
   },
   // *
+// Stream from a remote RTP source
+createInputRtp: {
+    path: '/norsk.api.media.Media/CreateInputRtp',
+    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,
+  },
+  // *
 // A node to nudge the timestamps on a stream, which affects how it syncs
 // with other streams. Useful for correcting for drift between different
 // sources.
@@ -1280,34 +1293,34 @@ createSrtInput: {
 // Subsequent nudges, via the `nudge` method, are applied gradually.
 //
 // This functionality is also provided by a `nudge` method on many sources.
-createTimestampNudger: {
-    path: '/norsk.api.media.Media/CreateTimestampNudger',
+createTransformStreamTimestampNudge: {
+    path: '/norsk.api.media.Media/CreateTransformStreamTimestampNudge',
     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,
+    requestType: media_pb.StreamTimestampNudgeMessage,
+    responseType: media_pb.StreamTimestampNudgeEvent,
+    requestSerialize: serialize_norsk_api_media_StreamTimestampNudgeMessage,
+    requestDeserialize: deserialize_norsk_api_media_StreamTimestampNudgeMessage,
+    responseSerialize: serialize_norsk_api_media_StreamTimestampNudgeEvent,
+    responseDeserialize: deserialize_norsk_api_media_StreamTimestampNudgeEvent,
   },
   // *
 // Encode a video stream to one or more renditions
-createVideoEncodeLadder: {
-    path: '/norsk.api.media.Media/CreateVideoEncodeLadder',
+createTransformVideoEncode: {
+    path: '/norsk.api.media.Media/CreateTransformVideoEncode',
     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,
+    requestType: media_pb.VideoEncodeMessage,
+    responseType: media_pb.VideoEncodeEvent,
+    requestSerialize: serialize_norsk_api_media_VideoEncodeMessage,
+    requestDeserialize: deserialize_norsk_api_media_VideoEncodeMessage,
+    responseSerialize: serialize_norsk_api_media_VideoEncodeEvent,
+    responseDeserialize: deserialize_norsk_api_media_VideoEncodeEvent,
   },
   // *
 // Transform a video stream (rescale, etc)
-createVideoTransform: {
-    path: '/norsk.api.media.Media/CreateVideoTransform',
+createTransformVideoTransform: {
+    path: '/norsk.api.media.Media/CreateTransformVideoTransform',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.VideoTransformMessage,
@@ -1319,77 +1332,77 @@ createVideoTransform: {
   },
   // *
 // Interferes with a stream by dropping frames
-createChaosMonkey: {
-    path: '/norsk.api.media.Media/CreateChaosMonkey',
+createTransformStreamChaosMonkey: {
+    path: '/norsk.api.media.Media/CreateTransformStreamChaosMonkey',
     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,
+    requestType: media_pb.StreamChaosMonkeyMessage,
+    responseType: media_pb.StreamChaosMonkeyEvent,
+    requestSerialize: serialize_norsk_api_media_StreamChaosMonkeyMessage,
+    requestDeserialize: deserialize_norsk_api_media_StreamChaosMonkeyMessage,
+    responseSerialize: serialize_norsk_api_media_StreamChaosMonkeyEvent,
+    responseDeserialize: deserialize_norsk_api_media_StreamChaosMonkeyEvent,
   },
   // *
 // Encode an audio stream.
-createAudioEncoder: {
-    path: '/norsk.api.media.Media/CreateAudioEncoder',
+createTransformAudioEncode: {
+    path: '/norsk.api.media.Media/CreateTransformAudioEncode',
     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,
+    requestType: media_pb.AudioEncodeMessage,
+    responseType: media_pb.AudioEncodeEvent,
+    requestSerialize: serialize_norsk_api_media_AudioEncodeMessage,
+    requestDeserialize: deserialize_norsk_api_media_AudioEncodeMessage,
+    responseSerialize: serialize_norsk_api_media_AudioEncodeEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioEncodeEvent,
   },
   // *
 // Create a Media Node composing multiple sources into one, eg to construct
 // overlays, picture-in-picture or split-screen video.
 //
 // Individual sources may be cropped or scaled as part of this process
-createComposeVideo: {
-    path: '/norsk.api.media.Media/CreateComposeVideo',
+createTransformVideoCompose: {
+    path: '/norsk.api.media.Media/CreateTransformVideoCompose',
     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,
+    requestType: media_pb.VideoComposeMessage,
+    responseType: media_pb.VideoComposeSourceEvent,
+    requestSerialize: serialize_norsk_api_media_VideoComposeMessage,
+    requestDeserialize: deserialize_norsk_api_media_VideoComposeMessage,
+    responseSerialize: serialize_norsk_api_media_VideoComposeSourceEvent,
+    responseDeserialize: deserialize_norsk_api_media_VideoComposeSourceEvent,
   },
   // *
 // Mix multiple audio streams together into a single output,
 // with optional gain control on each input.
-createAudioMixer: {
-    path: '/norsk.api.media.Media/CreateAudioMixer',
+createTransformAudioMix: {
+    path: '/norsk.api.media.Media/CreateTransformAudioMix',
     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,
+    requestType: media_pb.AudioMixMessage,
+    responseType: media_pb.AudioMixEvent,
+    requestSerialize: serialize_norsk_api_media_AudioMixMessage,
+    requestDeserialize: deserialize_norsk_api_media_AudioMixMessage,
+    responseSerialize: serialize_norsk_api_media_AudioMixEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioMixEvent,
   },
   // *
 // Given an audio stream of N channels, mix it down to M channels through a matrix of NxM gains.
-createAudioMatrixMixer: {
-    path: '/norsk.api.media.Media/CreateAudioMatrixMixer',
+createTransformAudioMixMatrix: {
+    path: '/norsk.api.media.Media/CreateTransformAudioMixMatrix',
     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,
+    requestType: media_pb.AudioMixMatrixMessage,
+    responseType: media_pb.AudioMixMatrixEvent,
+    requestSerialize: serialize_norsk_api_media_AudioMixMatrixMessage,
+    requestDeserialize: deserialize_norsk_api_media_AudioMixMatrixMessage,
+    responseSerialize: serialize_norsk_api_media_AudioMixMatrixEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioMixMatrixEvent,
   },
   // *
 // Apply gain to an audio stream
-createAudioGain: {
-    path: '/norsk.api.media.Media/CreateAudioGain',
+createTransformAudioGain: {
+    path: '/norsk.api.media.Media/CreateTransformAudioGain',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.AudioGainMessage,
@@ -1404,8 +1417,8 @@ createAudioGain: {
 // specified channel layout. The streams must all have the same sample format
 // and sample rate. The order of the streams provided for the channels is
 // important.
-createAudioBuildMultichannel: {
-    path: '/norsk.api.media.Media/CreateAudioBuildMultichannel',
+createTransformAudioBuildMultichannel: {
+    path: '/norsk.api.media.Media/CreateTransformAudioBuildMultichannel',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.AudioBuildMultichannelMessage,
@@ -1419,8 +1432,8 @@ createAudioBuildMultichannel: {
 // Split a multichannel audio stream into its individual channels. The first
 // channel receives the specified stream key, and each subsequent channel
 // increments the stream id on the stream key.
-createAudioSplitMultichannel: {
-    path: '/norsk.api.media.Media/CreateAudioSplitMultichannel',
+createTransformAudioSplitMultichannel: {
+    path: '/norsk.api.media.Media/CreateTransformAudioSplitMultichannel',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.AudioSplitMultichannelMessage,
@@ -1433,19 +1446,19 @@ createAudioSplitMultichannel: {
   // *
 // Create a Media Node performing transcription into subtitles using the
 // Amazon Transcribe AWS service.
-createAwsTranscribe: {
-    path: '/norsk.api.media.Media/CreateAwsTranscribe',
+createTransformAudioTranscribeAws: {
+    path: '/norsk.api.media.Media/CreateTransformAudioTranscribeAws',
     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,
+    requestType: media_pb.AudioTranscribeAwsMessage,
+    responseType: media_pb.AudioTranscribeAwsEvent,
+    requestSerialize: serialize_norsk_api_media_AudioTranscribeAwsMessage,
+    requestDeserialize: deserialize_norsk_api_media_AudioTranscribeAwsMessage,
+    responseSerialize: serialize_norsk_api_media_AudioTranscribeAwsEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioTranscribeAwsEvent,
   },
-  createCmafVideoOutput: {
-    path: '/norsk.api.media.Media/CreateCmafVideoOutput',
+  createOutputCmafVideo: {
+    path: '/norsk.api.media.Media/CreateOutputCmafVideo',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.CmafVideoMessage,
@@ -1455,8 +1468,8 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createHlsTsVideoOutput: {
-    path: '/norsk.api.media.Media/CreateHlsTsVideoOutput',
+  createOutputHlsTsVideo: {
+    path: '/norsk.api.media.Media/CreateOutputHlsTsVideo',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.HlsTsVideoMessage,
@@ -1466,8 +1479,8 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createHlsTsVideoPushOutput: {
-    path: '/norsk.api.media.Media/CreateHlsTsVideoPushOutput',
+  createOutputHlsTsVideoPush: {
+    path: '/norsk.api.media.Media/CreateOutputHlsTsVideoPush',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.HlsTsVideoPushMessage,
@@ -1477,8 +1490,8 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createCmafAudioOutput: {
-    path: '/norsk.api.media.Media/CreateCmafAudioOutput',
+  createOutputCmafAudio: {
+    path: '/norsk.api.media.Media/CreateOutputCmafAudio',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.CmafAudioMessage,
@@ -1488,8 +1501,8 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createHlsTsAudioOutput: {
-    path: '/norsk.api.media.Media/CreateHlsTsAudioOutput',
+  createOutputHlsTsAudio: {
+    path: '/norsk.api.media.Media/CreateOutputHlsTsAudio',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.HlsTsAudioMessage,
@@ -1499,8 +1512,8 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createCmafWebVttOutput: {
-    path: '/norsk.api.media.Media/CreateCmafWebVttOutput',
+  createOutputCmafWebVtt: {
+    path: '/norsk.api.media.Media/CreateOutputCmafWebVtt',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.CmafWebVttMessage,
@@ -1510,8 +1523,8 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createHlsWebVttPushOutput: {
-    path: '/norsk.api.media.Media/CreateHlsWebVttPushOutput',
+  createOutputHlsWebVttPush: {
+    path: '/norsk.api.media.Media/CreateOutputHlsWebVttPush',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.HlsWebVttPushMessage,
@@ -1521,8 +1534,8 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createHlsTsAudioPushOutput: {
-    path: '/norsk.api.media.Media/CreateHlsTsAudioPushOutput',
+  createOutputHlsTsAudioPush: {
+    path: '/norsk.api.media.Media/CreateOutputHlsTsAudioPush',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.HlsTsAudioPushMessage,
@@ -1532,8 +1545,8 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createHlsTsCombinedPushOutput: {
-    path: '/norsk.api.media.Media/CreateHlsTsCombinedPushOutput',
+  createOutputHlsTsCombinedPush: {
+    path: '/norsk.api.media.Media/CreateOutputHlsTsCombinedPush',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.HlsTsCombinedPushMessage,
@@ -1543,8 +1556,8 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createCmafMasterOutput: {
-    path: '/norsk.api.media.Media/CreateCmafMasterOutput',
+  createOutputCmafMaster: {
+    path: '/norsk.api.media.Media/CreateOutputCmafMaster',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.CmafMasterMessage,
@@ -1554,8 +1567,8 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createHlsMasterPushOutput: {
-    path: '/norsk.api.media.Media/CreateHlsMasterPushOutput',
+  createOutputHlsMasterPush: {
+    path: '/norsk.api.media.Media/CreateOutputHlsMasterPush',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.HlsMasterPushMessage,
@@ -1565,46 +1578,30 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  // *
-// Playback audio/video via webrtc to a browser, and accept audio/video input from a browser.
-// The browser client must conform to a custom protocol as implemented in the hosted test page.
-// For general WebRTC ingest prefer the WHIP input node, and for egest to a downstream media server
-// use the WHIP output node.
-createLocalWebRTCOutput: {
-    path: '/norsk.api.media.Media/CreateLocalWebRTCOutput',
+  createOutputWhip: {
+    path: '/norsk.api.media.Media/CreateOutputWhip',
     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,
+    requestType: media_pb.WhipOutputMessage,
+    responseType: media_pb.WhipOutputEvent,
+    requestSerialize: serialize_norsk_api_media_WhipOutputMessage,
+    requestDeserialize: deserialize_norsk_api_media_WhipOutputMessage,
+    responseSerialize: serialize_norsk_api_media_WhipOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_WhipOutputEvent,
   },
-  createWebRTCWhipOutput: {
-    path: '/norsk.api.media.Media/CreateWebRTCWhipOutput',
+  createOutputUdpTs: {
+    path: '/norsk.api.media.Media/CreateOutputUdpTs',
     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,
+    requestType: media_pb.UdpTsOutputMessage,
+    responseType: media_pb.UdpTsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_UdpTsOutputMessage,
+    requestDeserialize: deserialize_norsk_api_media_UdpTsOutputMessage,
+    responseSerialize: serialize_norsk_api_media_UdpTsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_UdpTsOutputEvent,
   },
-  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',
+  createOutputSrt: {
+    path: '/norsk.api.media.Media/CreateOutputSrt',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.SrtOutputMessage,
@@ -1614,8 +1611,8 @@ createLocalWebRTCOutput: {
     responseSerialize: serialize_norsk_api_media_SrtOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_SrtOutputEvent,
   },
-  createRtmpOutput: {
-    path: '/norsk.api.media.Media/CreateRtmpOutput',
+  createOutputRtmp: {
+    path: '/norsk.api.media.Media/CreateOutputRtmp',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.RtmpOutputMessage,
@@ -1627,16 +1624,16 @@ createLocalWebRTCOutput: {
   },
   // *
 // Stream to a Transport Stream file.
-createTsFileOutput: {
-    path: '/norsk.api.media.Media/CreateTsFileOutput',
+createOutputFileTs: {
+    path: '/norsk.api.media.Media/CreateOutputFileTs',
     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,
+    requestType: media_pb.FileTsOutputMessage,
+    responseType: media_pb.FileTsOutputEvent,
+    requestSerialize: serialize_norsk_api_media_FileTsOutputMessage,
+    requestDeserialize: deserialize_norsk_api_media_FileTsOutputMessage,
+    responseSerialize: serialize_norsk_api_media_FileTsOutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_FileTsOutputEvent,
   },
   // *
 // Output MP4 files to disk, both fragmented and non-fragmented.
@@ -1652,43 +1649,59 @@ createTsFileOutput: {
 // `write_file` message, which uses the frame data store if
 // `nonfragmented_file_name` was given or reads
 // back the fragmented mp4 if there is no non-fragmented file.
-createMp4FileOutput: {
-    path: '/norsk.api.media.Media/CreateMp4FileOutput',
+createOutputFileMp4: {
+    path: '/norsk.api.media.Media/CreateOutputFileMp4',
+    requestStream: true,
+    responseStream: true,
+    requestType: media_pb.FileMp4OutputMessage,
+    responseType: media_pb.FileMp4OutputEvent,
+    requestSerialize: serialize_norsk_api_media_FileMp4OutputMessage,
+    requestDeserialize: deserialize_norsk_api_media_FileMp4OutputMessage,
+    responseSerialize: serialize_norsk_api_media_FileMp4OutputEvent,
+    responseDeserialize: deserialize_norsk_api_media_FileMp4OutputEvent,
+  },
+  // *
+// Playback audio/video via webrtc to a browser, and accept audio/video input from a browser.
+// The browser client must conform to a custom protocol as implemented in the hosted test page.
+// For general WebRTC ingest prefer the WHIP input node, and for egest to a downstream media server
+// use the WHIP output node.
+createDuplexWebRTCBrowser: {
+    path: '/norsk.api.media.Media/CreateDuplexWebRTCBrowser',
     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,
+    requestType: media_pb.WebRTCBrowserDuplexMessage,
+    responseType: media_pb.WebRTCBrowserDuplexEvent,
+    requestSerialize: serialize_norsk_api_media_WebRTCBrowserDuplexMessage,
+    requestDeserialize: deserialize_norsk_api_media_WebRTCBrowserDuplexMessage,
+    responseSerialize: serialize_norsk_api_media_WebRTCBrowserDuplexEvent,
+    responseDeserialize: deserialize_norsk_api_media_WebRTCBrowserDuplexEvent,
   },
   // *
 // Switch between multiple input sources via a hard cut. May be used to switch between
 // sources of possibly different configurations or without decoding.
-createHardSwitcher: {
-    path: '/norsk.api.media.Media/CreateHardSwitcher',
+createControlStreamSwitchHard: {
+    path: '/norsk.api.media.Media/CreateControlStreamSwitchHard',
     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,
+    requestType: media_pb.StreamSwitchHardMessage,
+    responseType: media_pb.StreamSwitchHardEvent,
+    requestSerialize: serialize_norsk_api_media_StreamSwitchHardMessage,
+    requestDeserialize: deserialize_norsk_api_media_StreamSwitchHardMessage,
+    responseSerialize: serialize_norsk_api_media_StreamSwitchHardEvent,
+    responseDeserialize: deserialize_norsk_api_media_StreamSwitchHardEvent,
   },
   // *
 // Switch between multiple input sources without interruption, via a transition.
-createSmoothSwitcher: {
-    path: '/norsk.api.media.Media/CreateSmoothSwitcher',
+createControlStreamSwitchSmooth: {
+    path: '/norsk.api.media.Media/CreateControlStreamSwitchSmooth',
     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,
+    requestType: media_pb.StreamSwitchSmoothMessage,
+    responseType: media_pb.StreamSwitchSmoothEvent,
+    requestSerialize: serialize_norsk_api_media_StreamSwitchSmoothMessage,
+    requestDeserialize: deserialize_norsk_api_media_StreamSwitchSmoothMessage,
+    responseSerialize: serialize_norsk_api_media_StreamSwitchSmoothEvent,
+    responseDeserialize: deserialize_norsk_api_media_StreamSwitchSmoothEvent,
   },
   // *
 // Provide a new stream key for a single stream. Cannot be subscribed to
@@ -1696,8 +1709,8 @@ createSmoothSwitcher: {
 //
 // The stream key is used for identifying streams within multiplexed sources
 // and also is translated into URIs for HLS playlists and other resources.
-createStreamKeyOverride: {
-    path: '/norsk.api.media.Media/CreateStreamKeyOverride',
+createTransformStreamKeyOverride: {
+    path: '/norsk.api.media.Media/CreateTransformStreamKeyOverride',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.StreamKeyOverrideMessage,
@@ -1714,31 +1727,31 @@ createStreamKeyOverride: {
 // `CreateHlsMasterOutput` and `CreateHlsMasterPushOutput`
 // nodes. It is automatically configured for some sources (like RTMP) and in
 // cases where re-encoding is done, but is unset for other sources (like SRT).
-createMetadataOverride: {
-    path: '/norsk.api.media.Media/CreateMetadataOverride',
+createTransformStreamMetadataOverride: {
+    path: '/norsk.api.media.Media/CreateTransformStreamMetadataOverride',
     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,
+    requestType: media_pb.StreamMetadataOverrideMessage,
+    responseType: media_pb.StreamMetadataOverrideEvent,
+    requestSerialize: serialize_norsk_api_media_StreamMetadataOverrideMessage,
+    requestDeserialize: deserialize_norsk_api_media_StreamMetadataOverrideMessage,
+    responseSerialize: serialize_norsk_api_media_StreamMetadataOverrideEvent,
+    responseDeserialize: deserialize_norsk_api_media_StreamMetadataOverrideEvent,
   },
   // *
 // Sync multiple streams together by timestamps, queuing frames from streams
 // that are behind the others. This is already included in most nodes,
 // especially outputs.
-createSync: {
-    path: '/norsk.api.media.Media/CreateSync',
+createTransformStreamSync: {
+    path: '/norsk.api.media.Media/CreateTransformStreamSync',
     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,
+    requestType: media_pb.StreamSyncMessage,
+    responseType: media_pb.StreamSyncEvent,
+    requestSerialize: serialize_norsk_api_media_StreamSyncMessage,
+    requestDeserialize: deserialize_norsk_api_media_StreamSyncMessage,
+    responseSerialize: serialize_norsk_api_media_StreamSyncEvent,
+    responseDeserialize: deserialize_norsk_api_media_StreamSyncEvent,
   },
   // *
 // Record statistical information about media streams, including bitrate,
@@ -1746,42 +1759,29 @@ createSync: {
 // sampling windows.
 //
 // Corresponding settings are found on many input and output nodes.
-createStreamStats: {
-    path: '/norsk.api.media.Media/CreateStreamStats',
+createControlStreamStatistics: {
+    path: '/norsk.api.media.Media/CreateControlStreamStatistics',
     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,
+    requestType: media_pb.StreamStatisticsMessage,
+    responseType: media_pb.StreamStatisticsEvent,
+    requestSerialize: serialize_norsk_api_media_StreamStatisticsMessage,
+    requestDeserialize: deserialize_norsk_api_media_StreamStatisticsMessage,
+    responseSerialize: serialize_norsk_api_media_StreamStatisticsEvent,
+    responseDeserialize: deserialize_norsk_api_media_StreamStatisticsEvent,
   },
   // *
 // Monitor the volume of an audio stream
-createAudioLevels: {
-    path: '/norsk.api.media.Media/CreateAudioLevels',
+createControlAudioMeasureLevels: {
+    path: '/norsk.api.media.Media/CreateControlAudioMeasureLevels',
     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,
-  },
-  // *
-// Stream from a remote RTP source
-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,
+    requestType: media_pb.AudioMeasureLevelsMessage,
+    responseType: media_pb.AudioMeasureLevelsEvent,
+    requestSerialize: serialize_norsk_api_media_AudioMeasureLevelsMessage,
+    requestDeserialize: deserialize_norsk_api_media_AudioMeasureLevelsMessage,
+    responseSerialize: serialize_norsk_api_media_AudioMeasureLevelsEvent,
+    responseDeserialize: deserialize_norsk_api_media_AudioMeasureLevelsEvent,
   },
   // *
 // Query information about the hardware Norsk is running on.