@norskvideo/norsk-api 1.0.334 → 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
  */
@@ -4252,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);
@@ -4264,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 {
@@ -5962,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);
@@ -5974,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 {
@@ -6879,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
  */
@@ -6898,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);
@@ -6909,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 {
@@ -8968,6 +9182,16 @@ export class Mp4Encryption extends Message<Mp4Encryption> {
    */
   encryptionKey = "";
 
+  /**
+   * @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);
@@ -8978,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 {
@@ -8997,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
  */
@@ -10801,6 +11047,70 @@ export class WhipOutputMessage extends Message<WhipOutputMessage> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.WhipOutputEvent
+ */
+export class WhipOutputEvent extends Message<WhipOutputEvent> {
+  /**
+   * @generated from oneof norsk.api.media.WhipOutputEvent.message
+   */
+  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
  */
@@ -10815,6 +11125,13 @@ export class WebRTCBrowserDuplexConfiguration extends Message<WebRTCBrowserDuple
    */
   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();
     proto3.util.initPartial(data, this);
@@ -10825,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 {
@@ -10895,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: {
     /**
@@ -10921,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: {
     /**
@@ -10985,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);
   }
 }
 
@@ -11375,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;
 
@@ -11395,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 {
@@ -12608,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>) {
@@ -12636,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 {
@@ -13173,9 +13612,174 @@ proto3.util.setEnumType(NvidiaHevc_NvidiaHevcTier, "norsk.api.media.NvidiaHevc.N
 ]);
 
 /**
- * @generated from message norsk.api.media.NetintH264
+ * @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;
+   */
+  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.QuadraH264.QuadraH264Profile profile = 11;
+   */
+  profile = QuadraH264_QuadraH264Profile.DEFAULT;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt level = 12;
+   */
+  level?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool rcEnable = 13;
+   */
+  rcEnable?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt intraQp = 14;
+   */
+  intraQp?: OptionalInt;
+
+  /**
+   * @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.QuadraH264";
+  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 },
+    { 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>): QuadraH264 {
+    return new QuadraH264().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuadraH264 {
+    return new QuadraH264().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuadraH264 {
+    return new QuadraH264().fromJsonString(jsonString, options);
+  }
+
+  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.QuadraH264.QuadraH264Profile
+ */
+export enum QuadraH264_QuadraH264Profile {
+  /**
+   * @generated from enum value: QUADRA_H264_PROFILE_DEFAULT = 0;
+   */
+  DEFAULT = 0,
+
+  /**
+   * @generated from enum value: QUADRA_H264_PROFILE_BASELINE = 1;
+   */
+  BASELINE = 1,
+
+  /**
+   * @generated from enum value: QUADRA_H264_PROFILE_MAIN = 2;
+   */
+  MAIN = 2,
+
+  /**
+   * @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: QUADRA_H264_PROFILE_HIGH10 = 5;
+   */
+  HIGH10 = 5,
+}
+// 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.QuadraHevc
  */
-export class NetintH264 extends Message<NetintH264> {
+export class QuadraHevc extends Message<QuadraHevc> {
   /**
    * @generated from field: string extraOpts = 1;
    */
@@ -13227,9 +13831,200 @@ export class NetintH264 extends Message<NetintH264> {
   intraPeriod?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.NetintH264.NetintH264Profile profile = 11;
+   * @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 = NetintH264_NetintH264Profile.DEFAULT;
+  profile = QuadraHevc_QuadraHevcProfile.DEFAULT;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt level = 13;
+   */
+  level?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool rcEnable = 14;
+   */
+  rcEnable?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool lossless = 15;
+   */
+  lossless?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt intraQp = 16;
+   */
+  intraQp?: OptionalInt;
+
+  /**
+   * @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.QuadraHevc";
+  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 },
+    { 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>): QuadraHevc {
+    return new QuadraHevc().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuadraHevc {
+    return new QuadraHevc().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuadraHevc {
+    return new QuadraHevc().fromJsonString(jsonString, options);
+  }
+
+  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.QuadraHevc.QuadraHevcProfile
+ */
+export enum QuadraHevc_QuadraHevcProfile {
+  /**
+   * @generated from enum value: QUADRA_HEVC_PROFILE_DEFAULT = 0;
+   */
+  DEFAULT = 0,
+
+  /**
+   * @generated from enum value: QUADRA_HEVC_PROFILE_MAIN = 1;
+   */
+  MAIN = 1,
+
+  /**
+   * @generated from enum value: QUADRA_HEVC_PROFILE_MAIN10 = 2;
+   */
+  MAIN10 = 2,
+}
+// 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.QuadraHevc.QuadraHevcTier
+ */
+export enum QuadraHevc_QuadraHevcTier {
+  /**
+   * @generated from enum value: QUADRA_HEVC_TIER_MAIN = 0;
+   */
+  MAIN = 0,
+
+  /**
+   * @generated from enum value: QUADRA_HEVC_TIER_HIGH = 1;
+   */
+  HIGH = 1,
+}
+// 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.LoganH264
+ */
+export class LoganH264 extends Message<LoganH264> {
+  /**
+   * @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;
+   */
+  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.LoganH264.LoganH264Profile profile = 11;
+   */
+  profile = LoganH264_LoganH264Profile.DEFAULT;
 
   /**
    * @generated from field: norsk.api.media.OptionalInt level = 12;
@@ -13251,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 },
@@ -13269,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;
    */
@@ -13392,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;
@@ -13436,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 },
@@ -13454,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 },
@@ -13465,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" },
 ]);
 
 /**
@@ -15043,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
  */
@@ -15068,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>) {
@@ -15081,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 {