@norskvideo/norsk-api 1.0.332 → 1.0.335

package/lib/media_pb.ts

@@ -2656,6 +2656,106 @@ export class Context extends Message<Context> {
   }
 }
 
+/**
+ * *
+ * The MultipleContext message is sent from Norsk in response to a
+ * change to either the Media Node's inbound set of streams for
+ * certain nodes that are permitted non-disjoint context keys
+ * .
+ * Once received, your code **must** acknowledge the context change
+ * with a call to `Media.UnblockCall`,
+ * passing in the `blockingCallRef`; note that if using the
+ * JavaScript SDK then this is automatically handled.
+ *
+ * @generated from message norsk.api.media.MultipleContext
+ */
+export class MultipleContext extends Message<MultipleContext> {
+  /**
+   * @generated from field: repeated norsk.api.media.TaggedContext contexts = 1;
+   */
+  contexts: TaggedContext[] = [];
+
+  /**
+   * The reference for acknowledging the context change
+   *
+   * @generated from field: string blocking_call_ref = 2;
+   */
+  blockingCallRef = "";
+
+  constructor(data?: PartialMessage<MultipleContext>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MultipleContext";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "contexts", kind: "message", T: TaggedContext, repeated: true },
+    { no: 2, name: "blocking_call_ref", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MultipleContext {
+    return new MultipleContext().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MultipleContext {
+    return new MultipleContext().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MultipleContext {
+    return new MultipleContext().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MultipleContext | PlainMessage<MultipleContext> | undefined, b: MultipleContext | PlainMessage<MultipleContext> | undefined): boolean {
+    return proto3.util.equals(MultipleContext, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.TaggedContext
+ */
+export class TaggedContext extends Message<TaggedContext> {
+  /**
+   * The set of streams
+   *
+   * @generated from field: repeated norsk.api.media.StreamMetadata streams = 1;
+   */
+  streams: StreamMetadata[] = [];
+
+  /**
+   * @generated from field: norsk.api.media.InputPin pin = 2;
+   */
+  pin?: InputPin;
+
+  constructor(data?: PartialMessage<TaggedContext>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.TaggedContext";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "streams", kind: "message", T: StreamMetadata, repeated: true },
+    { no: 2, name: "pin", kind: "message", T: InputPin },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TaggedContext {
+    return new TaggedContext().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TaggedContext {
+    return new TaggedContext().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TaggedContext {
+    return new TaggedContext().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: TaggedContext | PlainMessage<TaggedContext> | undefined, b: TaggedContext | PlainMessage<TaggedContext> | undefined): boolean {
+    return proto3.util.equals(TaggedContext, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.BlockingCallRef
  */
@@ -2924,6 +3024,14 @@ export class MultiStreamStatistics extends Message<MultiStreamStatistics> {
    */
   allStreams: MultiStreamStatistics_SingleStreamStatistics[] = [];
 
+  /**
+   * Either `"default"`, if there is only one direction, or `"input"`/`"output"`
+   * (for duplex nodes, where there are two directions)
+   *
+   * @generated from field: string label = 3;
+   */
+  label = "";
+
   constructor(data?: PartialMessage<MultiStreamStatistics>) {
     super();
     proto3.util.initPartial(data, this);
@@ -2934,6 +3042,7 @@ export class MultiStreamStatistics extends Message<MultiStreamStatistics> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "sample_size_seconds", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
     { no: 2, name: "all_streams", kind: "message", T: MultiStreamStatistics_SingleStreamStatistics, repeated: true },
+    { no: 3, name: "label", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MultiStreamStatistics {
@@ -3614,6 +3723,186 @@ export class RtmpOnStream extends Message<RtmpOnStream> {
   }
 }
 
+/**
+ * *
+ * Sent to your code when an error is detected on an active connection.
+ * Typically you will receive a disconnected event immediately after
+ *
+ * @generated from message norsk.api.media.RtmpError
+ */
+export class RtmpError extends Message<RtmpError> {
+  /**
+   * @generated from field: norsk.api.media.ConnectionId connection_id = 1;
+   */
+  connectionId?: ConnectionId;
+
+  /**
+   * @generated from oneof norsk.api.media.RtmpError.error
+   */
+  error: {
+    /**
+     * @generated from field: norsk.api.media.RtmpError.UnsupportedVideo unsupported_video = 2;
+     */
+    value: RtmpError_UnsupportedVideo;
+    case: "unsupportedVideo";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.RtmpError.UnsupportedAudio unsupported_audio = 3;
+     */
+    value: RtmpError_UnsupportedAudio;
+    case: "unsupportedAudio";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<RtmpError>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.RtmpError";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "connection_id", kind: "message", T: ConnectionId },
+    { no: 2, name: "unsupported_video", kind: "message", T: RtmpError_UnsupportedVideo, oneof: "error" },
+    { no: 3, name: "unsupported_audio", kind: "message", T: RtmpError_UnsupportedAudio, oneof: "error" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpError {
+    return new RtmpError().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtmpError {
+    return new RtmpError().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtmpError {
+    return new RtmpError().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: RtmpError | PlainMessage<RtmpError> | undefined, b: RtmpError | PlainMessage<RtmpError> | undefined): boolean {
+    return proto3.util.equals(RtmpError, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.RtmpError.UnsupportedVideo
+ */
+export class RtmpError_UnsupportedVideo extends Message<RtmpError_UnsupportedVideo> {
+  /**
+   * @generated from field: string type = 1;
+   */
+  type = "";
+
+  constructor(data?: PartialMessage<RtmpError_UnsupportedVideo>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.RtmpError.UnsupportedVideo";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpError_UnsupportedVideo {
+    return new RtmpError_UnsupportedVideo().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtmpError_UnsupportedVideo {
+    return new RtmpError_UnsupportedVideo().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtmpError_UnsupportedVideo {
+    return new RtmpError_UnsupportedVideo().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: RtmpError_UnsupportedVideo | PlainMessage<RtmpError_UnsupportedVideo> | undefined, b: RtmpError_UnsupportedVideo | PlainMessage<RtmpError_UnsupportedVideo> | undefined): boolean {
+    return proto3.util.equals(RtmpError_UnsupportedVideo, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.RtmpError.UnsupportedAudio
+ */
+export class RtmpError_UnsupportedAudio extends Message<RtmpError_UnsupportedAudio> {
+  /**
+   * @generated from field: string type = 1;
+   */
+  type = "";
+
+  constructor(data?: PartialMessage<RtmpError_UnsupportedAudio>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.RtmpError.UnsupportedAudio";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpError_UnsupportedAudio {
+    return new RtmpError_UnsupportedAudio().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtmpError_UnsupportedAudio {
+    return new RtmpError_UnsupportedAudio().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtmpError_UnsupportedAudio {
+    return new RtmpError_UnsupportedAudio().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: RtmpError_UnsupportedAudio | PlainMessage<RtmpError_UnsupportedAudio> | undefined, b: RtmpError_UnsupportedAudio | PlainMessage<RtmpError_UnsupportedAudio> | undefined): boolean {
+    return proto3.util.equals(RtmpError_UnsupportedAudio, a, b);
+  }
+}
+
+/**
+ * *
+ * Sent to your code when a bytes-read report is received from the peer
+ *
+ * @generated from message norsk.api.media.RtmpBytesRead
+ */
+export class RtmpBytesRead extends Message<RtmpBytesRead> {
+  /**
+   * @generated from field: norsk.api.media.ConnectionId connection_id = 1;
+   */
+  connectionId?: ConnectionId;
+
+  /**
+   * @generated from field: int64 bytes_read = 2;
+   */
+  bytesRead = protoInt64.zero;
+
+  constructor(data?: PartialMessage<RtmpBytesRead>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.RtmpBytesRead";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "connection_id", kind: "message", T: ConnectionId },
+    { no: 2, name: "bytes_read", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpBytesRead {
+    return new RtmpBytesRead().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtmpBytesRead {
+    return new RtmpBytesRead().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtmpBytesRead {
+    return new RtmpBytesRead().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: RtmpBytesRead | PlainMessage<RtmpBytesRead> | undefined, b: RtmpBytesRead | PlainMessage<RtmpBytesRead> | undefined): boolean {
+    return proto3.util.equals(RtmpBytesRead, a, b);
+  }
+}
+
 /**
  * *
  * Messages that Norsk can send to your code in response to various RTMP
@@ -3661,6 +3950,18 @@ export class RtmpServerInputEvent extends Message<RtmpServerInputEvent> {
      */
     value: MultiStreamStatistics;
     case: "streamStatistics";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.RtmpError error = 7;
+     */
+    value: RtmpError;
+    case: "error";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.RtmpBytesRead bytes_read = 8;
+     */
+    value: RtmpBytesRead;
+    case: "bytesRead";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<RtmpServerInputEvent>) {
@@ -3677,6 +3978,8 @@ export class RtmpServerInputEvent extends Message<RtmpServerInputEvent> {
     { no: 4, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
     { no: 5, name: "status", kind: "message", T: RtmpServerInputStatus, oneof: "message" },
     { no: 6, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
+    { no: 7, name: "error", kind: "message", T: RtmpError, oneof: "message" },
+    { no: 8, name: "bytes_read", kind: "message", T: RtmpBytesRead, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpServerInputEvent {
@@ -4049,6 +4352,13 @@ export class FileTsInputConfiguration extends Message<FileTsInputConfiguration>
    */
   statsSampling?: StreamStatisticsSampling;
 
+  /**
+   * Loop back to play the start after reaching the end of the file
+   *
+   * @generated from field: bool loop = 5;
+   */
+  loop = false;
+
   constructor(data?: PartialMessage<FileTsInputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -4061,6 +4371,7 @@ export class FileTsInputConfiguration extends Message<FileTsInputConfiguration>
     { no: 2, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "filename", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 4, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 5, name: "loop", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileTsInputConfiguration {
@@ -5759,6 +6070,13 @@ export class FileMp4InputConfiguration extends Message<FileMp4InputConfiguration
    */
   statsSampling?: StreamStatisticsSampling;
 
+  /**
+   * Loop back to play the start after reaching the end of the file
+   *
+   * @generated from field: bool loop = 5;
+   */
+  loop = false;
+
   constructor(data?: PartialMessage<FileMp4InputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -5771,6 +6089,7 @@ export class FileMp4InputConfiguration extends Message<FileMp4InputConfiguration
     { no: 2, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 4, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 5, name: "loop", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputConfiguration {
@@ -6676,6 +6995,96 @@ export class BrowserInputEvent extends Message<BrowserInputEvent> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.WebRtcIceServerConfiguration
+ */
+export class WebRtcIceServerConfiguration extends Message<WebRtcIceServerConfiguration> {
+  /**
+   * @generated from field: repeated norsk.api.media.WebRtcIceServer servers = 1;
+   */
+  servers: WebRtcIceServer[] = [];
+
+  constructor(data?: PartialMessage<WebRtcIceServerConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.WebRtcIceServerConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "servers", kind: "message", T: WebRtcIceServer, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRtcIceServerConfiguration {
+    return new WebRtcIceServerConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRtcIceServerConfiguration {
+    return new WebRtcIceServerConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRtcIceServerConfiguration {
+    return new WebRtcIceServerConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: WebRtcIceServerConfiguration | PlainMessage<WebRtcIceServerConfiguration> | undefined, b: WebRtcIceServerConfiguration | PlainMessage<WebRtcIceServerConfiguration> | undefined): boolean {
+    return proto3.util.equals(WebRtcIceServerConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.WebRtcIceServer
+ */
+export class WebRtcIceServer extends Message<WebRtcIceServer> {
+  /**
+   * @generated from field: repeated string urls = 1;
+   */
+  urls: string[] = [];
+
+  /**
+   * The username to use when logging into a TURN server. Ignored otherwise.
+   *
+   * @generated from field: string username = 2;
+   */
+  username = "";
+
+  /**
+   * The username to use when logging into a TURN server. Ignored otherwise.
+   *
+   * @generated from field: string credential = 3;
+   */
+  credential = "";
+
+  constructor(data?: PartialMessage<WebRtcIceServer>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.WebRtcIceServer";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "urls", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+    { no: 2, name: "username", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "credential", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRtcIceServer {
+    return new WebRtcIceServer().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRtcIceServer {
+    return new WebRtcIceServer().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRtcIceServer {
+    return new WebRtcIceServer().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: WebRtcIceServer | PlainMessage<WebRtcIceServer> | undefined, b: WebRtcIceServer | PlainMessage<WebRtcIceServer> | undefined): boolean {
+    return proto3.util.equals(WebRtcIceServer, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.WhipInputConfiguration
  */
@@ -6695,6 +7104,13 @@ export class WhipInputConfiguration extends Message<WhipInputConfiguration> {
    */
   statsSampling?: StreamStatisticsSampling;
 
+  /**
+   * Optionally configure ICE servers (STUN/TURN)
+   *
+   * @generated from field: norsk.api.media.WebRtcIceServerConfiguration ice_server_configuration = 4;
+   */
+  iceServerConfiguration?: WebRtcIceServerConfiguration;
+
   constructor(data?: PartialMessage<WhipInputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -6706,6 +7122,7 @@ export class WhipInputConfiguration extends Message<WhipInputConfiguration> {
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 4, name: "ice_server_configuration", kind: "message", T: WebRtcIceServerConfiguration },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhipInputConfiguration {
@@ -6961,7 +7378,8 @@ export class ComposePart extends Message<ComposePart> {
    * in percentage terms, or a notional resolution can be used that is
    * independant of the source resolutions that may be provided.
    *
-   * If unset, this will be overriden by a global reference resolution if present
+   * If unset, this will be overriden by a global reference resolution if
+   * present
    *
    *
    * @generated from field: norsk.api.media.Resolution reference_resolution = 8;
@@ -7263,10 +7681,10 @@ export class VideoComposeConfiguration extends Message<VideoComposeConfiguration
   parts: ComposePart[] = [];
 
   /**
-   * * Optionally supply a fallback reference resolution. This allows description of the
-   * composition in a desired coordinate system, e.g. a resolution of 100x100
-   * can be specified to allow the source and destination areas to be described
-   * in percentage terms, or a notional resolution can be used that is
+   * * Optionally supply a fallback reference resolution. This allows description
+   * of the composition in a desired coordinate system, e.g. a resolution of
+   * 100x100 can be specified to allow the source and destination areas to be
+   * described in percentage terms, or a notional resolution can be used that is
    * independant of the source resolutions that may be provided.
    *
    * if set here, this reference resolution will be applied to
@@ -8764,7 +9182,17 @@ export class Mp4Encryption extends Message<Mp4Encryption> {
    */
   encryptionKey = "";
 
-  constructor(data?: PartialMessage<Mp4Encryption>) {
+  /**
+   * @generated from field: string encryption_pssh = 3;
+   */
+  encryptionPssh = "";
+
+  /**
+   * @generated from field: norsk.api.media.Mp4Encryption.Mp4EncryptionScheme encryption_scheme = 4;
+   */
+  encryptionScheme = Mp4Encryption_Mp4EncryptionScheme.CBCS;
+
+  constructor(data?: PartialMessage<Mp4Encryption>) {
     super();
     proto3.util.initPartial(data, this);
   }
@@ -8774,6 +9202,8 @@ export class Mp4Encryption extends Message<Mp4Encryption> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "encryption_key_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 2, name: "encryption_key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "encryption_pssh", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "encryption_scheme", kind: "enum", T: proto3.getEnumType(Mp4Encryption_Mp4EncryptionScheme) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mp4Encryption {
@@ -8793,6 +9223,26 @@ export class Mp4Encryption extends Message<Mp4Encryption> {
   }
 }
 
+/**
+ * @generated from enum norsk.api.media.Mp4Encryption.Mp4EncryptionScheme
+ */
+export enum Mp4Encryption_Mp4EncryptionScheme {
+  /**
+   * @generated from enum value: MP4_ENCRYPTION_SCHEME_CBCS = 0;
+   */
+  CBCS = 0,
+
+  /**
+   * @generated from enum value: MP4_ENCRYPTION_SCHEME_CENC = 1;
+   */
+  CENC = 1,
+}
+// Retrieve enum metadata with: proto3.getEnumType(Mp4Encryption_Mp4EncryptionScheme)
+proto3.util.setEnumType(Mp4Encryption_Mp4EncryptionScheme, "norsk.api.media.Mp4Encryption.Mp4EncryptionScheme", [
+  { no: 0, name: "MP4_ENCRYPTION_SCHEME_CBCS" },
+  { no: 1, name: "MP4_ENCRYPTION_SCHEME_CENC" },
+]);
+
 /**
  * @generated from message norsk.api.media.AwsS3PushDestination
  */
@@ -9128,6 +9578,11 @@ export class HlsTsVideoConfiguration extends Message<HlsTsVideoConfiguration> {
    */
   statsSampling?: StreamStatisticsSampling;
 
+  /**
+   * @generated from field: repeated norsk.api.media.CMAFDestination destinations = 5;
+   */
+  destinations: CMAFDestination[] = [];
+
   constructor(data?: PartialMessage<HlsTsVideoConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -9140,6 +9595,7 @@ export class HlsTsVideoConfiguration extends Message<HlsTsVideoConfiguration> {
     { no: 2, name: "segment_duration_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 3, name: "delay_output_ms", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 4, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 5, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsVideoConfiguration {
@@ -9178,6 +9634,12 @@ export class HlsTsVideoMessage extends Message<HlsTsVideoMessage> {
      */
     value: HlsTsVideoConfiguration;
     case: "configuration";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.UpdateCredentials update_credentials = 3;
+     */
+    value: UpdateCredentials;
+    case: "updateCredentials";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<HlsTsVideoMessage>) {
@@ -9190,6 +9652,7 @@ export class HlsTsVideoMessage extends Message<HlsTsVideoMessage> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
     { no: 2, name: "configuration", kind: "message", T: HlsTsVideoConfiguration, oneof: "message" },
+    { no: 3, name: "update_credentials", kind: "message", T: UpdateCredentials, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsVideoMessage {
@@ -9363,6 +9826,11 @@ export class HlsTsAudioConfiguration extends Message<HlsTsAudioConfiguration> {
    */
   statsSampling?: StreamStatisticsSampling;
 
+  /**
+   * @generated from field: repeated norsk.api.media.CMAFDestination destinations = 5;
+   */
+  destinations: CMAFDestination[] = [];
+
   constructor(data?: PartialMessage<HlsTsAudioConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -9375,6 +9843,7 @@ export class HlsTsAudioConfiguration extends Message<HlsTsAudioConfiguration> {
     { no: 2, name: "segment_duration_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 3, name: "delay_output_ms", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 4, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 5, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsAudioConfiguration {
@@ -9413,6 +9882,12 @@ export class HlsTsAudioMessage extends Message<HlsTsAudioMessage> {
      */
     value: HlsTsAudioConfiguration;
     case: "configuration";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.UpdateCredentials update_credentials = 3;
+     */
+    value: UpdateCredentials;
+    case: "updateCredentials";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<HlsTsAudioMessage>) {
@@ -9425,6 +9900,7 @@ export class HlsTsAudioMessage extends Message<HlsTsAudioMessage> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
     { no: 2, name: "configuration", kind: "message", T: HlsTsAudioConfiguration, oneof: "message" },
+    { no: 3, name: "update_credentials", kind: "message", T: UpdateCredentials, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsAudioMessage {
@@ -9464,9 +9940,24 @@ export class CmafWebVttConfiguration extends Message<CmafWebVttConfiguration> {
   delayOutputMs = 0;
 
   /**
-   * @generated from field: string sessionId = 4;
+   * @generated from field: repeated norsk.api.media.CMAFDestination destinations = 5;
    */
-  sessionId = "";
+  destinations: CMAFDestination[] = [];
+
+  /**
+   * @generated from field: string hls_cache_directory = 6;
+   */
+  hlsCacheDirectory = "";
+
+  /**
+   * @generated from field: uint32 maximum_playlist_segments = 7;
+   */
+  maximumPlaylistSegments = 0;
+
+  /**
+   * @generated from field: norsk.api.media.Interval pts_adjustment = 8;
+   */
+  ptsAdjustment?: Interval;
 
   constructor(data?: PartialMessage<CmafWebVttConfiguration>) {
     super();
@@ -9479,7 +9970,10 @@ export class CmafWebVttConfiguration extends Message<CmafWebVttConfiguration> {
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "segment_duration_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 3, name: "delay_output_ms", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
-    { no: 4, name: "sessionId", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 5, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
+    { no: 6, name: "hls_cache_directory", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 7, name: "maximum_playlist_segments", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 8, name: "pts_adjustment", kind: "message", T: Interval },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafWebVttConfiguration {
@@ -9499,6 +9993,70 @@ export class CmafWebVttConfiguration extends Message<CmafWebVttConfiguration> {
   }
 }
 
+/**
+ * TODO rethink this, not exposed to SDK yet
+ * Only credentials are updateable
+ *
+ * @generated from message norsk.api.media.CmafWebVttUpdateConfiguration
+ */
+export class CmafWebVttUpdateConfiguration extends Message<CmafWebVttUpdateConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * @generated from field: float retention_period_seconds = 2;
+   */
+  retentionPeriodSeconds = 0;
+
+  /**
+   * @generated from field: uint32 maximum_playlist_segments = 3;
+   */
+  maximumPlaylistSegments = 0;
+
+  /**
+   * @generated from field: norsk.api.media.Interval pts_adjustment = 4;
+   */
+  ptsAdjustment?: Interval;
+
+  /**
+   * @generated from field: norsk.api.media.UpdateCredentials update_credentials = 5;
+   */
+  updateCredentials?: UpdateCredentials;
+
+  constructor(data?: PartialMessage<CmafWebVttUpdateConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.CmafWebVttUpdateConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "retention_period_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
+    { no: 3, name: "maximum_playlist_segments", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 4, name: "pts_adjustment", kind: "message", T: Interval },
+    { no: 5, name: "update_credentials", kind: "message", T: UpdateCredentials },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafWebVttUpdateConfiguration {
+    return new CmafWebVttUpdateConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafWebVttUpdateConfiguration {
+    return new CmafWebVttUpdateConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafWebVttUpdateConfiguration {
+    return new CmafWebVttUpdateConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: CmafWebVttUpdateConfiguration | PlainMessage<CmafWebVttUpdateConfiguration> | undefined, b: CmafWebVttUpdateConfiguration | PlainMessage<CmafWebVttUpdateConfiguration> | undefined): boolean {
+    return proto3.util.equals(CmafWebVttUpdateConfiguration, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.AwsCredentials
  */
@@ -9591,140 +10149,6 @@ export class UpdateCredentials extends Message<UpdateCredentials> {
   }
 }
 
-/**
- * @generated from message norsk.api.media.HlsWebVttPushConfiguration
- */
-export class HlsWebVttPushConfiguration extends Message<HlsWebVttPushConfiguration> {
-  /**
-   * @generated from field: norsk.api.media.MediaNodeId id = 1;
-   */
-  id?: MediaNodeId;
-
-  /**
-   * @generated from field: float segment_duration_seconds = 2;
-   */
-  segmentDurationSeconds = 0;
-
-  /**
-   * @generated from field: float delay_output_ms = 3;
-   */
-  delayOutputMs = 0;
-
-  /**
-   * @generated from field: norsk.api.media.CMAFDestination destination = 4;
-   */
-  destination?: CMAFDestination;
-
-  /**
-   * @generated from field: float retention_period_s = 6;
-   */
-  retentionPeriodS = 0;
-
-  /**
-   * @generated from field: string hls_cache_directory = 7;
-   */
-  hlsCacheDirectory = "";
-
-  /**
-   * @generated from field: uint32 maximum_playlist_segments = 8;
-   */
-  maximumPlaylistSegments = 0;
-
-  /**
-   * @generated from field: norsk.api.media.Interval pts_adjustment = 9;
-   */
-  ptsAdjustment?: Interval;
-
-  constructor(data?: PartialMessage<HlsWebVttPushConfiguration>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsWebVttPushConfiguration";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "id", kind: "message", T: MediaNodeId },
-    { no: 2, name: "segment_duration_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
-    { no: 3, name: "delay_output_ms", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
-    { no: 4, name: "destination", kind: "message", T: CMAFDestination },
-    { no: 6, name: "retention_period_s", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
-    { no: 7, name: "hls_cache_directory", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 8, name: "maximum_playlist_segments", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-    { no: 9, name: "pts_adjustment", kind: "message", T: Interval },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsWebVttPushConfiguration {
-    return new HlsWebVttPushConfiguration().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsWebVttPushConfiguration {
-    return new HlsWebVttPushConfiguration().fromJson(jsonValue, options);
-  }
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsWebVttPushConfiguration {
-    return new HlsWebVttPushConfiguration().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: HlsWebVttPushConfiguration | PlainMessage<HlsWebVttPushConfiguration> | undefined, b: HlsWebVttPushConfiguration | PlainMessage<HlsWebVttPushConfiguration> | undefined): boolean {
-    return proto3.util.equals(HlsWebVttPushConfiguration, a, b);
-  }
-}
-
-/**
- * @generated from message norsk.api.media.HlsWebVttPushUpdateConfiguration
- */
-export class HlsWebVttPushUpdateConfiguration extends Message<HlsWebVttPushUpdateConfiguration> {
-  /**
-   * @generated from field: norsk.api.media.MediaNodeId id = 1;
-   */
-  id?: MediaNodeId;
-
-  /**
-   * @generated from field: float retention_period_s = 2;
-   */
-  retentionPeriodS = 0;
-
-  /**
-   * @generated from field: uint32 maximum_playlist_segments = 3;
-   */
-  maximumPlaylistSegments = 0;
-
-  /**
-   * @generated from field: norsk.api.media.Interval pts_adjustment = 4;
-   */
-  ptsAdjustment?: Interval;
-
-  constructor(data?: PartialMessage<HlsWebVttPushUpdateConfiguration>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsWebVttPushUpdateConfiguration";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "id", kind: "message", T: MediaNodeId },
-    { no: 2, name: "retention_period_s", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
-    { no: 3, name: "maximum_playlist_segments", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-    { no: 4, name: "pts_adjustment", kind: "message", T: Interval },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsWebVttPushUpdateConfiguration {
-    return new HlsWebVttPushUpdateConfiguration().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsWebVttPushUpdateConfiguration {
-    return new HlsWebVttPushUpdateConfiguration().fromJson(jsonValue, options);
-  }
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsWebVttPushUpdateConfiguration {
-    return new HlsWebVttPushUpdateConfiguration().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: HlsWebVttPushUpdateConfiguration | PlainMessage<HlsWebVttPushUpdateConfiguration> | undefined, b: HlsWebVttPushUpdateConfiguration | PlainMessage<HlsWebVttPushUpdateConfiguration> | undefined): boolean {
-    return proto3.util.equals(HlsWebVttPushUpdateConfiguration, a, b);
-  }
-}
-
 /**
  * @generated from message norsk.api.media.CmafWebVttMessage
  */
@@ -9744,6 +10168,18 @@ export class CmafWebVttMessage extends Message<CmafWebVttMessage> {
      */
     value: CmafWebVttConfiguration;
     case: "configuration";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.CmafWebVttUpdateConfiguration update_config = 3;
+     */
+    value: CmafWebVttUpdateConfiguration;
+    case: "updateConfig";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.UpdateCredentials update_credentials = 4;
+     */
+    value: UpdateCredentials;
+    case: "updateCredentials";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<CmafWebVttMessage>) {
@@ -9756,6 +10192,8 @@ export class CmafWebVttMessage extends Message<CmafWebVttMessage> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
     { no: 2, name: "configuration", kind: "message", T: CmafWebVttConfiguration, oneof: "message" },
+    { no: 3, name: "update_config", kind: "message", T: CmafWebVttUpdateConfiguration, oneof: "message" },
+    { no: 4, name: "update_credentials", kind: "message", T: UpdateCredentials, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafWebVttMessage {
@@ -9775,63 +10213,6 @@ export class CmafWebVttMessage extends Message<CmafWebVttMessage> {
   }
 }
 
-/**
- * @generated from message norsk.api.media.HlsWebVttPushMessage
- */
-export class HlsWebVttPushMessage extends Message<HlsWebVttPushMessage> {
-  /**
-   * @generated from oneof norsk.api.media.HlsWebVttPushMessage.message
-   */
-  message: {
-    /**
-     * @generated from field: norsk.api.media.Subscription subscription = 1;
-     */
-    value: Subscription;
-    case: "subscription";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.HlsWebVttPushConfiguration configuration = 2;
-     */
-    value: HlsWebVttPushConfiguration;
-    case: "configuration";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.HlsWebVttPushUpdateConfiguration update_config = 3;
-     */
-    value: HlsWebVttPushUpdateConfiguration;
-    case: "updateConfig";
-  } | { case: undefined; value?: undefined } = { case: undefined };
-
-  constructor(data?: PartialMessage<HlsWebVttPushMessage>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsWebVttPushMessage";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
-    { no: 2, name: "configuration", kind: "message", T: HlsWebVttPushConfiguration, oneof: "message" },
-    { no: 3, name: "update_config", kind: "message", T: HlsWebVttPushUpdateConfiguration, oneof: "message" },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsWebVttPushMessage {
-    return new HlsWebVttPushMessage().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsWebVttPushMessage {
-    return new HlsWebVttPushMessage().fromJson(jsonValue, options);
-  }
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsWebVttPushMessage {
-    return new HlsWebVttPushMessage().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: HlsWebVttPushMessage | PlainMessage<HlsWebVttPushMessage> | undefined, b: HlsWebVttPushMessage | PlainMessage<HlsWebVttPushMessage> | undefined): boolean {
-    return proto3.util.equals(HlsWebVttPushMessage, a, b);
-  }
-}
-
 /**
  * @generated from message norsk.api.media.CmafMasterConfiguration
  */
@@ -9945,355 +10326,28 @@ export class CmafMasterMessage extends Message<CmafMasterMessage> {
 }
 
 /**
- * @generated from message norsk.api.media.HlsMasterPushConfiguration
+ * @generated from message norsk.api.media.HlsTsCombinedPushConfiguration
  */
-export class HlsMasterPushConfiguration extends Message<HlsMasterPushConfiguration> {
+export class HlsTsCombinedPushConfiguration extends Message<HlsTsCombinedPushConfiguration> {
   /**
    * @generated from field: norsk.api.media.MediaNodeId id = 1;
    */
   id?: MediaNodeId;
 
   /**
-   * @generated from field: string playlist_name = 2;
+   * @generated from field: norsk.api.media.CMAFDestination destination = 2;
    */
-  playlistName = "";
+  destination?: CMAFDestination;
 
   /**
-   * @generated from field: norsk.api.media.CMAFDestination destination = 3;
+   * @generated from field: float segment_duration_seconds = 3;
    */
-  destination?: CMAFDestination;
+  segmentDurationSeconds = 0;
 
   /**
-   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
+   * @generated from field: float delay_output_ms = 4;
    */
-  statsSampling?: StreamStatisticsSampling;
-
-  constructor(data?: PartialMessage<HlsMasterPushConfiguration>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsMasterPushConfiguration";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "id", kind: "message", T: MediaNodeId },
-    { no: 2, name: "playlist_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: "destination", kind: "message", T: CMAFDestination },
-    { no: 4, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsMasterPushConfiguration {
-    return new HlsMasterPushConfiguration().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsMasterPushConfiguration {
-    return new HlsMasterPushConfiguration().fromJson(jsonValue, options);
-  }
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsMasterPushConfiguration {
-    return new HlsMasterPushConfiguration().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: HlsMasterPushConfiguration | PlainMessage<HlsMasterPushConfiguration> | undefined, b: HlsMasterPushConfiguration | PlainMessage<HlsMasterPushConfiguration> | undefined): boolean {
-    return proto3.util.equals(HlsMasterPushConfiguration, a, b);
-  }
-}
-
-/**
- * @generated from message norsk.api.media.HlsMasterPushMessage
- */
-export class HlsMasterPushMessage extends Message<HlsMasterPushMessage> {
-  /**
-   * @generated from oneof norsk.api.media.HlsMasterPushMessage.message
-   */
-  message: {
-    /**
-     * @generated from field: norsk.api.media.Subscription subscription = 1;
-     */
-    value: Subscription;
-    case: "subscription";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.HlsMasterPushConfiguration configuration = 2;
-     */
-    value: HlsMasterPushConfiguration;
-    case: "configuration";
-  } | { case: undefined; value?: undefined } = { case: undefined };
-
-  constructor(data?: PartialMessage<HlsMasterPushMessage>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsMasterPushMessage";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
-    { no: 2, name: "configuration", kind: "message", T: HlsMasterPushConfiguration, oneof: "message" },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsMasterPushMessage {
-    return new HlsMasterPushMessage().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsMasterPushMessage {
-    return new HlsMasterPushMessage().fromJson(jsonValue, options);
-  }
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsMasterPushMessage {
-    return new HlsMasterPushMessage().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: HlsMasterPushMessage | PlainMessage<HlsMasterPushMessage> | undefined, b: HlsMasterPushMessage | PlainMessage<HlsMasterPushMessage> | undefined): boolean {
-    return proto3.util.equals(HlsMasterPushMessage, a, b);
-  }
-}
-
-/**
- * @generated from message norsk.api.media.HlsTsVideoPushConfiguration
- */
-export class HlsTsVideoPushConfiguration extends Message<HlsTsVideoPushConfiguration> {
-  /**
-   * @generated from field: norsk.api.media.MediaNodeId id = 1;
-   */
-  id?: MediaNodeId;
-
-  /**
-   * @generated from field: norsk.api.media.CMAFDestination destination = 2;
-   */
-  destination?: CMAFDestination;
-
-  /**
-   * @generated from field: float segment_duration_seconds = 3;
-   */
-  segmentDurationSeconds = 0;
-
-  /**
-   * @generated from field: float delay_output_ms = 4;
-   */
-  delayOutputMs = 0;
-
-  /**
-   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 5;
-   */
-  statsSampling?: StreamStatisticsSampling;
-
-  constructor(data?: PartialMessage<HlsTsVideoPushConfiguration>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsTsVideoPushConfiguration";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "id", kind: "message", T: MediaNodeId },
-    { no: 2, name: "destination", kind: "message", T: CMAFDestination },
-    { no: 3, name: "segment_duration_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
-    { no: 4, name: "delay_output_ms", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
-    { no: 5, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsVideoPushConfiguration {
-    return new HlsTsVideoPushConfiguration().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsTsVideoPushConfiguration {
-    return new HlsTsVideoPushConfiguration().fromJson(jsonValue, options);
-  }
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsTsVideoPushConfiguration {
-    return new HlsTsVideoPushConfiguration().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: HlsTsVideoPushConfiguration | PlainMessage<HlsTsVideoPushConfiguration> | undefined, b: HlsTsVideoPushConfiguration | PlainMessage<HlsTsVideoPushConfiguration> | undefined): boolean {
-    return proto3.util.equals(HlsTsVideoPushConfiguration, a, b);
-  }
-}
-
-/**
- * @generated from message norsk.api.media.HlsTsVideoPushMessage
- */
-export class HlsTsVideoPushMessage extends Message<HlsTsVideoPushMessage> {
-  /**
-   * @generated from oneof norsk.api.media.HlsTsVideoPushMessage.message
-   */
-  message: {
-    /**
-     * @generated from field: norsk.api.media.Subscription subscription = 1;
-     */
-    value: Subscription;
-    case: "subscription";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.HlsTsVideoPushConfiguration configuration = 2;
-     */
-    value: HlsTsVideoPushConfiguration;
-    case: "configuration";
-  } | { case: undefined; value?: undefined } = { case: undefined };
-
-  constructor(data?: PartialMessage<HlsTsVideoPushMessage>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsTsVideoPushMessage";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
-    { no: 2, name: "configuration", kind: "message", T: HlsTsVideoPushConfiguration, oneof: "message" },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsVideoPushMessage {
-    return new HlsTsVideoPushMessage().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsTsVideoPushMessage {
-    return new HlsTsVideoPushMessage().fromJson(jsonValue, options);
-  }
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsTsVideoPushMessage {
-    return new HlsTsVideoPushMessage().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: HlsTsVideoPushMessage | PlainMessage<HlsTsVideoPushMessage> | undefined, b: HlsTsVideoPushMessage | PlainMessage<HlsTsVideoPushMessage> | undefined): boolean {
-    return proto3.util.equals(HlsTsVideoPushMessage, a, b);
-  }
-}
-
-/**
- * @generated from message norsk.api.media.HlsTsAudioPushConfiguration
- */
-export class HlsTsAudioPushConfiguration extends Message<HlsTsAudioPushConfiguration> {
-  /**
-   * @generated from field: norsk.api.media.MediaNodeId id = 1;
-   */
-  id?: MediaNodeId;
-
-  /**
-   * @generated from field: norsk.api.media.CMAFDestination destination = 2;
-   */
-  destination?: CMAFDestination;
-
-  /**
-   * @generated from field: float segment_duration_seconds = 3;
-   */
-  segmentDurationSeconds = 0;
-
-  /**
-   * @generated from field: float delay_output_ms = 4;
-   */
-  delayOutputMs = 0;
-
-  /**
-   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 5;
-   */
-  statsSampling?: StreamStatisticsSampling;
-
-  constructor(data?: PartialMessage<HlsTsAudioPushConfiguration>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsTsAudioPushConfiguration";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "id", kind: "message", T: MediaNodeId },
-    { no: 2, name: "destination", kind: "message", T: CMAFDestination },
-    { no: 3, name: "segment_duration_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
-    { no: 4, name: "delay_output_ms", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
-    { no: 5, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsAudioPushConfiguration {
-    return new HlsTsAudioPushConfiguration().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsTsAudioPushConfiguration {
-    return new HlsTsAudioPushConfiguration().fromJson(jsonValue, options);
-  }
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsTsAudioPushConfiguration {
-    return new HlsTsAudioPushConfiguration().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: HlsTsAudioPushConfiguration | PlainMessage<HlsTsAudioPushConfiguration> | undefined, b: HlsTsAudioPushConfiguration | PlainMessage<HlsTsAudioPushConfiguration> | undefined): boolean {
-    return proto3.util.equals(HlsTsAudioPushConfiguration, a, b);
-  }
-}
-
-/**
- * @generated from message norsk.api.media.HlsTsAudioPushMessage
- */
-export class HlsTsAudioPushMessage extends Message<HlsTsAudioPushMessage> {
-  /**
-   * @generated from oneof norsk.api.media.HlsTsAudioPushMessage.message
-   */
-  message: {
-    /**
-     * @generated from field: norsk.api.media.Subscription subscription = 1;
-     */
-    value: Subscription;
-    case: "subscription";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.HlsTsAudioPushConfiguration configuration = 2;
-     */
-    value: HlsTsAudioPushConfiguration;
-    case: "configuration";
-  } | { case: undefined; value?: undefined } = { case: undefined };
-
-  constructor(data?: PartialMessage<HlsTsAudioPushMessage>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsTsAudioPushMessage";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
-    { no: 2, name: "configuration", kind: "message", T: HlsTsAudioPushConfiguration, oneof: "message" },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsAudioPushMessage {
-    return new HlsTsAudioPushMessage().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsTsAudioPushMessage {
-    return new HlsTsAudioPushMessage().fromJson(jsonValue, options);
-  }
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsTsAudioPushMessage {
-    return new HlsTsAudioPushMessage().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: HlsTsAudioPushMessage | PlainMessage<HlsTsAudioPushMessage> | undefined, b: HlsTsAudioPushMessage | PlainMessage<HlsTsAudioPushMessage> | undefined): boolean {
-    return proto3.util.equals(HlsTsAudioPushMessage, a, b);
-  }
-}
-
-/**
- * @generated from message norsk.api.media.HlsTsCombinedPushConfiguration
- */
-export class HlsTsCombinedPushConfiguration extends Message<HlsTsCombinedPushConfiguration> {
-  /**
-   * @generated from field: norsk.api.media.MediaNodeId id = 1;
-   */
-  id?: MediaNodeId;
-
-  /**
-   * @generated from field: norsk.api.media.CMAFDestination destination = 2;
-   */
-  destination?: CMAFDestination;
-
-  /**
-   * @generated from field: float segment_duration_seconds = 3;
-   */
-  segmentDurationSeconds = 0;
-
-  /**
-   * @generated from field: float delay_output_ms = 4;
-   */
-  delayOutputMs = 0;
+  delayOutputMs = 0;
 
   /**
    * @generated from field: string playlist_name = 5;
@@ -10994,18 +11048,89 @@ export class WhipOutputMessage extends Message<WhipOutputMessage> {
 }
 
 /**
- * @generated from message norsk.api.media.WebRTCBrowserDuplexConfiguration
+ * @generated from message norsk.api.media.WhipOutputEvent
  */
-export class WebRTCBrowserDuplexConfiguration extends Message<WebRTCBrowserDuplexConfiguration> {
-  /**
-   * @generated from field: norsk.api.media.MediaNodeId id = 1;
-   */
-  id?: MediaNodeId;
-
+export class WhipOutputEvent extends Message<WhipOutputEvent> {
   /**
-   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 2;
+   * @generated from oneof norsk.api.media.WhipOutputEvent.message
    */
-  statsSampling?: StreamStatisticsSampling;
+  message: {
+    /**
+     * @generated from field: norsk.api.media.MediaNodeId node_id = 1;
+     */
+    value: MediaNodeId;
+    case: "nodeId";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 2;
+     */
+    value: SubscriptionResponse;
+    case: "subscriptionResponse";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context inbound_context = 3;
+     */
+    value: Context;
+    case: "inboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 4;
+     */
+    value: MultiStreamStatistics;
+    case: "streamStatistics";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<WhipOutputEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.WhipOutputEvent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
+    { no: 2, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
+    { no: 3, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
+    { no: 4, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhipOutputEvent {
+    return new WhipOutputEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WhipOutputEvent {
+    return new WhipOutputEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WhipOutputEvent {
+    return new WhipOutputEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: WhipOutputEvent | PlainMessage<WhipOutputEvent> | undefined, b: WhipOutputEvent | PlainMessage<WhipOutputEvent> | undefined): boolean {
+    return proto3.util.equals(WhipOutputEvent, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.WebRTCBrowserDuplexConfiguration
+ */
+export class WebRTCBrowserDuplexConfiguration extends Message<WebRTCBrowserDuplexConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 2;
+   */
+  statsSampling?: StreamStatisticsSampling;
+
+  /**
+   * Optionally configure ICE servers (STUN/TURN)
+   *
+   * @generated from field: norsk.api.media.WebRtcIceServerConfiguration ice_server_configuration = 3;
+   */
+  iceServerConfiguration?: WebRtcIceServerConfiguration;
 
   constructor(data?: PartialMessage<WebRTCBrowserDuplexConfiguration>) {
     super();
@@ -11017,6 +11142,7 @@ export class WebRTCBrowserDuplexConfiguration extends Message<WebRTCBrowserDuple
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 3, name: "ice_server_configuration", kind: "message", T: WebRtcIceServerConfiguration },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRTCBrowserDuplexConfiguration {
@@ -11087,11 +11213,11 @@ export class WebRTCBrowserDuplexMessage extends Message<WebRTCBrowserDuplexMessa
 }
 
 /**
- * @generated from message norsk.api.media.WhipOutputEvent
+ * @generated from message norsk.api.media.WebRTCBrowserDuplexEvent
  */
-export class WhipOutputEvent extends Message<WhipOutputEvent> {
+export class WebRTCBrowserDuplexEvent extends Message<WebRTCBrowserDuplexEvent> {
   /**
-   * @generated from oneof norsk.api.media.WhipOutputEvent.message
+   * @generated from oneof norsk.api.media.WebRTCBrowserDuplexEvent.message
    */
   message: {
     /**
@@ -11113,49 +11239,157 @@ export class WhipOutputEvent extends Message<WhipOutputEvent> {
     case: "inboundContext";
   } | {
     /**
-     * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 4;
+     * @generated from field: norsk.api.media.Context outbound_context = 4;
+     */
+    value: Context;
+    case: "outboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 5;
      */
     value: MultiStreamStatistics;
     case: "streamStatistics";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<WhipOutputEvent>) {
+  constructor(data?: PartialMessage<WebRTCBrowserDuplexEvent>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.WhipOutputEvent";
+  static readonly typeName = "norsk.api.media.WebRTCBrowserDuplexEvent";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
     { no: 2, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
     { no: 3, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
-    { no: 4, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
+    { no: 4, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
+    { no: 5, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhipOutputEvent {
-    return new WhipOutputEvent().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRTCBrowserDuplexEvent {
+    return new WebRTCBrowserDuplexEvent().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WhipOutputEvent {
-    return new WhipOutputEvent().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRTCBrowserDuplexEvent {
+    return new WebRTCBrowserDuplexEvent().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WhipOutputEvent {
-    return new WhipOutputEvent().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRTCBrowserDuplexEvent {
+    return new WebRTCBrowserDuplexEvent().fromJsonString(jsonString, options);
   }
 
-  static equals(a: WhipOutputEvent | PlainMessage<WhipOutputEvent> | undefined, b: WhipOutputEvent | PlainMessage<WhipOutputEvent> | undefined): boolean {
-    return proto3.util.equals(WhipOutputEvent, a, b);
+  static equals(a: WebRTCBrowserDuplexEvent | PlainMessage<WebRTCBrowserDuplexEvent> | undefined, b: WebRTCBrowserDuplexEvent | PlainMessage<WebRTCBrowserDuplexEvent> | undefined): boolean {
+    return proto3.util.equals(WebRTCBrowserDuplexEvent, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.WebRTCBrowserDuplexEvent
+ * @generated from message norsk.api.media.WhepOutputConfiguration
  */
-export class WebRTCBrowserDuplexEvent extends Message<WebRTCBrowserDuplexEvent> {
+export class WhepOutputConfiguration extends Message<WhepOutputConfiguration> {
   /**
-   * @generated from oneof norsk.api.media.WebRTCBrowserDuplexEvent.message
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 2;
+   */
+  statsSampling?: StreamStatisticsSampling;
+
+  /**
+   * Optionally configure ICE servers (STUN/TURN)
+   *
+   * @generated from field: norsk.api.media.WebRtcIceServerConfiguration ice_server_configuration = 3;
+   */
+  iceServerConfiguration?: WebRtcIceServerConfiguration;
+
+  constructor(data?: PartialMessage<WhepOutputConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.WhepOutputConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 3, name: "ice_server_configuration", kind: "message", T: WebRtcIceServerConfiguration },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhepOutputConfiguration {
+    return new WhepOutputConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WhepOutputConfiguration {
+    return new WhepOutputConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WhepOutputConfiguration {
+    return new WhepOutputConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: WhepOutputConfiguration | PlainMessage<WhepOutputConfiguration> | undefined, b: WhepOutputConfiguration | PlainMessage<WhepOutputConfiguration> | undefined): boolean {
+    return proto3.util.equals(WhepOutputConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.WhepOutputMessage
+ */
+export class WhepOutputMessage extends Message<WhepOutputMessage> {
+  /**
+   * @generated from oneof norsk.api.media.WhepOutputMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Subscription subscription = 1;
+     */
+    value: Subscription;
+    case: "subscription";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.WhepOutputConfiguration configuration = 2;
+     */
+    value: WhepOutputConfiguration;
+    case: "configuration";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<WhepOutputMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.WhepOutputMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+    { no: 2, name: "configuration", kind: "message", T: WhepOutputConfiguration, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhepOutputMessage {
+    return new WhepOutputMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WhepOutputMessage {
+    return new WhepOutputMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WhepOutputMessage {
+    return new WhepOutputMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: WhepOutputMessage | PlainMessage<WhepOutputMessage> | undefined, b: WhepOutputMessage | PlainMessage<WhepOutputMessage> | undefined): boolean {
+    return proto3.util.equals(WhepOutputMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.WhepOutputEvent
+ */
+export class WhepOutputEvent extends Message<WhepOutputEvent> {
+  /**
+   * @generated from oneof norsk.api.media.WhepOutputEvent.message
    */
   message: {
     /**
@@ -11177,47 +11411,40 @@ export class WebRTCBrowserDuplexEvent extends Message<WebRTCBrowserDuplexEvent>
     case: "inboundContext";
   } | {
     /**
-     * @generated from field: norsk.api.media.Context outbound_context = 4;
-     */
-    value: Context;
-    case: "outboundContext";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 5;
+     * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 4;
      */
     value: MultiStreamStatistics;
     case: "streamStatistics";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<WebRTCBrowserDuplexEvent>) {
+  constructor(data?: PartialMessage<WhepOutputEvent>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.WebRTCBrowserDuplexEvent";
+  static readonly typeName = "norsk.api.media.WhepOutputEvent";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
     { no: 2, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
     { no: 3, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
-    { no: 4, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
-    { no: 5, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
+    { no: 4, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRTCBrowserDuplexEvent {
-    return new WebRTCBrowserDuplexEvent().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhepOutputEvent {
+    return new WhepOutputEvent().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRTCBrowserDuplexEvent {
-    return new WebRTCBrowserDuplexEvent().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WhepOutputEvent {
+    return new WhepOutputEvent().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRTCBrowserDuplexEvent {
-    return new WebRTCBrowserDuplexEvent().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WhepOutputEvent {
+    return new WhepOutputEvent().fromJsonString(jsonString, options);
   }
 
-  static equals(a: WebRTCBrowserDuplexEvent | PlainMessage<WebRTCBrowserDuplexEvent> | undefined, b: WebRTCBrowserDuplexEvent | PlainMessage<WebRTCBrowserDuplexEvent> | undefined): boolean {
-    return proto3.util.equals(WebRTCBrowserDuplexEvent, a, b);
+  static equals(a: WhepOutputEvent | PlainMessage<WhepOutputEvent> | undefined, b: WhepOutputEvent | PlainMessage<WhepOutputEvent> | undefined): boolean {
+    return proto3.util.equals(WhepOutputEvent, a, b);
   }
 }
 
@@ -11567,12 +11794,17 @@ export class FileMp4OutputConfiguration extends Message<FileMp4OutputConfigurati
   nonfragmentedFileName = "";
 
   /**
-   * @generated from field: norsk.api.media.Mp4Encryption encryption = 4;
+   * @generated from field: norsk.api.media.Mp4Encryption audio_encryption = 4;
    */
-  encryption?: Mp4Encryption;
+  audioEncryption?: Mp4Encryption;
 
   /**
-   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 5;
+   * @generated from field: norsk.api.media.Mp4Encryption video_encryption = 5;
+   */
+  videoEncryption?: Mp4Encryption;
+
+  /**
+   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 6;
    */
   statsSampling?: StreamStatisticsSampling;
 
@@ -11587,8 +11819,9 @@ export class FileMp4OutputConfiguration extends Message<FileMp4OutputConfigurati
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "fragmented_file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "nonfragmented_file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 4, name: "encryption", kind: "message", T: Mp4Encryption },
-    { no: 5, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 4, name: "audio_encryption", kind: "message", T: Mp4Encryption },
+    { no: 5, name: "video_encryption", kind: "message", T: Mp4Encryption },
+    { no: 6, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4OutputConfiguration {
@@ -12800,16 +13033,28 @@ export class VideoEncodeStream extends Message<VideoEncodeStream> {
     case: "nvidiaHevc";
   } | {
     /**
-     * @generated from field: norsk.api.media.NetintH264 netintH264 = 9;
+     * @generated from field: norsk.api.media.LoganH264 loganH264 = 9;
      */
-    value: NetintH264;
-    case: "netintH264";
+    value: LoganH264;
+    case: "loganH264";
   } | {
     /**
-     * @generated from field: norsk.api.media.NetintHevc netintHevc = 10;
+     * @generated from field: norsk.api.media.LoganHevc loganHevc = 10;
      */
-    value: NetintHevc;
-    case: "netintHevc";
+    value: LoganHevc;
+    case: "loganHevc";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.QuadraH264 quadraH264 = 11;
+     */
+    value: QuadraH264;
+    case: "quadraH264";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.QuadraHevc quadraHevc = 12;
+     */
+    value: QuadraHevc;
+    case: "quadraHevc";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<VideoEncodeStream>) {
@@ -12828,8 +13073,10 @@ export class VideoEncodeStream extends Message<VideoEncodeStream> {
     { no: 6, name: "x265", kind: "message", T: X265Codec, oneof: "codec" },
     { no: 7, name: "nvidiaH264", kind: "message", T: NvidiaH264, oneof: "codec" },
     { no: 8, name: "nvidiaHevc", kind: "message", T: NvidiaHevc, oneof: "codec" },
-    { no: 9, name: "netintH264", kind: "message", T: NetintH264, oneof: "codec" },
-    { no: 10, name: "netintHevc", kind: "message", T: NetintHevc, oneof: "codec" },
+    { no: 9, name: "loganH264", kind: "message", T: LoganH264, oneof: "codec" },
+    { no: 10, name: "loganHevc", kind: "message", T: LoganHevc, oneof: "codec" },
+    { no: 11, name: "quadraH264", kind: "message", T: QuadraH264, oneof: "codec" },
+    { no: 12, name: "quadraHevc", kind: "message", T: QuadraHevc, oneof: "codec" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncodeStream {
@@ -13119,255 +13366,611 @@ export class NvidiaH264 extends Message<NvidiaH264> {
   gopInterval?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.OptionalInt idrPeriod = 3;
+   * @generated from field: norsk.api.media.OptionalInt idrPeriod = 3;
+   */
+  idrPeriod?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt frameIntervalP = 4;
+   */
+  frameIntervalP?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt maxNumRefFrames = 5;
+   */
+  maxNumRefFrames?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool outputAud = 6;
+   */
+  outputAud?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt level = 7;
+   */
+  level?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.NvidiaH264.NvidiaH264Profile profile = 8;
+   */
+  profile = NvidiaH264_NvidiaH264Profile.AUTO;
+
+  /**
+   * @generated from field: norsk.api.media.NvidiaRateControl rateControl = 9;
+   */
+  rateControl?: NvidiaRateControl;
+
+  constructor(data?: PartialMessage<NvidiaH264>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.NvidiaH264";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "preset", kind: "enum", T: proto3.getEnumType(NvidiaPreset) },
+    { no: 2, name: "gopInterval", kind: "message", T: OptionalInt },
+    { no: 3, name: "idrPeriod", kind: "message", T: OptionalInt },
+    { no: 4, name: "frameIntervalP", kind: "message", T: OptionalInt },
+    { no: 5, name: "maxNumRefFrames", kind: "message", T: OptionalInt },
+    { no: 6, name: "outputAud", kind: "message", T: OptionalBool },
+    { no: 7, name: "level", kind: "message", T: OptionalInt },
+    { no: 8, name: "profile", kind: "enum", T: proto3.getEnumType(NvidiaH264_NvidiaH264Profile) },
+    { no: 9, name: "rateControl", kind: "message", T: NvidiaRateControl },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NvidiaH264 {
+    return new NvidiaH264().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NvidiaH264 {
+    return new NvidiaH264().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NvidiaH264 {
+    return new NvidiaH264().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: NvidiaH264 | PlainMessage<NvidiaH264> | undefined, b: NvidiaH264 | PlainMessage<NvidiaH264> | undefined): boolean {
+    return proto3.util.equals(NvidiaH264, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.NvidiaH264.NvidiaH264Profile
+ */
+export enum NvidiaH264_NvidiaH264Profile {
+  /**
+   * @generated from enum value: NVIDIA_H264_PROFILE_AUTO = 0;
+   */
+  AUTO = 0,
+
+  /**
+   * @generated from enum value: NVIDIA_H264_PROFILE_BASELINE = 1;
+   */
+  BASELINE = 1,
+
+  /**
+   * @generated from enum value: NVIDIA_H264_PROFILE_MAIN = 2;
+   */
+  MAIN = 2,
+
+  /**
+   * @generated from enum value: NVIDIA_H264_PROFILE_HIGH = 4;
+   */
+  HIGH = 4,
+
+  /**
+   * @generated from enum value: NVIDIA_H264_PROFILE_HIGH444 = 7;
+   */
+  HIGH444 = 7,
+}
+// Retrieve enum metadata with: proto3.getEnumType(NvidiaH264_NvidiaH264Profile)
+proto3.util.setEnumType(NvidiaH264_NvidiaH264Profile, "norsk.api.media.NvidiaH264.NvidiaH264Profile", [
+  { no: 0, name: "NVIDIA_H264_PROFILE_AUTO" },
+  { no: 1, name: "NVIDIA_H264_PROFILE_BASELINE" },
+  { no: 2, name: "NVIDIA_H264_PROFILE_MAIN" },
+  { no: 4, name: "NVIDIA_H264_PROFILE_HIGH" },
+  { no: 7, name: "NVIDIA_H264_PROFILE_HIGH444" },
+]);
+
+/**
+ * @generated from message norsk.api.media.NvidiaHevc
+ */
+export class NvidiaHevc extends Message<NvidiaHevc> {
+  /**
+   * @generated from field: norsk.api.media.NvidiaPreset preset = 1;
+   */
+  preset = NvidiaPreset.P1;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt gopInterval = 2;
+   */
+  gopInterval?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt idrPeriod = 3;
+   */
+  idrPeriod?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt frameIntervalP = 4;
+   */
+  frameIntervalP?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt maxNumRefFrames = 5;
+   */
+  maxNumRefFrames?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool outputAud = 6;
+   */
+  outputAud?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt level = 7;
+   */
+  level?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.NvidiaHevc.NvidiaHevcTier tier = 8;
+   */
+  tier = NvidiaHevc_NvidiaHevcTier.MAIN;
+
+  /**
+   * @generated from field: norsk.api.media.NvidiaHevc.NvidiaHevcProfile profile = 9;
+   */
+  profile = NvidiaHevc_NvidiaHevcProfile.AUTO;
+
+  /**
+   * @generated from field: norsk.api.media.NvidiaRateControl rateControl = 10;
+   */
+  rateControl?: NvidiaRateControl;
+
+  constructor(data?: PartialMessage<NvidiaHevc>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.NvidiaHevc";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "preset", kind: "enum", T: proto3.getEnumType(NvidiaPreset) },
+    { no: 2, name: "gopInterval", kind: "message", T: OptionalInt },
+    { no: 3, name: "idrPeriod", kind: "message", T: OptionalInt },
+    { no: 4, name: "frameIntervalP", kind: "message", T: OptionalInt },
+    { no: 5, name: "maxNumRefFrames", kind: "message", T: OptionalInt },
+    { no: 6, name: "outputAud", kind: "message", T: OptionalBool },
+    { no: 7, name: "level", kind: "message", T: OptionalInt },
+    { no: 8, name: "tier", kind: "enum", T: proto3.getEnumType(NvidiaHevc_NvidiaHevcTier) },
+    { no: 9, name: "profile", kind: "enum", T: proto3.getEnumType(NvidiaHevc_NvidiaHevcProfile) },
+    { no: 10, name: "rateControl", kind: "message", T: NvidiaRateControl },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NvidiaHevc {
+    return new NvidiaHevc().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NvidiaHevc {
+    return new NvidiaHevc().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NvidiaHevc {
+    return new NvidiaHevc().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: NvidiaHevc | PlainMessage<NvidiaHevc> | undefined, b: NvidiaHevc | PlainMessage<NvidiaHevc> | undefined): boolean {
+    return proto3.util.equals(NvidiaHevc, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.NvidiaHevc.NvidiaHevcProfile
+ */
+export enum NvidiaHevc_NvidiaHevcProfile {
+  /**
+   * @generated from enum value: NVIDIA_HEVC_PROFILE_AUTO = 0;
+   */
+  AUTO = 0,
+
+  /**
+   * @generated from enum value: NVIDIA_HEVC_PROFILE_MAIN = 1;
+   */
+  MAIN = 1,
+
+  /**
+   * @generated from enum value: NVIDIA_HEVC_PROFILE_MAIN10 = 2;
+   */
+  MAIN10 = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(NvidiaHevc_NvidiaHevcProfile)
+proto3.util.setEnumType(NvidiaHevc_NvidiaHevcProfile, "norsk.api.media.NvidiaHevc.NvidiaHevcProfile", [
+  { no: 0, name: "NVIDIA_HEVC_PROFILE_AUTO" },
+  { no: 1, name: "NVIDIA_HEVC_PROFILE_MAIN" },
+  { no: 2, name: "NVIDIA_HEVC_PROFILE_MAIN10" },
+]);
+
+/**
+ * @generated from enum norsk.api.media.NvidiaHevc.NvidiaHevcTier
+ */
+export enum NvidiaHevc_NvidiaHevcTier {
+  /**
+   * @generated from enum value: NVIDIA_HEVC_TIER_MAIN = 0;
+   */
+  MAIN = 0,
+
+  /**
+   * @generated from enum value: NVIDIA_HEVC_TIER_HIGH = 1;
+   */
+  HIGH = 1,
+}
+// Retrieve enum metadata with: proto3.getEnumType(NvidiaHevc_NvidiaHevcTier)
+proto3.util.setEnumType(NvidiaHevc_NvidiaHevcTier, "norsk.api.media.NvidiaHevc.NvidiaHevcTier", [
+  { no: 0, name: "NVIDIA_HEVC_TIER_MAIN" },
+  { no: 1, name: "NVIDIA_HEVC_TIER_HIGH" },
+]);
+
+/**
+ * @generated from message norsk.api.media.QuadraH264
+ */
+export class QuadraH264 extends Message<QuadraH264> {
+  /**
+   * @generated from field: string extraOpts = 1;
+   */
+  extraOpts = "";
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool enableAud = 2;
+   */
+  enableAud?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt gpuIndex = 3;
+   */
+  gpuIndex?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt bitrate = 4;
+   */
+  bitrate?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool flushGop = 5;
+   */
+  flushGop?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool enableVfr = 6;
+   */
+  enableVfr?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt crf = 7;
+   */
+  crf?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool cbr = 8;
    */
-  idrPeriod?: OptionalInt;
+  cbr?: OptionalBool;
 
   /**
-   * @generated from field: norsk.api.media.OptionalInt frameIntervalP = 4;
+   * @generated from field: norsk.api.media.OptionalInt gopPresetIndex = 9;
    */
-  frameIntervalP?: OptionalInt;
+  gopPresetIndex?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.OptionalInt maxNumRefFrames = 5;
+   * @generated from field: norsk.api.media.OptionalInt intraPeriod = 10;
    */
-  maxNumRefFrames?: OptionalInt;
+  intraPeriod?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.OptionalBool outputAud = 6;
+   * @generated from field: norsk.api.media.QuadraH264.QuadraH264Profile profile = 11;
    */
-  outputAud?: OptionalBool;
+  profile = QuadraH264_QuadraH264Profile.DEFAULT;
 
   /**
-   * @generated from field: norsk.api.media.OptionalInt level = 7;
+   * @generated from field: norsk.api.media.OptionalInt level = 12;
    */
   level?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.NvidiaH264.NvidiaH264Profile profile = 8;
+   * @generated from field: norsk.api.media.OptionalBool rcEnable = 13;
    */
-  profile = NvidiaH264_NvidiaH264Profile.AUTO;
+  rcEnable?: OptionalBool;
 
   /**
-   * @generated from field: norsk.api.media.NvidiaRateControl rateControl = 9;
+   * @generated from field: norsk.api.media.OptionalInt intraQp = 14;
    */
-  rateControl?: NvidiaRateControl;
+  intraQp?: OptionalInt;
 
-  constructor(data?: PartialMessage<NvidiaH264>) {
+  /**
+   * @generated from field: norsk.api.media.OptionalInt rcInitDelay = 15;
+   */
+  rcInitDelay?: OptionalInt;
+
+  constructor(data?: PartialMessage<QuadraH264>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.NvidiaH264";
+  static readonly typeName = "norsk.api.media.QuadraH264";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "preset", kind: "enum", T: proto3.getEnumType(NvidiaPreset) },
-    { no: 2, name: "gopInterval", kind: "message", T: OptionalInt },
-    { no: 3, name: "idrPeriod", kind: "message", T: OptionalInt },
-    { no: 4, name: "frameIntervalP", kind: "message", T: OptionalInt },
-    { no: 5, name: "maxNumRefFrames", kind: "message", T: OptionalInt },
-    { no: 6, name: "outputAud", kind: "message", T: OptionalBool },
-    { no: 7, name: "level", kind: "message", T: OptionalInt },
-    { no: 8, name: "profile", kind: "enum", T: proto3.getEnumType(NvidiaH264_NvidiaH264Profile) },
-    { no: 9, name: "rateControl", kind: "message", T: NvidiaRateControl },
+    { no: 1, name: "extraOpts", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "enableAud", kind: "message", T: OptionalBool },
+    { no: 3, name: "gpuIndex", kind: "message", T: OptionalInt },
+    { no: 4, name: "bitrate", kind: "message", T: OptionalInt },
+    { no: 5, name: "flushGop", kind: "message", T: OptionalBool },
+    { no: 6, name: "enableVfr", kind: "message", T: OptionalBool },
+    { no: 7, name: "crf", kind: "message", T: OptionalInt },
+    { no: 8, name: "cbr", kind: "message", T: OptionalBool },
+    { no: 9, name: "gopPresetIndex", kind: "message", T: OptionalInt },
+    { no: 10, name: "intraPeriod", kind: "message", T: OptionalInt },
+    { no: 11, name: "profile", kind: "enum", T: proto3.getEnumType(QuadraH264_QuadraH264Profile) },
+    { no: 12, name: "level", kind: "message", T: OptionalInt },
+    { no: 13, name: "rcEnable", kind: "message", T: OptionalBool },
+    { no: 14, name: "intraQp", kind: "message", T: OptionalInt },
+    { no: 15, name: "rcInitDelay", kind: "message", T: OptionalInt },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NvidiaH264 {
-    return new NvidiaH264().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuadraH264 {
+    return new QuadraH264().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NvidiaH264 {
-    return new NvidiaH264().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuadraH264 {
+    return new QuadraH264().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NvidiaH264 {
-    return new NvidiaH264().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuadraH264 {
+    return new QuadraH264().fromJsonString(jsonString, options);
   }
 
-  static equals(a: NvidiaH264 | PlainMessage<NvidiaH264> | undefined, b: NvidiaH264 | PlainMessage<NvidiaH264> | undefined): boolean {
-    return proto3.util.equals(NvidiaH264, a, b);
+  static equals(a: QuadraH264 | PlainMessage<QuadraH264> | undefined, b: QuadraH264 | PlainMessage<QuadraH264> | undefined): boolean {
+    return proto3.util.equals(QuadraH264, a, b);
   }
 }
 
 /**
- * @generated from enum norsk.api.media.NvidiaH264.NvidiaH264Profile
+ * @generated from enum norsk.api.media.QuadraH264.QuadraH264Profile
  */
-export enum NvidiaH264_NvidiaH264Profile {
+export enum QuadraH264_QuadraH264Profile {
   /**
-   * @generated from enum value: NVIDIA_H264_PROFILE_AUTO = 0;
+   * @generated from enum value: QUADRA_H264_PROFILE_DEFAULT = 0;
    */
-  AUTO = 0,
+  DEFAULT = 0,
 
   /**
-   * @generated from enum value: NVIDIA_H264_PROFILE_BASELINE = 1;
+   * @generated from enum value: QUADRA_H264_PROFILE_BASELINE = 1;
    */
   BASELINE = 1,
 
   /**
-   * @generated from enum value: NVIDIA_H264_PROFILE_MAIN = 2;
+   * @generated from enum value: QUADRA_H264_PROFILE_MAIN = 2;
    */
   MAIN = 2,
 
   /**
-   * @generated from enum value: NVIDIA_H264_PROFILE_HIGH = 4;
+   * @generated from enum value: QUADRA_H264_PROFILE_EXTENDED = 3;
+   */
+  EXTENDED = 3,
+
+  /**
+   * @generated from enum value: QUADRA_H264_PROFILE_HIGH = 4;
    */
   HIGH = 4,
 
   /**
-   * @generated from enum value: NVIDIA_H264_PROFILE_HIGH444 = 7;
+   * @generated from enum value: QUADRA_H264_PROFILE_HIGH10 = 5;
    */
-  HIGH444 = 7,
+  HIGH10 = 5,
 }
-// Retrieve enum metadata with: proto3.getEnumType(NvidiaH264_NvidiaH264Profile)
-proto3.util.setEnumType(NvidiaH264_NvidiaH264Profile, "norsk.api.media.NvidiaH264.NvidiaH264Profile", [
-  { no: 0, name: "NVIDIA_H264_PROFILE_AUTO" },
-  { no: 1, name: "NVIDIA_H264_PROFILE_BASELINE" },
-  { no: 2, name: "NVIDIA_H264_PROFILE_MAIN" },
-  { no: 4, name: "NVIDIA_H264_PROFILE_HIGH" },
-  { no: 7, name: "NVIDIA_H264_PROFILE_HIGH444" },
+// Retrieve enum metadata with: proto3.getEnumType(QuadraH264_QuadraH264Profile)
+proto3.util.setEnumType(QuadraH264_QuadraH264Profile, "norsk.api.media.QuadraH264.QuadraH264Profile", [
+  { no: 0, name: "QUADRA_H264_PROFILE_DEFAULT" },
+  { no: 1, name: "QUADRA_H264_PROFILE_BASELINE" },
+  { no: 2, name: "QUADRA_H264_PROFILE_MAIN" },
+  { no: 3, name: "QUADRA_H264_PROFILE_EXTENDED" },
+  { no: 4, name: "QUADRA_H264_PROFILE_HIGH" },
+  { no: 5, name: "QUADRA_H264_PROFILE_HIGH10" },
 ]);
 
 /**
- * @generated from message norsk.api.media.NvidiaHevc
+ * @generated from message norsk.api.media.QuadraHevc
  */
-export class NvidiaHevc extends Message<NvidiaHevc> {
+export class QuadraHevc extends Message<QuadraHevc> {
   /**
-   * @generated from field: norsk.api.media.NvidiaPreset preset = 1;
+   * @generated from field: string extraOpts = 1;
    */
-  preset = NvidiaPreset.P1;
+  extraOpts = "";
 
   /**
-   * @generated from field: norsk.api.media.OptionalInt gopInterval = 2;
+   * @generated from field: norsk.api.media.OptionalBool enableAud = 2;
    */
-  gopInterval?: OptionalInt;
+  enableAud?: OptionalBool;
 
   /**
-   * @generated from field: norsk.api.media.OptionalInt idrPeriod = 3;
+   * @generated from field: norsk.api.media.OptionalInt gpuIndex = 3;
    */
-  idrPeriod?: OptionalInt;
+  gpuIndex?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.OptionalInt frameIntervalP = 4;
+   * @generated from field: norsk.api.media.OptionalInt bitrate = 4;
    */
-  frameIntervalP?: OptionalInt;
+  bitrate?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.OptionalInt maxNumRefFrames = 5;
+   * @generated from field: norsk.api.media.OptionalBool flushGop = 5;
    */
-  maxNumRefFrames?: OptionalInt;
+  flushGop?: OptionalBool;
 
   /**
-   * @generated from field: norsk.api.media.OptionalBool outputAud = 6;
+   * @generated from field: norsk.api.media.OptionalBool enableVfr = 6;
    */
-  outputAud?: OptionalBool;
+  enableVfr?: OptionalBool;
 
   /**
-   * @generated from field: norsk.api.media.OptionalInt level = 7;
+   * @generated from field: norsk.api.media.OptionalInt crf = 7;
+   */
+  crf?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool cbr = 8;
+   */
+  cbr?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt gopPresetIndex = 9;
+   */
+  gopPresetIndex?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt intraPeriod = 10;
+   */
+  intraPeriod?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.QuadraHevc.QuadraHevcTier tier = 11;
+   */
+  tier = QuadraHevc_QuadraHevcTier.MAIN;
+
+  /**
+   * @generated from field: norsk.api.media.QuadraHevc.QuadraHevcProfile profile = 12;
+   */
+  profile = QuadraHevc_QuadraHevcProfile.DEFAULT;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt level = 13;
    */
   level?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.NvidiaHevc.NvidiaHevcTier tier = 8;
+   * @generated from field: norsk.api.media.OptionalBool rcEnable = 14;
    */
-  tier = NvidiaHevc_NvidiaHevcTier.MAIN;
+  rcEnable?: OptionalBool;
 
   /**
-   * @generated from field: norsk.api.media.NvidiaHevc.NvidiaHevcProfile profile = 9;
+   * @generated from field: norsk.api.media.OptionalBool lossless = 15;
    */
-  profile = NvidiaHevc_NvidiaHevcProfile.AUTO;
+  lossless?: OptionalBool;
 
   /**
-   * @generated from field: norsk.api.media.NvidiaRateControl rateControl = 10;
+   * @generated from field: norsk.api.media.OptionalInt intraQp = 16;
    */
-  rateControl?: NvidiaRateControl;
+  intraQp?: OptionalInt;
 
-  constructor(data?: PartialMessage<NvidiaHevc>) {
+  /**
+   * @generated from field: norsk.api.media.OptionalInt rcInitDelay = 17;
+   */
+  rcInitDelay?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool hrdEnable = 18;
+   */
+  hrdEnable?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt dolbyVisionProfile = 19;
+   */
+  dolbyVisionProfile?: OptionalInt;
+
+  constructor(data?: PartialMessage<QuadraHevc>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.NvidiaHevc";
+  static readonly typeName = "norsk.api.media.QuadraHevc";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "preset", kind: "enum", T: proto3.getEnumType(NvidiaPreset) },
-    { no: 2, name: "gopInterval", kind: "message", T: OptionalInt },
-    { no: 3, name: "idrPeriod", kind: "message", T: OptionalInt },
-    { no: 4, name: "frameIntervalP", kind: "message", T: OptionalInt },
-    { no: 5, name: "maxNumRefFrames", kind: "message", T: OptionalInt },
-    { no: 6, name: "outputAud", kind: "message", T: OptionalBool },
-    { no: 7, name: "level", kind: "message", T: OptionalInt },
-    { no: 8, name: "tier", kind: "enum", T: proto3.getEnumType(NvidiaHevc_NvidiaHevcTier) },
-    { no: 9, name: "profile", kind: "enum", T: proto3.getEnumType(NvidiaHevc_NvidiaHevcProfile) },
-    { no: 10, name: "rateControl", kind: "message", T: NvidiaRateControl },
+    { no: 1, name: "extraOpts", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "enableAud", kind: "message", T: OptionalBool },
+    { no: 3, name: "gpuIndex", kind: "message", T: OptionalInt },
+    { no: 4, name: "bitrate", kind: "message", T: OptionalInt },
+    { no: 5, name: "flushGop", kind: "message", T: OptionalBool },
+    { no: 6, name: "enableVfr", kind: "message", T: OptionalBool },
+    { no: 7, name: "crf", kind: "message", T: OptionalInt },
+    { no: 8, name: "cbr", kind: "message", T: OptionalBool },
+    { no: 9, name: "gopPresetIndex", kind: "message", T: OptionalInt },
+    { no: 10, name: "intraPeriod", kind: "message", T: OptionalInt },
+    { no: 11, name: "tier", kind: "enum", T: proto3.getEnumType(QuadraHevc_QuadraHevcTier) },
+    { no: 12, name: "profile", kind: "enum", T: proto3.getEnumType(QuadraHevc_QuadraHevcProfile) },
+    { no: 13, name: "level", kind: "message", T: OptionalInt },
+    { no: 14, name: "rcEnable", kind: "message", T: OptionalBool },
+    { no: 15, name: "lossless", kind: "message", T: OptionalBool },
+    { no: 16, name: "intraQp", kind: "message", T: OptionalInt },
+    { no: 17, name: "rcInitDelay", kind: "message", T: OptionalInt },
+    { no: 18, name: "hrdEnable", kind: "message", T: OptionalBool },
+    { no: 19, name: "dolbyVisionProfile", kind: "message", T: OptionalInt },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NvidiaHevc {
-    return new NvidiaHevc().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuadraHevc {
+    return new QuadraHevc().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NvidiaHevc {
-    return new NvidiaHevc().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuadraHevc {
+    return new QuadraHevc().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NvidiaHevc {
-    return new NvidiaHevc().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuadraHevc {
+    return new QuadraHevc().fromJsonString(jsonString, options);
   }
 
-  static equals(a: NvidiaHevc | PlainMessage<NvidiaHevc> | undefined, b: NvidiaHevc | PlainMessage<NvidiaHevc> | undefined): boolean {
-    return proto3.util.equals(NvidiaHevc, a, b);
+  static equals(a: QuadraHevc | PlainMessage<QuadraHevc> | undefined, b: QuadraHevc | PlainMessage<QuadraHevc> | undefined): boolean {
+    return proto3.util.equals(QuadraHevc, a, b);
   }
 }
 
 /**
- * @generated from enum norsk.api.media.NvidiaHevc.NvidiaHevcProfile
+ * @generated from enum norsk.api.media.QuadraHevc.QuadraHevcProfile
  */
-export enum NvidiaHevc_NvidiaHevcProfile {
+export enum QuadraHevc_QuadraHevcProfile {
   /**
-   * @generated from enum value: NVIDIA_HEVC_PROFILE_AUTO = 0;
+   * @generated from enum value: QUADRA_HEVC_PROFILE_DEFAULT = 0;
    */
-  AUTO = 0,
+  DEFAULT = 0,
 
   /**
-   * @generated from enum value: NVIDIA_HEVC_PROFILE_MAIN = 1;
+   * @generated from enum value: QUADRA_HEVC_PROFILE_MAIN = 1;
    */
   MAIN = 1,
 
   /**
-   * @generated from enum value: NVIDIA_HEVC_PROFILE_MAIN10 = 2;
+   * @generated from enum value: QUADRA_HEVC_PROFILE_MAIN10 = 2;
    */
   MAIN10 = 2,
 }
-// Retrieve enum metadata with: proto3.getEnumType(NvidiaHevc_NvidiaHevcProfile)
-proto3.util.setEnumType(NvidiaHevc_NvidiaHevcProfile, "norsk.api.media.NvidiaHevc.NvidiaHevcProfile", [
-  { no: 0, name: "NVIDIA_HEVC_PROFILE_AUTO" },
-  { no: 1, name: "NVIDIA_HEVC_PROFILE_MAIN" },
-  { no: 2, name: "NVIDIA_HEVC_PROFILE_MAIN10" },
+// Retrieve enum metadata with: proto3.getEnumType(QuadraHevc_QuadraHevcProfile)
+proto3.util.setEnumType(QuadraHevc_QuadraHevcProfile, "norsk.api.media.QuadraHevc.QuadraHevcProfile", [
+  { no: 0, name: "QUADRA_HEVC_PROFILE_DEFAULT" },
+  { no: 1, name: "QUADRA_HEVC_PROFILE_MAIN" },
+  { no: 2, name: "QUADRA_HEVC_PROFILE_MAIN10" },
 ]);
 
 /**
- * @generated from enum norsk.api.media.NvidiaHevc.NvidiaHevcTier
+ * @generated from enum norsk.api.media.QuadraHevc.QuadraHevcTier
  */
-export enum NvidiaHevc_NvidiaHevcTier {
+export enum QuadraHevc_QuadraHevcTier {
   /**
-   * @generated from enum value: NVIDIA_HEVC_TIER_MAIN = 0;
+   * @generated from enum value: QUADRA_HEVC_TIER_MAIN = 0;
    */
   MAIN = 0,
 
   /**
-   * @generated from enum value: NVIDIA_HEVC_TIER_HIGH = 1;
+   * @generated from enum value: QUADRA_HEVC_TIER_HIGH = 1;
    */
   HIGH = 1,
 }
-// Retrieve enum metadata with: proto3.getEnumType(NvidiaHevc_NvidiaHevcTier)
-proto3.util.setEnumType(NvidiaHevc_NvidiaHevcTier, "norsk.api.media.NvidiaHevc.NvidiaHevcTier", [
-  { no: 0, name: "NVIDIA_HEVC_TIER_MAIN" },
-  { no: 1, name: "NVIDIA_HEVC_TIER_HIGH" },
+// Retrieve enum metadata with: proto3.getEnumType(QuadraHevc_QuadraHevcTier)
+proto3.util.setEnumType(QuadraHevc_QuadraHevcTier, "norsk.api.media.QuadraHevc.QuadraHevcTier", [
+  { no: 0, name: "QUADRA_HEVC_TIER_MAIN" },
+  { no: 1, name: "QUADRA_HEVC_TIER_HIGH" },
 ]);
 
 /**
- * @generated from message norsk.api.media.NetintH264
+ * @generated from message norsk.api.media.LoganH264
  */
-export class NetintH264 extends Message<NetintH264> {
+export class LoganH264 extends Message<LoganH264> {
   /**
    * @generated from field: string extraOpts = 1;
    */
@@ -13419,9 +14022,9 @@ export class NetintH264 extends Message<NetintH264> {
   intraPeriod?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.NetintH264.NetintH264Profile profile = 11;
+   * @generated from field: norsk.api.media.LoganH264.LoganH264Profile profile = 11;
    */
-  profile = NetintH264_NetintH264Profile.DEFAULT;
+  profile = LoganH264_LoganH264Profile.DEFAULT;
 
   /**
    * @generated from field: norsk.api.media.OptionalInt level = 12;
@@ -13443,13 +14046,13 @@ export class NetintH264 extends Message<NetintH264> {
    */
   rcInitDelay?: OptionalInt;
 
-  constructor(data?: PartialMessage<NetintH264>) {
+  constructor(data?: PartialMessage<LoganH264>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.NetintH264";
+  static readonly typeName = "norsk.api.media.LoganH264";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "extraOpts", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 2, name: "enableAud", kind: "message", T: OptionalBool },
@@ -13461,78 +14064,78 @@ export class NetintH264 extends Message<NetintH264> {
     { no: 8, name: "cbr", kind: "message", T: OptionalBool },
     { no: 9, name: "gopPresetIndex", kind: "message", T: OptionalInt },
     { no: 10, name: "intraPeriod", kind: "message", T: OptionalInt },
-    { no: 11, name: "profile", kind: "enum", T: proto3.getEnumType(NetintH264_NetintH264Profile) },
+    { no: 11, name: "profile", kind: "enum", T: proto3.getEnumType(LoganH264_LoganH264Profile) },
     { no: 12, name: "level", kind: "message", T: OptionalInt },
     { no: 13, name: "rcEnable", kind: "message", T: OptionalBool },
     { no: 14, name: "intraQp", kind: "message", T: OptionalInt },
     { no: 15, name: "rcInitDelay", kind: "message", T: OptionalInt },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NetintH264 {
-    return new NetintH264().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LoganH264 {
+    return new LoganH264().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NetintH264 {
-    return new NetintH264().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LoganH264 {
+    return new LoganH264().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NetintH264 {
-    return new NetintH264().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LoganH264 {
+    return new LoganH264().fromJsonString(jsonString, options);
   }
 
-  static equals(a: NetintH264 | PlainMessage<NetintH264> | undefined, b: NetintH264 | PlainMessage<NetintH264> | undefined): boolean {
-    return proto3.util.equals(NetintH264, a, b);
+  static equals(a: LoganH264 | PlainMessage<LoganH264> | undefined, b: LoganH264 | PlainMessage<LoganH264> | undefined): boolean {
+    return proto3.util.equals(LoganH264, a, b);
   }
 }
 
 /**
- * @generated from enum norsk.api.media.NetintH264.NetintH264Profile
+ * @generated from enum norsk.api.media.LoganH264.LoganH264Profile
  */
-export enum NetintH264_NetintH264Profile {
+export enum LoganH264_LoganH264Profile {
   /**
-   * @generated from enum value: NETINT_H264_PROFILE_DEFAULT = 0;
+   * @generated from enum value: LOGAN_H264_PROFILE_DEFAULT = 0;
    */
   DEFAULT = 0,
 
   /**
-   * @generated from enum value: NETINT_H264_PROFILE_BASELINE = 1;
+   * @generated from enum value: LOGAN_H264_PROFILE_BASELINE = 1;
    */
   BASELINE = 1,
 
   /**
-   * @generated from enum value: NETINT_H264_PROFILE_MAIN = 2;
+   * @generated from enum value: LOGAN_H264_PROFILE_MAIN = 2;
    */
   MAIN = 2,
 
   /**
-   * @generated from enum value: NETINT_H264_PROFILE_EXTENDED = 3;
+   * @generated from enum value: LOGAN_H264_PROFILE_EXTENDED = 3;
    */
   EXTENDED = 3,
 
   /**
-   * @generated from enum value: NETINT_H264_PROFILE_HIGH = 4;
+   * @generated from enum value: LOGAN_H264_PROFILE_HIGH = 4;
    */
   HIGH = 4,
 
   /**
-   * @generated from enum value: NETINT_H264_PROFILE_HIGH10 = 5;
+   * @generated from enum value: LOGAN_H264_PROFILE_HIGH10 = 5;
    */
   HIGH10 = 5,
 }
-// Retrieve enum metadata with: proto3.getEnumType(NetintH264_NetintH264Profile)
-proto3.util.setEnumType(NetintH264_NetintH264Profile, "norsk.api.media.NetintH264.NetintH264Profile", [
-  { no: 0, name: "NETINT_H264_PROFILE_DEFAULT" },
-  { no: 1, name: "NETINT_H264_PROFILE_BASELINE" },
-  { no: 2, name: "NETINT_H264_PROFILE_MAIN" },
-  { no: 3, name: "NETINT_H264_PROFILE_EXTENDED" },
-  { no: 4, name: "NETINT_H264_PROFILE_HIGH" },
-  { no: 5, name: "NETINT_H264_PROFILE_HIGH10" },
+// Retrieve enum metadata with: proto3.getEnumType(LoganH264_LoganH264Profile)
+proto3.util.setEnumType(LoganH264_LoganH264Profile, "norsk.api.media.LoganH264.LoganH264Profile", [
+  { no: 0, name: "LOGAN_H264_PROFILE_DEFAULT" },
+  { no: 1, name: "LOGAN_H264_PROFILE_BASELINE" },
+  { no: 2, name: "LOGAN_H264_PROFILE_MAIN" },
+  { no: 3, name: "LOGAN_H264_PROFILE_EXTENDED" },
+  { no: 4, name: "LOGAN_H264_PROFILE_HIGH" },
+  { no: 5, name: "LOGAN_H264_PROFILE_HIGH10" },
 ]);
 
 /**
- * @generated from message norsk.api.media.NetintHevc
+ * @generated from message norsk.api.media.LoganHevc
  */
-export class NetintHevc extends Message<NetintHevc> {
+export class LoganHevc extends Message<LoganHevc> {
   /**
    * @generated from field: string extraOpts = 1;
    */
@@ -13584,14 +14187,14 @@ export class NetintHevc extends Message<NetintHevc> {
   intraPeriod?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.NetintHevc.NetintHevcTier tier = 11;
+   * @generated from field: norsk.api.media.LoganHevc.LoganHevcTier tier = 11;
    */
-  tier = NetintHevc_NetintHevcTier.MAIN;
+  tier = LoganHevc_LoganHevcTier.MAIN;
 
   /**
-   * @generated from field: norsk.api.media.NetintHevc.NetintHevcProfile profile = 12;
+   * @generated from field: norsk.api.media.LoganHevc.LoganHevcProfile profile = 12;
    */
-  profile = NetintHevc_NetintHevcProfile.DEFAULT;
+  profile = LoganHevc_LoganHevcProfile.DEFAULT;
 
   /**
    * @generated from field: norsk.api.media.OptionalInt level = 13;
@@ -13628,13 +14231,13 @@ export class NetintHevc extends Message<NetintHevc> {
    */
   dolbyVisionProfile?: OptionalInt;
 
-  constructor(data?: PartialMessage<NetintHevc>) {
+  constructor(data?: PartialMessage<LoganHevc>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.NetintHevc";
+  static readonly typeName = "norsk.api.media.LoganHevc";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "extraOpts", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 2, name: "enableAud", kind: "message", T: OptionalBool },
@@ -13646,8 +14249,8 @@ export class NetintHevc extends Message<NetintHevc> {
     { no: 8, name: "cbr", kind: "message", T: OptionalBool },
     { no: 9, name: "gopPresetIndex", kind: "message", T: OptionalInt },
     { no: 10, name: "intraPeriod", kind: "message", T: OptionalInt },
-    { no: 11, name: "tier", kind: "enum", T: proto3.getEnumType(NetintHevc_NetintHevcTier) },
-    { no: 12, name: "profile", kind: "enum", T: proto3.getEnumType(NetintHevc_NetintHevcProfile) },
+    { no: 11, name: "tier", kind: "enum", T: proto3.getEnumType(LoganHevc_LoganHevcTier) },
+    { no: 12, name: "profile", kind: "enum", T: proto3.getEnumType(LoganHevc_LoganHevcProfile) },
     { no: 13, name: "level", kind: "message", T: OptionalInt },
     { no: 14, name: "rcEnable", kind: "message", T: OptionalBool },
     { no: 15, name: "lossless", kind: "message", T: OptionalBool },
@@ -13657,67 +14260,67 @@ export class NetintHevc extends Message<NetintHevc> {
     { no: 19, name: "dolbyVisionProfile", kind: "message", T: OptionalInt },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NetintHevc {
-    return new NetintHevc().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LoganHevc {
+    return new LoganHevc().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NetintHevc {
-    return new NetintHevc().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LoganHevc {
+    return new LoganHevc().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NetintHevc {
-    return new NetintHevc().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LoganHevc {
+    return new LoganHevc().fromJsonString(jsonString, options);
   }
 
-  static equals(a: NetintHevc | PlainMessage<NetintHevc> | undefined, b: NetintHevc | PlainMessage<NetintHevc> | undefined): boolean {
-    return proto3.util.equals(NetintHevc, a, b);
+  static equals(a: LoganHevc | PlainMessage<LoganHevc> | undefined, b: LoganHevc | PlainMessage<LoganHevc> | undefined): boolean {
+    return proto3.util.equals(LoganHevc, a, b);
   }
 }
 
 /**
- * @generated from enum norsk.api.media.NetintHevc.NetintHevcProfile
+ * @generated from enum norsk.api.media.LoganHevc.LoganHevcProfile
  */
-export enum NetintHevc_NetintHevcProfile {
+export enum LoganHevc_LoganHevcProfile {
   /**
-   * @generated from enum value: NETINT_HEVC_PROFILE_DEFAULT = 0;
+   * @generated from enum value: LOGAN_HEVC_PROFILE_DEFAULT = 0;
    */
   DEFAULT = 0,
 
   /**
-   * @generated from enum value: NETINT_HEVC_PROFILE_MAIN = 1;
+   * @generated from enum value: LOGAN_HEVC_PROFILE_MAIN = 1;
    */
   MAIN = 1,
 
   /**
-   * @generated from enum value: NETINT_HEVC_PROFILE_MAIN10 = 2;
+   * @generated from enum value: LOGAN_HEVC_PROFILE_MAIN10 = 2;
    */
   MAIN10 = 2,
 }
-// Retrieve enum metadata with: proto3.getEnumType(NetintHevc_NetintHevcProfile)
-proto3.util.setEnumType(NetintHevc_NetintHevcProfile, "norsk.api.media.NetintHevc.NetintHevcProfile", [
-  { no: 0, name: "NETINT_HEVC_PROFILE_DEFAULT" },
-  { no: 1, name: "NETINT_HEVC_PROFILE_MAIN" },
-  { no: 2, name: "NETINT_HEVC_PROFILE_MAIN10" },
+// Retrieve enum metadata with: proto3.getEnumType(LoganHevc_LoganHevcProfile)
+proto3.util.setEnumType(LoganHevc_LoganHevcProfile, "norsk.api.media.LoganHevc.LoganHevcProfile", [
+  { no: 0, name: "LOGAN_HEVC_PROFILE_DEFAULT" },
+  { no: 1, name: "LOGAN_HEVC_PROFILE_MAIN" },
+  { no: 2, name: "LOGAN_HEVC_PROFILE_MAIN10" },
 ]);
 
 /**
- * @generated from enum norsk.api.media.NetintHevc.NetintHevcTier
+ * @generated from enum norsk.api.media.LoganHevc.LoganHevcTier
  */
-export enum NetintHevc_NetintHevcTier {
+export enum LoganHevc_LoganHevcTier {
   /**
-   * @generated from enum value: NETINT_HEVC_TIER_MAIN = 0;
+   * @generated from enum value: LOGAN_HEVC_TIER_MAIN = 0;
    */
   MAIN = 0,
 
   /**
-   * @generated from enum value: NETINT_HEVC_TIER_HIGH = 1;
+   * @generated from enum value: LOGAN_HEVC_TIER_HIGH = 1;
    */
   HIGH = 1,
 }
-// Retrieve enum metadata with: proto3.getEnumType(NetintHevc_NetintHevcTier)
-proto3.util.setEnumType(NetintHevc_NetintHevcTier, "norsk.api.media.NetintHevc.NetintHevcTier", [
-  { no: 0, name: "NETINT_HEVC_TIER_MAIN" },
-  { no: 1, name: "NETINT_HEVC_TIER_HIGH" },
+// Retrieve enum metadata with: proto3.getEnumType(LoganHevc_LoganHevcTier)
+proto3.util.setEnumType(LoganHevc_LoganHevcTier, "norsk.api.media.LoganHevc.LoganHevcTier", [
+  { no: 0, name: "LOGAN_HEVC_TIER_MAIN" },
+  { no: 1, name: "LOGAN_HEVC_TIER_HIGH" },
 ]);
 
 /**
@@ -14362,14 +14965,16 @@ export class StreamMetadataOverrideConfiguration extends Message<StreamMetadataO
   id?: MediaNodeId;
 
   /**
-   * * Override the bitrate metadata of a compressed video stream, or `0` to clear 
+   * * Override the bitrate metadata of a compressed video stream, or `0` to
+   * clear 
    *
    * @generated from field: norsk.api.media.OptionalInt video_bitrate = 2;
    */
   videoBitrate?: OptionalInt;
 
   /**
-   * * Override the bitrate metadata of a compressed audio stream, or `0` to clear 
+   * * Override the bitrate metadata of a compressed audio stream, or `0` to
+   * clear 
    *
    * @generated from field: norsk.api.media.OptionalInt audio_bitrate = 3;
    */
@@ -14426,14 +15031,16 @@ export class StreamMetadataOverrideConfiguration extends Message<StreamMetadataO
  */
 export class StreamMetadataOverrideUpdateConfiguration extends Message<StreamMetadataOverrideUpdateConfiguration> {
   /**
-   * * Override the bitrate metadata of a compressed video stream, or `0` to clear 
+   * * Override the bitrate metadata of a compressed video stream, or `0` to
+   * clear 
    *
    * @generated from field: norsk.api.media.OptionalInt video_bitrate = 2;
    */
   videoBitrate?: OptionalInt;
 
   /**
-   * * Override the bitrate metadata of a compressed audio stream, or `0` to clear 
+   * * Override the bitrate metadata of a compressed audio stream, or `0` to
+   * clear 
    *
    * @generated from field: norsk.api.media.OptionalInt audio_bitrate = 3;
    */
@@ -15231,6 +15838,49 @@ export class StreamSwitchSmoothMessage extends Message<StreamSwitchSmoothMessage
   }
 }
 
+/**
+ * @generated from message norsk.api.media.StreamSwitchSmoothSwitchError
+ */
+export class StreamSwitchSmoothSwitchError extends Message<StreamSwitchSmoothSwitchError> {
+  /**
+   * @generated from field: string reason = 1;
+   */
+  reason = "";
+
+  /**
+   * @generated from field: norsk.api.media.InputPin requested_source = 2;
+   */
+  requestedSource?: InputPin;
+
+  constructor(data?: PartialMessage<StreamSwitchSmoothSwitchError>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamSwitchSmoothSwitchError";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "reason", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "requested_source", kind: "message", T: InputPin },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchSmoothSwitchError {
+    return new StreamSwitchSmoothSwitchError().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSwitchSmoothSwitchError {
+    return new StreamSwitchSmoothSwitchError().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSwitchSmoothSwitchError {
+    return new StreamSwitchSmoothSwitchError().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamSwitchSmoothSwitchError | PlainMessage<StreamSwitchSmoothSwitchError> | undefined, b: StreamSwitchSmoothSwitchError | PlainMessage<StreamSwitchSmoothSwitchError> | undefined): boolean {
+    return proto3.util.equals(StreamSwitchSmoothSwitchError, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.StreamSwitchSmoothEvent
  */
@@ -15256,6 +15906,21 @@ export class StreamSwitchSmoothEvent extends Message<StreamSwitchSmoothEvent> {
      */
     value: SubscriptionResponse;
     case: "subscriptionResponse";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.StreamSwitchSmoothSwitchError switch_error = 4;
+     */
+    value: StreamSwitchSmoothSwitchError;
+    case: "switchError";
+  } | {
+    /**
+     * Message sent when inbound context changes on some input; presence of an input in this message means that
+     * media has arrived and is ready to switch immediately
+     *
+     * @generated from field: norsk.api.media.MultipleContext inbound_context = 5;
+     */
+    value: MultipleContext;
+    case: "inboundContext";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<StreamSwitchSmoothEvent>) {
@@ -15269,6 +15934,8 @@ export class StreamSwitchSmoothEvent extends Message<StreamSwitchSmoothEvent> {
     { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
     { no: 2, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
     { no: 3, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
+    { no: 4, name: "switch_error", kind: "message", T: StreamSwitchSmoothSwitchError, oneof: "message" },
+    { no: 5, name: "inbound_context", kind: "message", T: MultipleContext, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchSmoothEvent {
@@ -17216,7 +17883,8 @@ export class SubscribeSource extends Message<SubscribeSource> {
  */
 export class Subscription extends Message<Subscription> {
   /**
-   * An arbitrary id of the subscription, to enable correlating of the corresponding subscription response
+   * An arbitrary id of the subscription, to enable correlating of the
+   * corresponding subscription response
    *
    * @generated from field: string id = 1;
    */
@@ -17492,7 +18160,8 @@ export class SourceSubscriptionError extends Message<SourceSubscriptionError> {
     case: "unknownSourceStream";
   } | {
     /**
-     * The media node is not set up to receive data on this pin (which may be auto-detected)
+     * The media node is not set up to receive data on this pin (which may be
+     * auto-detected)
      *
      * @generated from field: norsk.api.media.SourceSubscriptionError.NoSubscriberPin no_subscriber_pin = 4;
      */
@@ -17500,7 +18169,8 @@ export class SourceSubscriptionError extends Message<SourceSubscriptionError> {
     case: "noSubscriberPin";
   } | {
     /**
-     * Norsk does not support conversion from the media types of the source to the media types accepted by the subscriber
+     * Norsk does not support conversion from the media types of the source to
+     * the media types accepted by the subscriber
      *
      * @generated from field: norsk.api.media.SourceSubscriptionError.UnsupportedConversion unsupported_conversion = 5;
      */