@norskvideo/norsk-api 0.0.329 → 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,48 +249,48 @@ 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');
+function serialize_norsk_api_media_CmafAudioMessage(arg) {
+  if (!(arg instanceof media_pb.CmafAudioMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.CmafAudioMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_ChaosMonkeyEvent(buffer_arg) {
-  return media_pb.ChaosMonkeyEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_CmafAudioMessage(buffer_arg) {
+  return media_pb.CmafAudioMessage.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');
+function serialize_norsk_api_media_CmafMasterMessage(arg) {
+  if (!(arg instanceof media_pb.CmafMasterMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.CmafMasterMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_ChaosMonkeyMessage(buffer_arg) {
-  return media_pb.ChaosMonkeyMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_CmafMasterMessage(buffer_arg) {
+  return media_pb.CmafMasterMessage.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');
+function serialize_norsk_api_media_CmafVideoMessage(arg) {
+  if (!(arg instanceof media_pb.CmafVideoMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.CmafVideoMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_ComposeVideoMessage(buffer_arg) {
-  return media_pb.ComposeVideoMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_CmafVideoMessage(buffer_arg) {
+  return media_pb.CmafVideoMessage.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');
+function serialize_norsk_api_media_CmafWebVttMessage(arg) {
+  if (!(arg instanceof media_pb.CmafWebVttMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.CmafWebVttMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_media_ComposeVideoSourceEvent(buffer_arg) {
-  return media_pb.ComposeVideoSourceEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_CmafWebVttMessage(buffer_arg) {
+  return media_pb.CmafWebVttMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_norsk_api_media_DeckLinkCardIndex(arg) {
@@ -337,59 +337,136 @@ 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_HardSwitcherEvent(buffer_arg) {
-  return media_pb.HardSwitcherEvent.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_FileImageInputConfiguration(buffer_arg) {
+  return media_pb.FileImageInputConfiguration.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_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_HardSwitcherMessage(buffer_arg) {
-  return media_pb.HardSwitcherMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_FileImageInputEvent(buffer_arg) {
+  return media_pb.FileImageInputEvent.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');
+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_Hardware(buffer_arg) {
-  return media_pb.Hardware.fromBinary(new Uint8Array(buffer_arg));
+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 serialize_norsk_api_media_HlsAudioMessage(arg) {
-  if (!(arg instanceof media_pb.HlsAudioMessage)) {
-    throw new Error('Expected argument of type norsk.api.media.HlsAudioMessage');
+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_HlsAudioMessage(buffer_arg) {
-  return media_pb.HlsAudioMessage.fromBinary(new Uint8Array(buffer_arg));
+function deserialize_norsk_api_media_FileTsOutputEvent(buffer_arg) {
+  return media_pb.FileTsOutputEvent.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');
+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_HlsMasterMessage(buffer_arg) {
-  return media_pb.HlsMasterMessage.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_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_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) {
+  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_HlsMasterPushMessage(arg) {
@@ -469,28 +546,6 @@ 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');
@@ -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_StreamMetadataOverrideEvent(buffer_arg) {
+  return media_pb.StreamMetadataOverrideEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+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_StreamStatsEvent(buffer_arg) {
-  return media_pb.StreamStatsEvent.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_StreamStatsMessage(arg) {
-  if (!(arg instanceof media_pb.StreamStatsMessage)) {
-    throw new Error('Expected argument of type norsk.api.media.StreamStatsMessage');
+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_StreamStatsMessage(buffer_arg) {
-  return media_pb.StreamStatsMessage.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_SyncEvent(arg) {
-  if (!(arg instanceof media_pb.SyncEvent)) {
-    throw new Error('Expected argument of type norsk.api.media.SyncEvent');
+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_SyncEvent(buffer_arg) {
-  return media_pb.SyncEvent.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_SyncMessage(arg) {
-  if (!(arg instanceof media_pb.SyncMessage)) {
-    throw new Error('Expected argument of type norsk.api.media.SyncMessage');
+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_SyncMessage(buffer_arg) {
-  return media_pb.SyncMessage.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_TestCardVideoGeneratorEvent(arg) {
-  if (!(arg instanceof media_pb.TestCardVideoGeneratorEvent)) {
-    throw new Error('Expected argument of type norsk.api.media.TestCardVideoGeneratorEvent');
+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_TestCardVideoGeneratorEvent(buffer_arg) {
-  return media_pb.TestCardVideoGeneratorEvent.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_TestCardVideoGeneratorMessage(arg) {
-  if (!(arg instanceof media_pb.TestCardVideoGeneratorMessage)) {
-    throw new Error('Expected argument of type norsk.api.media.TestCardVideoGeneratorMessage');
+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_TestCardVideoGeneratorMessage(buffer_arg) {
-  return media_pb.TestCardVideoGeneratorMessage.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_TimestampNudgerEvent(arg) {
-  if (!(arg instanceof media_pb.TimestampNudgerEvent)) {
-    throw new Error('Expected argument of type norsk.api.media.TimestampNudgerEvent');
+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_TimestampNudgerEvent(buffer_arg) {
-  return media_pb.TimestampNudgerEvent.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_TimestampNudgerMessage(arg) {
-  if (!(arg instanceof media_pb.TimestampNudgerMessage)) {
-    throw new Error('Expected argument of type norsk.api.media.TimestampNudgerMessage');
+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_TimestampNudgerMessage(buffer_arg) {
-  return media_pb.TimestampNudgerMessage.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_TsFileInputMessage(arg) {
-  if (!(arg instanceof media_pb.TsFileInputMessage)) {
-    throw new Error('Expected argument of type norsk.api.media.TsFileInputMessage');
+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_TsFileInputMessage(buffer_arg) {
-  return media_pb.TsFileInputMessage.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_TsFileOutputEvent(arg) {
-  if (!(arg instanceof media_pb.TsFileOutputEvent)) {
-    throw new Error('Expected argument of type norsk.api.media.TsFileOutputEvent');
+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_TsFileOutputEvent(buffer_arg) {
-  return media_pb.TsFileOutputEvent.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_TsFileOutputMessage(arg) {
-  if (!(arg instanceof media_pb.TsFileOutputMessage)) {
-    throw new Error('Expected argument of type norsk.api.media.TsFileOutputMessage');
+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_TsFileOutputMessage(buffer_arg) {
-  return media_pb.TsFileOutputMessage.fromBinary(new Uint8Array(buffer_arg));
+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,61 +1098,72 @@ 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 <b>must</b> send an <ref>RtmpInputConfiguration</ref>
+// and your code **must** send an `RtmpServerInputConfiguration`
 // 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.
+// `RtmpConnection` message is sent, which the code can choose to
+// accept &ndash; by sending an `RtmpConnectionAccept` message or
+// reject &ndash; by sending an `RtmpConnectionReject` 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',
+// `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,
   },
-  createTsFileInput: {
-    path: '/norsk.api.media.Media/CreateTsFileInput',
+  // *
+// Read from a Transport Stream file with realtime playback.
+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,
   },
-  createDeckLinkInput: {
-    path: '/norsk.api.media.Media/CreateDeckLinkInput',
+  // *
+// SDI/HDMI Input using a BlackMagic DeckLink card.
+// The available cards on the machine can be enumerated using the
+// `HardwareInfo` rpc.
+//
+// Multiple cards and both SDI and HDMI inputs are supported, with all DeckLink-supported
+// 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.
+createInputDeckLink: {
+    path: '/norsk.api.media.Media/CreateInputDeckLink',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.DeckLinkInputMessage,
@@ -1163,33 +1174,36 @@ createRtmpInput: {
     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',
+// Read an image from a file. Various image formats are supported, see the
+// 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,
   },
-  createAudioSignalGenerator: {
-    path: '/norsk.api.media.Media/CreateAudioSignalGenerator',
+  // *
+// Generate a test audio signal with a configurable waveform.
+createInputAudioSignalGenerator: {
+    path: '/norsk.api.media.Media/CreateInputAudioSignalGenerator',
     requestStream: false,
     responseStream: true,
     requestType: media_pb.AudioSignalGeneratorConfiguration,
@@ -1199,8 +1213,10 @@ createMp4FileInput: {
     responseSerialize: serialize_norsk_api_media_AudioSignalGeneratorEvent,
     responseDeserialize: deserialize_norsk_api_media_AudioSignalGeneratorEvent,
   },
-  createBrowserInput: {
-    path: '/norsk.api.media.Media/CreateBrowserInput',
+  // *
+// Video source from rendering an HTML page
+createInputBrowser: {
+    path: '/norsk.api.media.Media/CreateInputBrowser',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.BrowserInputMessage,
@@ -1210,8 +1226,8 @@ createMp4FileInput: {
     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,
@@ -1221,8 +1237,10 @@ createMp4FileInput: {
     responseSerialize: serialize_norsk_api_media_WhipInputEvent,
     responseDeserialize: deserialize_norsk_api_media_WhipInputEvent,
   },
-  createSrtInput: {
-    path: '/norsk.api.media.Media/CreateSrtInput',
+  // *
+// Stream from a SRT source
+createInputSrt: {
+    path: '/norsk.api.media.Media/CreateInputSrt',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.SrtInputMessage,
@@ -1232,8 +1250,8 @@ createMp4FileInput: {
     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,
@@ -1243,8 +1261,8 @@ createMp4FileInput: {
     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,
@@ -1254,30 +1272,55 @@ createMp4FileInput: {
     responseSerialize: serialize_norsk_api_media_TsInputEvent,
     responseDeserialize: deserialize_norsk_api_media_TsInputEvent,
   },
-  createTimestampNudger: {
-    path: '/norsk.api.media.Media/CreateTimestampNudger',
+  // *
+// Stream from a remote RTP source
+createInputRtp: {
+    path: '/norsk.api.media.Media/CreateInputRtp',
     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.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,
   },
-  createVideoEncodeLadder: {
-    path: '/norsk.api.media.Media/CreateVideoEncodeLadder',
+  // *
+// 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.
+//
+// Subsequent nudges, via the `nudge` method, are applied gradually.
+//
+// This functionality is also provided by a `nudge` method on many sources.
+createTransformStreamTimestampNudge: {
+    path: '/norsk.api.media.Media/CreateTransformStreamTimestampNudge',
     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.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,
   },
-  createVideoTransform: {
-    path: '/norsk.api.media.Media/CreateVideoTransform',
+  // *
+// Encode a video stream to one or more renditions
+createTransformVideoEncode: {
+    path: '/norsk.api.media.Media/CreateTransformVideoEncode',
+    requestStream: true,
+    responseStream: true,
+    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)
+createTransformVideoTransform: {
+    path: '/norsk.api.media.Media/CreateTransformVideoTransform',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.VideoTransformMessage,
@@ -1287,68 +1330,79 @@ createMp4FileInput: {
     responseSerialize: serialize_norsk_api_media_VideoTransformEvent,
     responseDeserialize: deserialize_norsk_api_media_VideoTransformEvent,
   },
-  createChaosMonkey: {
-    path: '/norsk.api.media.Media/CreateChaosMonkey',
+  // *
+// Interferes with a stream by dropping frames
+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,
   },
-  createAudioEncoder: {
-    path: '/norsk.api.media.Media/CreateAudioEncoder',
+  // *
+// Encode an audio stream.
+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.
-// <br/><br/>
+//
 // 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,
   },
-  createAudioMixer: {
-    path: '/norsk.api.media.Media/CreateAudioMixer',
+  // *
+// Mix multiple audio streams together into a single output,
+// with optional gain control on each input.
+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,
   },
-  createAudioMatrixMixer: {
-    path: '/norsk.api.media.Media/CreateAudioMatrixMixer',
+  // *
+// Given an audio stream of N channels, mix it down to M channels through a matrix of NxM gains.
+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,
   },
-  createAudioGain: {
-    path: '/norsk.api.media.Media/CreateAudioGain',
+  // *
+// Apply gain to an audio stream
+createTransformAudioGain: {
+    path: '/norsk.api.media.Media/CreateTransformAudioGain',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.AudioGainMessage,
@@ -1358,8 +1412,13 @@ createComposeVideo: {
     responseSerialize: serialize_norsk_api_media_AudioGainEvent,
     responseDeserialize: deserialize_norsk_api_media_AudioGainEvent,
   },
-  createAudioBuildMultichannel: {
-    path: '/norsk.api.media.Media/CreateAudioBuildMultichannel',
+  // *
+// Aggregate many single-channel audio streams into a stream with the
+// 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.
+createTransformAudioBuildMultichannel: {
+    path: '/norsk.api.media.Media/CreateTransformAudioBuildMultichannel',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.AudioBuildMultichannelMessage,
@@ -1369,8 +1428,12 @@ createComposeVideo: {
     responseSerialize: serialize_norsk_api_media_AudioBuildMultichannelEvent,
     responseDeserialize: deserialize_norsk_api_media_AudioBuildMultichannelEvent,
   },
-  createAudioSplitMultichannel: {
-    path: '/norsk.api.media.Media/CreateAudioSplitMultichannel',
+  // *
+// 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.
+createTransformAudioSplitMultichannel: {
+    path: '/norsk.api.media.Media/CreateTransformAudioSplitMultichannel',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.AudioSplitMultichannelMessage,
@@ -1383,30 +1446,30 @@ createComposeVideo: {
   // *
 // 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,
   },
-  createHlsVideoOutput: {
-    path: '/norsk.api.media.Media/CreateHlsVideoOutput',
+  createOutputCmafVideo: {
+    path: '/norsk.api.media.Media/CreateOutputCmafVideo',
     requestStream: true,
     responseStream: true,
-    requestType: media_pb.HlsVideoMessage,
+    requestType: media_pb.CmafVideoMessage,
     responseType: media_pb.HlsOutputEvent,
-    requestSerialize: serialize_norsk_api_media_HlsVideoMessage,
-    requestDeserialize: deserialize_norsk_api_media_HlsVideoMessage,
+    requestSerialize: serialize_norsk_api_media_CmafVideoMessage,
+    requestDeserialize: deserialize_norsk_api_media_CmafVideoMessage,
     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,
@@ -1416,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,
@@ -1427,19 +1490,19 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createHlsAudioOutput: {
-    path: '/norsk.api.media.Media/CreateHlsAudioOutput',
+  createOutputCmafAudio: {
+    path: '/norsk.api.media.Media/CreateOutputCmafAudio',
     requestStream: true,
     responseStream: true,
-    requestType: media_pb.HlsAudioMessage,
+    requestType: media_pb.CmafAudioMessage,
     responseType: media_pb.HlsOutputEvent,
-    requestSerialize: serialize_norsk_api_media_HlsAudioMessage,
-    requestDeserialize: deserialize_norsk_api_media_HlsAudioMessage,
+    requestSerialize: serialize_norsk_api_media_CmafAudioMessage,
+    requestDeserialize: deserialize_norsk_api_media_CmafAudioMessage,
     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,
@@ -1449,19 +1512,19 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createHlsWebVttOutput: {
-    path: '/norsk.api.media.Media/CreateHlsWebVttOutput',
+  createOutputCmafWebVtt: {
+    path: '/norsk.api.media.Media/CreateOutputCmafWebVtt',
     requestStream: true,
     responseStream: true,
-    requestType: media_pb.HlsWebVttMessage,
+    requestType: media_pb.CmafWebVttMessage,
     responseType: media_pb.HlsOutputEvent,
-    requestSerialize: serialize_norsk_api_media_HlsWebVttMessage,
-    requestDeserialize: deserialize_norsk_api_media_HlsWebVttMessage,
+    requestSerialize: serialize_norsk_api_media_CmafWebVttMessage,
+    requestDeserialize: deserialize_norsk_api_media_CmafWebVttMessage,
     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,
@@ -1471,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,
@@ -1482,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,
@@ -1493,19 +1556,19 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_HlsOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_HlsOutputEvent,
   },
-  createHlsMasterOutput: {
-    path: '/norsk.api.media.Media/CreateHlsMasterOutput',
+  createOutputCmafMaster: {
+    path: '/norsk.api.media.Media/CreateOutputCmafMaster',
     requestStream: true,
     responseStream: true,
-    requestType: media_pb.HlsMasterMessage,
+    requestType: media_pb.CmafMasterMessage,
     responseType: media_pb.HlsOutputEvent,
-    requestSerialize: serialize_norsk_api_media_HlsMasterMessage,
-    requestDeserialize: deserialize_norsk_api_media_HlsMasterMessage,
+    requestSerialize: serialize_norsk_api_media_CmafMasterMessage,
+    requestDeserialize: deserialize_norsk_api_media_CmafMasterMessage,
     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,
@@ -1515,41 +1578,30 @@ createAwsTranscribe: {
     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',
+  createOutputWhip: {
+    path: '/norsk.api.media.Media/CreateOutputWhip',
     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.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,
   },
-  createTsUdpOutput: {
-    path: '/norsk.api.media.Media/CreateTsUdpOutput',
+  createOutputUdpTs: {
+    path: '/norsk.api.media.Media/CreateOutputUdpTs',
     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,
+    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,
   },
-  createSrtOutput: {
-    path: '/norsk.api.media.Media/CreateSrtOutput',
+  createOutputSrt: {
+    path: '/norsk.api.media.Media/CreateOutputSrt',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.SrtOutputMessage,
@@ -1559,8 +1611,8 @@ createAwsTranscribe: {
     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,
@@ -1570,52 +1622,95 @@ createAwsTranscribe: {
     responseSerialize: serialize_norsk_api_media_RtmpOutputEvent,
     responseDeserialize: deserialize_norsk_api_media_RtmpOutputEvent,
   },
-  createTsFileOutput: {
-    path: '/norsk.api.media.Media/CreateTsFileOutput',
+  // *
+// Stream to a Transport Stream file.
+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,
   },
-  createMp4FileOutput: {
-    path: '/norsk.api.media.Media/CreateMp4FileOutput',
+  // *
+// Output MP4 files to disk, both fragmented and non-fragmented.
+//
+// The fragmented output is required.
+//
+// The optional non-fragmented filename will be written after sending
+// the `close` message and will be fully written by the time the node is
+// closed. This sets up a temp file to store the frame data by appending
+// the extension `.tmp`.
+//
+// A non-fragmented MP4 file can be written on request with the
+// `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.
+createOutputFileMp4: {
+    path: '/norsk.api.media.Media/CreateOutputFileMp4',
     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.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,
   },
-  createHardSwitcher: {
-    path: '/norsk.api.media.Media/CreateHardSwitcher',
+  // *
+// 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.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.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,
   },
-  createSmoothSwitcher: {
-    path: '/norsk.api.media.Media/CreateSmoothSwitcher',
+  // *
+// Switch between multiple input sources via a hard cut. May be used to switch between
+// sources of possibly different configurations or without decoding.
+createControlStreamSwitchHard: {
+    path: '/norsk.api.media.Media/CreateControlStreamSwitchHard',
     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.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,
   },
-  createStreamKeyOverride: {
-    path: '/norsk.api.media.Media/CreateStreamKeyOverride',
+  // *
+// Switch between multiple input sources without interruption, via a transition.
+createControlStreamSwitchSmooth: {
+    path: '/norsk.api.media.Media/CreateControlStreamSwitchSmooth',
+    requestStream: true,
+    responseStream: true,
+    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
+// multiple streams at once.
+//
+// The stream key is used for identifying streams within multiplexed sources
+// and also is translated into URIs for HLS playlists and other resources.
+createTransformStreamKeyOverride: {
+    path: '/norsk.api.media.Media/CreateTransformStreamKeyOverride',
     requestStream: true,
     responseStream: true,
     requestType: media_pb.StreamKeyOverrideMessage,
@@ -1625,62 +1720,72 @@ createAwsTranscribe: {
     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',
+  // *
+// Override bitrate and language metadata on streams.
+//
+// Audio and video bitrate metadata is required for playlists for both
+// `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).
+createTransformStreamMetadataOverride: {
+    path: '/norsk.api.media.Media/CreateTransformStreamMetadataOverride',
     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.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,
   },
-  createStreamStats: {
-    path: '/norsk.api.media.Media/CreateStreamStats',
+  // *
+// Sync multiple streams together by timestamps, queuing frames from streams
+// that are behind the others. This is already included in most nodes,
+// especially outputs.
+createTransformStreamSync: {
+    path: '/norsk.api.media.Media/CreateTransformStreamSync',
     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.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,
   },
-  createAudioLevels: {
-    path: '/norsk.api.media.Media/CreateAudioLevels',
+  // *
+// Record statistical information about media streams, including bitrate,
+// frame rate, and number of keyframes, measured over some configurable
+// sampling windows.
+//
+// Corresponding settings are found on many input and output nodes.
+createControlStreamStatistics: {
+    path: '/norsk.api.media.Media/CreateControlStreamStatistics',
     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,
+    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,
   },
-  createRtpInput: {
-    path: '/norsk.api.media.Media/CreateRtpInput',
+  // *
+// Monitor the volume of an audio stream
+createControlAudioMeasureLevels: {
+    path: '/norsk.api.media.Media/CreateControlAudioMeasureLevels',
     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,
   },
-  hardwareInfo: {
+  // *
+// Query information about the hardware Norsk is running on.
+hardwareInfo: {
     path: '/norsk.api.media.Media/HardwareInfo',
     requestStream: false,
     responseStream: false,