@norskvideo/norsk-api 1.0.385 → 1.0.387

package/lib/media_pb.ts

@@ -5,7 +5,7 @@
 
 import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
 import { Empty, Message, proto3, protoInt64, Timestamp } from "@bufbuild/protobuf";
-import { CurrentLoad, Log, Log_Level, OptionalBool, OptionalInt, OptionalInt64, OptionalString, UInt32OrInfinity, Version } from "./shared/common_pb.js";
+import { CurrentLoad, Log, Log_Level, OptionalBool, OptionalFloat, OptionalInt, OptionalInt64, OptionalString, UInt32OrInfinity, Version } from "./shared/common_pb.js";
 
 /**
  * @generated from enum norsk.api.media.NodeMetricsMode
@@ -6901,6 +6901,464 @@ export class DeckLinkInputEvent extends Message<DeckLinkInputEvent> {
   }
 }
 
+/**
+ * ///////////////////////////////
+ * Kantar Audio Watermarks
+ *
+ * @generated from message norsk.api.media.AudioWatermarkConfiguration
+ */
+export class AudioWatermarkConfiguration extends Message<AudioWatermarkConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * @generated from oneof norsk.api.media.AudioWatermarkConfiguration.license
+   */
+  license: {
+    /**
+     * @generated from field: norsk.api.media.AudioWatermarkConfiguration.OnlineLicense online_license = 2;
+     */
+    value: AudioWatermarkConfiguration_OnlineLicense;
+    case: "onlineLicense";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.AudioWatermarkConfiguration.OfflineLicense offline_license = 3;
+     */
+    value: AudioWatermarkConfiguration_OfflineLicense;
+    case: "offlineLicense";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<AudioWatermarkConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AudioWatermarkConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "online_license", kind: "message", T: AudioWatermarkConfiguration_OnlineLicense, oneof: "license" },
+    { no: 3, name: "offline_license", kind: "message", T: AudioWatermarkConfiguration_OfflineLicense, oneof: "license" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioWatermarkConfiguration {
+    return new AudioWatermarkConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioWatermarkConfiguration {
+    return new AudioWatermarkConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioWatermarkConfiguration {
+    return new AudioWatermarkConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AudioWatermarkConfiguration | PlainMessage<AudioWatermarkConfiguration> | undefined, b: AudioWatermarkConfiguration | PlainMessage<AudioWatermarkConfiguration> | undefined): boolean {
+    return proto3.util.equals(AudioWatermarkConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.AudioWatermarkConfiguration.OnlineLicense
+ */
+export class AudioWatermarkConfiguration_OnlineLicense extends Message<AudioWatermarkConfiguration_OnlineLicense> {
+  /**
+   * @generated from field: string login = 1;
+   */
+  login = "";
+
+  /**
+   * @generated from field: string password = 2;
+   */
+  password = "";
+
+  /**
+   * @generated from field: string server = 3;
+   */
+  server = "";
+
+  /**
+   * @generated from field: int32 port = 4;
+   */
+  port = 0;
+
+  /**
+   * @generated from field: int64 license_id = 5;
+   */
+  licenseId = protoInt64.zero;
+
+  constructor(data?: PartialMessage<AudioWatermarkConfiguration_OnlineLicense>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AudioWatermarkConfiguration.OnlineLicense";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "login", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "password", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "server", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "port", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 5, name: "license_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioWatermarkConfiguration_OnlineLicense {
+    return new AudioWatermarkConfiguration_OnlineLicense().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioWatermarkConfiguration_OnlineLicense {
+    return new AudioWatermarkConfiguration_OnlineLicense().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioWatermarkConfiguration_OnlineLicense {
+    return new AudioWatermarkConfiguration_OnlineLicense().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AudioWatermarkConfiguration_OnlineLicense | PlainMessage<AudioWatermarkConfiguration_OnlineLicense> | undefined, b: AudioWatermarkConfiguration_OnlineLicense | PlainMessage<AudioWatermarkConfiguration_OnlineLicense> | undefined): boolean {
+    return proto3.util.equals(AudioWatermarkConfiguration_OnlineLicense, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.AudioWatermarkConfiguration.OfflineLicense
+ */
+export class AudioWatermarkConfiguration_OfflineLicense extends Message<AudioWatermarkConfiguration_OfflineLicense> {
+  /**
+   * @generated from field: string kantar_license = 1;
+   */
+  kantarLicense = "";
+
+  /**
+   * @generated from field: string audience_license = 2;
+   */
+  audienceLicense = "";
+
+  /**
+   * @generated from field: string channel_name = 3;
+   */
+  channelName = "";
+
+  constructor(data?: PartialMessage<AudioWatermarkConfiguration_OfflineLicense>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AudioWatermarkConfiguration.OfflineLicense";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "kantar_license", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "audience_license", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "channel_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioWatermarkConfiguration_OfflineLicense {
+    return new AudioWatermarkConfiguration_OfflineLicense().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioWatermarkConfiguration_OfflineLicense {
+    return new AudioWatermarkConfiguration_OfflineLicense().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioWatermarkConfiguration_OfflineLicense {
+    return new AudioWatermarkConfiguration_OfflineLicense().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AudioWatermarkConfiguration_OfflineLicense | PlainMessage<AudioWatermarkConfiguration_OfflineLicense> | undefined, b: AudioWatermarkConfiguration_OfflineLicense | PlainMessage<AudioWatermarkConfiguration_OfflineLicense> | undefined): boolean {
+    return proto3.util.equals(AudioWatermarkConfiguration_OfflineLicense, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.AudioWatermarkMessage
+ */
+export class AudioWatermarkMessage extends Message<AudioWatermarkMessage> {
+  /**
+   * @generated from oneof norsk.api.media.AudioWatermarkMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Subscription subscription = 1;
+     */
+    value: Subscription;
+    case: "subscription";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.AudioWatermarkConfiguration initial_config = 2;
+     */
+    value: AudioWatermarkConfiguration;
+    case: "initialConfig";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<AudioWatermarkMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AudioWatermarkMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+    { no: 2, name: "initial_config", kind: "message", T: AudioWatermarkConfiguration, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioWatermarkMessage {
+    return new AudioWatermarkMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioWatermarkMessage {
+    return new AudioWatermarkMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioWatermarkMessage {
+    return new AudioWatermarkMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AudioWatermarkMessage | PlainMessage<AudioWatermarkMessage> | undefined, b: AudioWatermarkMessage | PlainMessage<AudioWatermarkMessage> | undefined): boolean {
+    return proto3.util.equals(AudioWatermarkMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.AudioWatermarkLicenseInformation
+ */
+export class AudioWatermarkLicenseInformation extends Message<AudioWatermarkLicenseInformation> {
+  /**
+   * @generated from field: int32 remaining_days = 1;
+   */
+  remainingDays = 0;
+
+  /**
+   * @generated from field: repeated norsk.api.media.AudioWatermarkLicenseInformation.ChannelInfo channel_infos = 2;
+   */
+  channelInfos: AudioWatermarkLicenseInformation_ChannelInfo[] = [];
+
+  constructor(data?: PartialMessage<AudioWatermarkLicenseInformation>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AudioWatermarkLicenseInformation";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "remaining_days", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 2, name: "channel_infos", kind: "message", T: AudioWatermarkLicenseInformation_ChannelInfo, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioWatermarkLicenseInformation {
+    return new AudioWatermarkLicenseInformation().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioWatermarkLicenseInformation {
+    return new AudioWatermarkLicenseInformation().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioWatermarkLicenseInformation {
+    return new AudioWatermarkLicenseInformation().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AudioWatermarkLicenseInformation | PlainMessage<AudioWatermarkLicenseInformation> | undefined, b: AudioWatermarkLicenseInformation | PlainMessage<AudioWatermarkLicenseInformation> | undefined): boolean {
+    return proto3.util.equals(AudioWatermarkLicenseInformation, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.AudioWatermarkLicenseInformation.ChannelInfo
+ */
+export class AudioWatermarkLicenseInformation_ChannelInfo extends Message<AudioWatermarkLicenseInformation_ChannelInfo> {
+  /**
+   * @generated from field: string channel_name = 1;
+   */
+  channelName = "";
+
+  /**
+   * @generated from field: int64 channel_id = 2;
+   */
+  channelId = protoInt64.zero;
+
+  constructor(data?: PartialMessage<AudioWatermarkLicenseInformation_ChannelInfo>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AudioWatermarkLicenseInformation.ChannelInfo";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "channel_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "channel_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioWatermarkLicenseInformation_ChannelInfo {
+    return new AudioWatermarkLicenseInformation_ChannelInfo().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioWatermarkLicenseInformation_ChannelInfo {
+    return new AudioWatermarkLicenseInformation_ChannelInfo().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioWatermarkLicenseInformation_ChannelInfo {
+    return new AudioWatermarkLicenseInformation_ChannelInfo().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AudioWatermarkLicenseInformation_ChannelInfo | PlainMessage<AudioWatermarkLicenseInformation_ChannelInfo> | undefined, b: AudioWatermarkLicenseInformation_ChannelInfo | PlainMessage<AudioWatermarkLicenseInformation_ChannelInfo> | undefined): boolean {
+    return proto3.util.equals(AudioWatermarkLicenseInformation_ChannelInfo, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.AudioWatermarkSnapEvent
+ */
+export class AudioWatermarkSnapEvent extends Message<AudioWatermarkSnapEvent> {
+  /**
+   * @generated from field: norsk.api.media.AudioWatermarkSnapEvent.EventType event_type = 1;
+   */
+  eventType = AudioWatermarkSnapEvent_EventType.SNAPINFO;
+
+  /**
+   * @generated from field: int32 code = 2;
+   */
+  code = 0;
+
+  /**
+   * @generated from field: string message = 3;
+   */
+  message = "";
+
+  constructor(data?: PartialMessage<AudioWatermarkSnapEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AudioWatermarkSnapEvent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "event_type", kind: "enum", T: proto3.getEnumType(AudioWatermarkSnapEvent_EventType) },
+    { no: 2, name: "code", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 3, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioWatermarkSnapEvent {
+    return new AudioWatermarkSnapEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioWatermarkSnapEvent {
+    return new AudioWatermarkSnapEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioWatermarkSnapEvent {
+    return new AudioWatermarkSnapEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AudioWatermarkSnapEvent | PlainMessage<AudioWatermarkSnapEvent> | undefined, b: AudioWatermarkSnapEvent | PlainMessage<AudioWatermarkSnapEvent> | undefined): boolean {
+    return proto3.util.equals(AudioWatermarkSnapEvent, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.AudioWatermarkSnapEvent.EventType
+ */
+export enum AudioWatermarkSnapEvent_EventType {
+  /**
+   * @generated from enum value: SNAPINFO = 0;
+   */
+  SNAPINFO = 0,
+
+  /**
+   * @generated from enum value: SNAPWARNING = 1;
+   */
+  SNAPWARNING = 1,
+
+  /**
+   * @generated from enum value: SNAPERROR = 2;
+   */
+  SNAPERROR = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(AudioWatermarkSnapEvent_EventType)
+proto3.util.setEnumType(AudioWatermarkSnapEvent_EventType, "norsk.api.media.AudioWatermarkSnapEvent.EventType", [
+  { no: 0, name: "SNAPINFO" },
+  { no: 1, name: "SNAPWARNING" },
+  { no: 2, name: "SNAPERROR" },
+]);
+
+/**
+ * @generated from message norsk.api.media.AudioWatermarkEvent
+ */
+export class AudioWatermarkEvent extends Message<AudioWatermarkEvent> {
+  /**
+   * @generated from oneof norsk.api.media.AudioWatermarkEvent.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.MediaNodeId node_id = 1;
+     */
+    value: MediaNodeId;
+    case: "nodeId";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context outbound_context = 2;
+     */
+    value: Context;
+    case: "outboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context inbound_context = 3;
+     */
+    value: Context;
+    case: "inboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 4;
+     */
+    value: SubscriptionResponse;
+    case: "subscriptionResponse";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.AudioWatermarkLicenseInformation license_information = 5;
+     */
+    value: AudioWatermarkLicenseInformation;
+    case: "licenseInformation";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.AudioWatermarkSnapEvent snap_event = 6;
+     */
+    value: AudioWatermarkSnapEvent;
+    case: "snapEvent";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<AudioWatermarkEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AudioWatermarkEvent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { 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: "inbound_context", kind: "message", T: Context, oneof: "message" },
+    { no: 4, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
+    { no: 5, name: "license_information", kind: "message", T: AudioWatermarkLicenseInformation, oneof: "message" },
+    { no: 6, name: "snap_event", kind: "message", T: AudioWatermarkSnapEvent, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioWatermarkEvent {
+    return new AudioWatermarkEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioWatermarkEvent {
+    return new AudioWatermarkEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioWatermarkEvent {
+    return new AudioWatermarkEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AudioWatermarkEvent | PlainMessage<AudioWatermarkEvent> | undefined, b: AudioWatermarkEvent | PlainMessage<AudioWatermarkEvent> | undefined): boolean {
+    return proto3.util.equals(AudioWatermarkEvent, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.DeltacastChannel
  */
@@ -7654,115 +8112,391 @@ export class FileMp4InputStatus extends Message<FileMp4InputStatus> {
    */
   state = FileMp4InputStatus_State.INPUT_STATUS_UNKNOWN;
 
-  constructor(data?: PartialMessage<FileMp4InputStatus>) {
+  constructor(data?: PartialMessage<FileMp4InputStatus>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FileMp4InputStatus";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "state", kind: "enum", T: proto3.getEnumType(FileMp4InputStatus_State) },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputStatus {
+    return new FileMp4InputStatus().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputStatus {
+    return new FileMp4InputStatus().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputStatus {
+    return new FileMp4InputStatus().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FileMp4InputStatus | PlainMessage<FileMp4InputStatus> | undefined, b: FileMp4InputStatus | PlainMessage<FileMp4InputStatus> | undefined): boolean {
+    return proto3.util.equals(FileMp4InputStatus, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.FileMp4InputStatus.State
+ */
+export enum FileMp4InputStatus_State {
+  /**
+   * @generated from enum value: INPUT_STATUS_UNKNOWN = 0;
+   */
+  INPUT_STATUS_UNKNOWN = 0,
+
+  /**
+   * @generated from enum value: INPUT_STATUS_EOF = 1;
+   */
+  INPUT_STATUS_EOF = 1,
+
+  /**
+   * @generated from enum value: INPUT_STATUS_EOF_LOOPING = 2;
+   */
+  INPUT_STATUS_EOF_LOOPING = 2,
+
+  /**
+   * @generated from enum value: INPUT_STATUS_STOP_POSITION = 3;
+   */
+  INPUT_STATUS_STOP_POSITION = 3,
+}
+// Retrieve enum metadata with: proto3.getEnumType(FileMp4InputStatus_State)
+proto3.util.setEnumType(FileMp4InputStatus_State, "norsk.api.media.FileMp4InputStatus.State", [
+  { no: 0, name: "INPUT_STATUS_UNKNOWN" },
+  { no: 1, name: "INPUT_STATUS_EOF" },
+  { no: 2, name: "INPUT_STATUS_EOF_LOOPING" },
+  { no: 3, name: "INPUT_STATUS_STOP_POSITION" },
+]);
+
+/**
+ * @generated from message norsk.api.media.FileMp4InputInfo
+ */
+export class FileMp4InputInfo extends Message<FileMp4InputInfo> {
+  /**
+   * @generated from field: norsk.api.common.OptionalInt byte_length = 1;
+   */
+  byteLength?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt duration_ms = 2;
+   */
+  durationMs?: OptionalInt;
+
+  constructor(data?: PartialMessage<FileMp4InputInfo>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FileMp4InputInfo";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "byte_length", kind: "message", T: OptionalInt },
+    { no: 2, name: "duration_ms", kind: "message", T: OptionalInt },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputInfo {
+    return new FileMp4InputInfo().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputInfo {
+    return new FileMp4InputInfo().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputInfo {
+    return new FileMp4InputInfo().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FileMp4InputInfo | PlainMessage<FileMp4InputInfo> | undefined, b: FileMp4InputInfo | PlainMessage<FileMp4InputInfo> | undefined): boolean {
+    return proto3.util.equals(FileMp4InputInfo, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.FileMp4InputEvent
+ */
+export class FileMp4InputEvent extends Message<FileMp4InputEvent> {
+  /**
+   * @generated from oneof norsk.api.media.FileMp4InputEvent.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.MediaNodeId node_id = 1;
+     */
+    value: MediaNodeId;
+    case: "nodeId";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context outbound_context = 2;
+     */
+    value: Context;
+    case: "outboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.FileMp4InputStatus status = 3;
+     */
+    value: FileMp4InputStatus;
+    case: "status";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.FileMp4InputInfo info = 4;
+     */
+    value: FileMp4InputInfo;
+    case: "info";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 5;
+     */
+    value: MultiStreamStatistics;
+    case: "streamStatistics";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.GopStructure gop_structure = 6;
+     */
+    value: GopStructure;
+    case: "gopStructure";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<FileMp4InputEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FileMp4InputEvent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { 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: "status", kind: "message", T: FileMp4InputStatus, oneof: "message" },
+    { no: 4, name: "info", kind: "message", T: FileMp4InputInfo, oneof: "message" },
+    { no: 5, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
+    { no: 6, name: "gop_structure", kind: "message", T: GopStructure, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputEvent {
+    return new FileMp4InputEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputEvent {
+    return new FileMp4InputEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputEvent {
+    return new FileMp4InputEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FileMp4InputEvent | PlainMessage<FileMp4InputEvent> | undefined, b: FileMp4InputEvent | PlainMessage<FileMp4InputEvent> | undefined): boolean {
+    return proto3.util.equals(FileMp4InputEvent, a, b);
+  }
+}
+
+/**
+ * ///////////////////////////////
+ * WAV Input
+ *
+ * @generated from message norsk.api.media.FileWavInputConfiguration
+ */
+export class FileWavInputConfiguration extends Message<FileWavInputConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * @generated from field: string source_name = 2;
+   */
+  sourceName = "";
+
+  /**
+   * @generated from field: string file_name = 3;
+   */
+  fileName = "";
+
+  constructor(data?: PartialMessage<FileWavInputConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FileWavInputConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileWavInputConfiguration {
+    return new FileWavInputConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileWavInputConfiguration {
+    return new FileWavInputConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileWavInputConfiguration {
+    return new FileWavInputConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FileWavInputConfiguration | PlainMessage<FileWavInputConfiguration> | undefined, b: FileWavInputConfiguration | PlainMessage<FileWavInputConfiguration> | undefined): boolean {
+    return proto3.util.equals(FileWavInputConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.FileWavInputEvent
+ */
+export class FileWavInputEvent extends Message<FileWavInputEvent> {
+  /**
+   * @generated from oneof norsk.api.media.FileWavInputEvent.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.MediaNodeId node_id = 1;
+     */
+    value: MediaNodeId;
+    case: "nodeId";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context outbound_context = 2;
+     */
+    value: Context;
+    case: "outboundContext";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<FileWavInputEvent>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FileMp4InputStatus";
+  static readonly typeName = "norsk.api.media.FileWavInputEvent";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "state", kind: "enum", T: proto3.getEnumType(FileMp4InputStatus_State) },
+    { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
+    { no: 2, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputStatus {
-    return new FileMp4InputStatus().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileWavInputEvent {
+    return new FileWavInputEvent().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputStatus {
-    return new FileMp4InputStatus().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileWavInputEvent {
+    return new FileWavInputEvent().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputStatus {
-    return new FileMp4InputStatus().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileWavInputEvent {
+    return new FileWavInputEvent().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FileMp4InputStatus | PlainMessage<FileMp4InputStatus> | undefined, b: FileMp4InputStatus | PlainMessage<FileMp4InputStatus> | undefined): boolean {
-    return proto3.util.equals(FileMp4InputStatus, a, b);
+  static equals(a: FileWavInputEvent | PlainMessage<FileWavInputEvent> | undefined, b: FileWavInputEvent | PlainMessage<FileWavInputEvent> | undefined): boolean {
+    return proto3.util.equals(FileWavInputEvent, a, b);
   }
 }
 
 /**
- * @generated from enum norsk.api.media.FileMp4InputStatus.State
+ * ///////////////////////////////
+ * WAV Output
+ *
+ * @generated from message norsk.api.media.FileWavOutputConfiguration
  */
-export enum FileMp4InputStatus_State {
+export class FileWavOutputConfiguration extends Message<FileWavOutputConfiguration> {
   /**
-   * @generated from enum value: INPUT_STATUS_UNKNOWN = 0;
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
    */
-  INPUT_STATUS_UNKNOWN = 0,
+  id?: MediaNodeId;
 
   /**
-   * @generated from enum value: INPUT_STATUS_EOF = 1;
+   * @generated from field: string file_name = 2;
    */
-  INPUT_STATUS_EOF = 1,
+  fileName = "";
 
-  /**
-   * @generated from enum value: INPUT_STATUS_EOF_LOOPING = 2;
-   */
-  INPUT_STATUS_EOF_LOOPING = 2,
+  constructor(data?: PartialMessage<FileWavOutputConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
 
-  /**
-   * @generated from enum value: INPUT_STATUS_STOP_POSITION = 3;
-   */
-  INPUT_STATUS_STOP_POSITION = 3,
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FileWavOutputConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileWavOutputConfiguration {
+    return new FileWavOutputConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileWavOutputConfiguration {
+    return new FileWavOutputConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileWavOutputConfiguration {
+    return new FileWavOutputConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FileWavOutputConfiguration | PlainMessage<FileWavOutputConfiguration> | undefined, b: FileWavOutputConfiguration | PlainMessage<FileWavOutputConfiguration> | undefined): boolean {
+    return proto3.util.equals(FileWavOutputConfiguration, a, b);
+  }
 }
-// Retrieve enum metadata with: proto3.getEnumType(FileMp4InputStatus_State)
-proto3.util.setEnumType(FileMp4InputStatus_State, "norsk.api.media.FileMp4InputStatus.State", [
-  { no: 0, name: "INPUT_STATUS_UNKNOWN" },
-  { no: 1, name: "INPUT_STATUS_EOF" },
-  { no: 2, name: "INPUT_STATUS_EOF_LOOPING" },
-  { no: 3, name: "INPUT_STATUS_STOP_POSITION" },
-]);
 
 /**
- * @generated from message norsk.api.media.FileMp4InputInfo
+ * @generated from message norsk.api.media.FileWavOutputMessage
  */
-export class FileMp4InputInfo extends Message<FileMp4InputInfo> {
-  /**
-   * @generated from field: norsk.api.common.OptionalInt byte_length = 1;
-   */
-  byteLength?: OptionalInt;
-
+export class FileWavOutputMessage extends Message<FileWavOutputMessage> {
   /**
-   * @generated from field: norsk.api.common.OptionalInt duration_ms = 2;
+   * @generated from oneof norsk.api.media.FileWavOutputMessage.message
    */
-  durationMs?: OptionalInt;
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Subscription subscription = 1;
+     */
+    value: Subscription;
+    case: "subscription";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.FileWavOutputConfiguration configuration = 2;
+     */
+    value: FileWavOutputConfiguration;
+    case: "configuration";
+  } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<FileMp4InputInfo>) {
+  constructor(data?: PartialMessage<FileWavOutputMessage>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FileMp4InputInfo";
+  static readonly typeName = "norsk.api.media.FileWavOutputMessage";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "byte_length", kind: "message", T: OptionalInt },
-    { no: 2, name: "duration_ms", kind: "message", T: OptionalInt },
+    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+    { no: 2, name: "configuration", kind: "message", T: FileWavOutputConfiguration, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputInfo {
-    return new FileMp4InputInfo().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileWavOutputMessage {
+    return new FileWavOutputMessage().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputInfo {
-    return new FileMp4InputInfo().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileWavOutputMessage {
+    return new FileWavOutputMessage().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputInfo {
-    return new FileMp4InputInfo().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileWavOutputMessage {
+    return new FileWavOutputMessage().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FileMp4InputInfo | PlainMessage<FileMp4InputInfo> | undefined, b: FileMp4InputInfo | PlainMessage<FileMp4InputInfo> | undefined): boolean {
-    return proto3.util.equals(FileMp4InputInfo, a, b);
+  static equals(a: FileWavOutputMessage | PlainMessage<FileWavOutputMessage> | undefined, b: FileWavOutputMessage | PlainMessage<FileWavOutputMessage> | undefined): boolean {
+    return proto3.util.equals(FileWavOutputMessage, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.FileMp4InputEvent
+ * @generated from message norsk.api.media.FileWavOutputEvent
  */
-export class FileMp4InputEvent extends Message<FileMp4InputEvent> {
+export class FileWavOutputEvent extends Message<FileWavOutputEvent> {
   /**
-   * @generated from oneof norsk.api.media.FileMp4InputEvent.message
+   * @generated from oneof norsk.api.media.FileWavOutputEvent.message
    */
   message: {
     /**
@@ -7772,66 +8506,45 @@ export class FileMp4InputEvent extends Message<FileMp4InputEvent> {
     case: "nodeId";
   } | {
     /**
-     * @generated from field: norsk.api.media.Context outbound_context = 2;
-     */
-    value: Context;
-    case: "outboundContext";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.FileMp4InputStatus status = 3;
-     */
-    value: FileMp4InputStatus;
-    case: "status";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.FileMp4InputInfo info = 4;
-     */
-    value: FileMp4InputInfo;
-    case: "info";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 5;
+     * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 2;
      */
-    value: MultiStreamStatistics;
-    case: "streamStatistics";
+    value: SubscriptionResponse;
+    case: "subscriptionResponse";
   } | {
     /**
-     * @generated from field: norsk.api.media.GopStructure gop_structure = 6;
+     * @generated from field: norsk.api.media.Context inbound_context = 3;
      */
-    value: GopStructure;
-    case: "gopStructure";
+    value: Context;
+    case: "inboundContext";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<FileMp4InputEvent>) {
+  constructor(data?: PartialMessage<FileWavOutputEvent>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FileMp4InputEvent";
+  static readonly typeName = "norsk.api.media.FileWavOutputEvent";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { 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: "status", kind: "message", T: FileMp4InputStatus, oneof: "message" },
-    { no: 4, name: "info", kind: "message", T: FileMp4InputInfo, oneof: "message" },
-    { no: 5, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
-    { no: 6, name: "gop_structure", kind: "message", T: GopStructure, oneof: "message" },
+    { no: 2, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
+    { no: 3, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputEvent {
-    return new FileMp4InputEvent().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileWavOutputEvent {
+    return new FileWavOutputEvent().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputEvent {
-    return new FileMp4InputEvent().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileWavOutputEvent {
+    return new FileWavOutputEvent().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputEvent {
-    return new FileMp4InputEvent().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileWavOutputEvent {
+    return new FileWavOutputEvent().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FileMp4InputEvent | PlainMessage<FileMp4InputEvent> | undefined, b: FileMp4InputEvent | PlainMessage<FileMp4InputEvent> | undefined): boolean {
-    return proto3.util.equals(FileMp4InputEvent, a, b);
+  static equals(a: FileWavOutputEvent | PlainMessage<FileWavOutputEvent> | undefined, b: FileWavOutputEvent | PlainMessage<FileWavOutputEvent> | undefined): boolean {
+    return proto3.util.equals(FileWavOutputEvent, a, b);
   }
 }
 
@@ -7954,6 +8667,16 @@ export class AudioSignalGeneratorConfiguration extends Message<AudioSignalGenera
    */
   wave?: Wave;
 
+  /**
+   * @generated from field: norsk.api.common.OptionalInt samples_per_frame = 8;
+   */
+  samplesPerFrame?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt output_frame_count = 9;
+   */
+  outputFrameCount?: OptionalInt;
+
   constructor(data?: PartialMessage<AudioSignalGeneratorConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -7969,6 +8692,8 @@ export class AudioSignalGeneratorConfiguration extends Message<AudioSignalGenera
     { no: 5, name: "sampleFormat", kind: "enum", T: proto3.getEnumType(SampleFormat) },
     { no: 6, name: "language", kind: "message", T: OptionalString },
     { no: 7, name: "wave", kind: "message", T: Wave },
+    { no: 8, name: "samples_per_frame", kind: "message", T: OptionalInt },
+    { no: 9, name: "output_frame_count", kind: "message", T: OptionalInt },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioSignalGeneratorConfiguration {
@@ -11423,66 +12148,190 @@ export class CmafVideoConfiguration extends Message<CmafVideoConfiguration> {
 }
 
 /**
- * @generated from message norsk.api.media.CmafVideoMessage
+ * @generated from message norsk.api.media.CmafVideoMessage
+ */
+export class CmafVideoMessage extends Message<CmafVideoMessage> {
+  /**
+   * @generated from oneof norsk.api.media.CmafVideoMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Subscription subscription = 1;
+     */
+    value: Subscription;
+    case: "subscription";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.CmafVideoConfiguration configuration = 2;
+     */
+    value: CmafVideoConfiguration;
+    case: "configuration";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.UpdateCredentials update_credentials = 3;
+     */
+    value: UpdateCredentials;
+    case: "updateCredentials";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.UpdateDestinationPlaylist update_playlist = 4;
+     */
+    value: UpdateDestinationPlaylist;
+    case: "updatePlaylist";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<CmafVideoMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.CmafVideoMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+    { no: 2, name: "configuration", kind: "message", T: CmafVideoConfiguration, oneof: "message" },
+    { no: 3, name: "update_credentials", kind: "message", T: UpdateCredentials, oneof: "message" },
+    { no: 4, name: "update_playlist", kind: "message", T: UpdateDestinationPlaylist, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafVideoMessage {
+    return new CmafVideoMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafVideoMessage {
+    return new CmafVideoMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafVideoMessage {
+    return new CmafVideoMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: CmafVideoMessage | PlainMessage<CmafVideoMessage> | undefined, b: CmafVideoMessage | PlainMessage<CmafVideoMessage> | undefined): boolean {
+    return proto3.util.equals(CmafVideoMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SegmentationExactFrameCount
+ */
+export class SegmentationExactFrameCount extends Message<SegmentationExactFrameCount> {
+  /**
+   * @generated from field: int32 frame_count = 1;
+   */
+  frameCount = 0;
+
+  constructor(data?: PartialMessage<SegmentationExactFrameCount>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SegmentationExactFrameCount";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "frame_count", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SegmentationExactFrameCount {
+    return new SegmentationExactFrameCount().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SegmentationExactFrameCount {
+    return new SegmentationExactFrameCount().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SegmentationExactFrameCount {
+    return new SegmentationExactFrameCount().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SegmentationExactFrameCount | PlainMessage<SegmentationExactFrameCount> | undefined, b: SegmentationExactFrameCount | PlainMessage<SegmentationExactFrameCount> | undefined): boolean {
+    return proto3.util.equals(SegmentationExactFrameCount, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SegmentationExactIdrCount
+ */
+export class SegmentationExactIdrCount extends Message<SegmentationExactIdrCount> {
+  /**
+   * @generated from field: int32 idr_count = 1;
+   */
+  idrCount = 0;
+
+  constructor(data?: PartialMessage<SegmentationExactIdrCount>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SegmentationExactIdrCount";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "idr_count", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SegmentationExactIdrCount {
+    return new SegmentationExactIdrCount().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SegmentationExactIdrCount {
+    return new SegmentationExactIdrCount().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SegmentationExactIdrCount {
+    return new SegmentationExactIdrCount().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SegmentationExactIdrCount | PlainMessage<SegmentationExactIdrCount> | undefined, b: SegmentationExactIdrCount | PlainMessage<SegmentationExactIdrCount> | undefined): boolean {
+    return proto3.util.equals(SegmentationExactIdrCount, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SegmentationStrategy
  */
-export class CmafVideoMessage extends Message<CmafVideoMessage> {
+export class SegmentationStrategy extends Message<SegmentationStrategy> {
   /**
-   * @generated from oneof norsk.api.media.CmafVideoMessage.message
+   * @generated from oneof norsk.api.media.SegmentationStrategy.message
    */
   message: {
     /**
-     * @generated from field: norsk.api.media.Subscription subscription = 1;
-     */
-    value: Subscription;
-    case: "subscription";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.CmafVideoConfiguration configuration = 2;
-     */
-    value: CmafVideoConfiguration;
-    case: "configuration";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.UpdateCredentials update_credentials = 3;
+     * @generated from field: norsk.api.media.SegmentationExactFrameCount frame_count = 1;
      */
-    value: UpdateCredentials;
-    case: "updateCredentials";
+    value: SegmentationExactFrameCount;
+    case: "frameCount";
   } | {
     /**
-     * @generated from field: norsk.api.media.UpdateDestinationPlaylist update_playlist = 4;
+     * @generated from field: norsk.api.media.SegmentationExactIdrCount idr_count = 2;
      */
-    value: UpdateDestinationPlaylist;
-    case: "updatePlaylist";
+    value: SegmentationExactIdrCount;
+    case: "idrCount";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<CmafVideoMessage>) {
+  constructor(data?: PartialMessage<SegmentationStrategy>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.CmafVideoMessage";
+  static readonly typeName = "norsk.api.media.SegmentationStrategy";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
-    { no: 2, name: "configuration", kind: "message", T: CmafVideoConfiguration, oneof: "message" },
-    { no: 3, name: "update_credentials", kind: "message", T: UpdateCredentials, oneof: "message" },
-    { no: 4, name: "update_playlist", kind: "message", T: UpdateDestinationPlaylist, oneof: "message" },
+    { no: 1, name: "frame_count", kind: "message", T: SegmentationExactFrameCount, oneof: "message" },
+    { no: 2, name: "idr_count", kind: "message", T: SegmentationExactIdrCount, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafVideoMessage {
-    return new CmafVideoMessage().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SegmentationStrategy {
+    return new SegmentationStrategy().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafVideoMessage {
-    return new CmafVideoMessage().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SegmentationStrategy {
+    return new SegmentationStrategy().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafVideoMessage {
-    return new CmafVideoMessage().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SegmentationStrategy {
+    return new SegmentationStrategy().fromJsonString(jsonString, options);
   }
 
-  static equals(a: CmafVideoMessage | PlainMessage<CmafVideoMessage> | undefined, b: CmafVideoMessage | PlainMessage<CmafVideoMessage> | undefined): boolean {
-    return proto3.util.equals(CmafVideoMessage, a, b);
+  static equals(a: SegmentationStrategy | PlainMessage<SegmentationStrategy> | undefined, b: SegmentationStrategy | PlainMessage<SegmentationStrategy> | undefined): boolean {
+    return proto3.util.equals(SegmentationStrategy, a, b);
   }
 }
 
@@ -11544,6 +12393,11 @@ export class HlsTsVideoConfiguration extends Message<HlsTsVideoConfiguration> {
    */
   metrics = NodeMetricsMode.NODE_METRICS_DEFAULT;
 
+  /**
+   * @generated from field: norsk.api.media.SegmentationStrategy segmentation_strategy = 12;
+   */
+  segmentationStrategy?: SegmentationStrategy;
+
   constructor(data?: PartialMessage<HlsTsVideoConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -11562,6 +12416,7 @@ export class HlsTsVideoConfiguration extends Message<HlsTsVideoConfiguration> {
     { no: 9, name: "name", kind: "message", T: OptionalString },
     { no: 10, name: "pdt_every_segment", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
     { no: 11, name: "metrics", kind: "enum", T: proto3.getEnumType(NodeMetricsMode) },
+    { no: 12, name: "segmentation_strategy", kind: "message", T: SegmentationStrategy },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsVideoConfiguration {
@@ -11868,6 +12723,11 @@ export class HlsTsAudioConfiguration extends Message<HlsTsAudioConfiguration> {
    */
   metrics = NodeMetricsMode.NODE_METRICS_DEFAULT;
 
+  /**
+   * @generated from field: norsk.api.media.SegmentationStrategy segmentation_strategy = 12;
+   */
+  segmentationStrategy?: SegmentationStrategy;
+
   constructor(data?: PartialMessage<HlsTsAudioConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -11886,6 +12746,7 @@ export class HlsTsAudioConfiguration extends Message<HlsTsAudioConfiguration> {
     { no: 9, name: "name", kind: "message", T: OptionalString },
     { no: 10, name: "pdt_every_segment", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
     { no: 11, name: "metrics", kind: "enum", T: proto3.getEnumType(NodeMetricsMode) },
+    { no: 12, name: "segmentation_strategy", kind: "message", T: SegmentationStrategy },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsAudioConfiguration {
@@ -13053,6 +13914,11 @@ export class HlsTsCombinedPushConfiguration extends Message<HlsTsCombinedPushCon
    */
   pdtEverySegment = false;
 
+  /**
+   * @generated from field: norsk.api.media.SegmentationStrategy segmentation_strategy = 11;
+   */
+  segmentationStrategy?: SegmentationStrategy;
+
   constructor(data?: PartialMessage<HlsTsCombinedPushConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -13069,6 +13935,7 @@ export class HlsTsCombinedPushConfiguration extends Message<HlsTsCombinedPushCon
     { no: 7, name: "m3u_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 9, name: "name", kind: "message", T: OptionalString },
     { no: 10, name: "pdt_every_segment", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 11, name: "segmentation_strategy", kind: "message", T: SegmentationStrategy },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsCombinedPushConfiguration {
@@ -16688,6 +17555,18 @@ export class VideoEncodeStream extends Message<VideoEncodeStream> {
      */
     value: AmdMA35DHevc;
     case: "amdMA35DHevc";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.QuadraAv1 quadraAv1 = 17;
+     */
+    value: QuadraAv1;
+    case: "quadraAv1";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.AmdMA35DAv1 amdMA35DAv1 = 18;
+     */
+    value: AmdMA35DAv1;
+    case: "amdMA35DAv1";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<VideoEncodeStream>) {
@@ -16714,6 +17593,8 @@ export class VideoEncodeStream extends Message<VideoEncodeStream> {
     { no: 14, name: "amdU30Hevc", kind: "message", T: AmdU30Hevc, oneof: "codec" },
     { no: 15, name: "amdMA35DH264", kind: "message", T: AmdMA35DH264, oneof: "codec" },
     { no: 16, name: "amdMA35DHevc", kind: "message", T: AmdMA35DHevc, oneof: "codec" },
+    { no: 17, name: "quadraAv1", kind: "message", T: QuadraAv1, oneof: "codec" },
+    { no: 18, name: "amdMA35DAv1", kind: "message", T: AmdMA35DAv1, oneof: "codec" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncodeStream {
@@ -17443,30 +18324,237 @@ proto3.util.setEnumType(NvidiaHevc_NvidiaHevcProfile, "norsk.api.media.NvidiaHev
   { no: 2, name: "NVIDIA_HEVC_PROFILE_MAIN10" },
 ]);
 
-/**
- * @generated from enum norsk.api.media.NvidiaHevc.NvidiaHevcTier
- */
-export enum NvidiaHevc_NvidiaHevcTier {
+/**
+ * @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.common.OptionalBool enableAud = 2;
+   */
+  enableAud?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt gpuIndex = 3;
+   */
+  gpuIndex?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt bitrate = 4;
+   */
+  bitrate?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalBool enableVfr = 6;
+   */
+  enableVfr?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt crf = 7;
+   */
+  crf?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt gopPresetIndex = 9;
+   */
+  gopPresetIndex?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt intraPeriod = 10;
+   */
+  intraPeriod?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.QuadraH264.QuadraH264Profile profile = 11;
+   */
+  profile = QuadraH264_QuadraH264Profile.DEFAULT;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt level = 12;
+   */
+  level?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalBool rcEnable = 13;
+   */
+  rcEnable?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt intraQp = 14;
+   */
+  intraQp?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalBool hrdEnable = 18;
+   */
+  hrdEnable?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt dolbyVisionProfile = 19;
+   */
+  dolbyVisionProfile?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalBool fillerEnable = 20;
+   */
+  fillerEnable?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt minQp = 21;
+   */
+  minQp?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt maxQp = 22;
+   */
+  maxQp?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt maxDeltaQp = 23;
+   */
+  maxDeltaQp?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalBool cuLevelRCEnable = 24;
+   */
+  cuLevelRCEnable?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt lookAheadDepth = 25;
+   */
+  lookAheadDepth?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt vbvBufferSize = 26;
+   */
+  vbvBufferSize?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt vbvMaxRate = 27;
+   */
+  vbvMaxRate?: 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: 6, name: "enableVfr", kind: "message", T: OptionalBool },
+    { no: 7, name: "crf", kind: "message", T: OptionalInt },
+    { 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: 18, name: "hrdEnable", kind: "message", T: OptionalBool },
+    { no: 19, name: "dolbyVisionProfile", kind: "message", T: OptionalInt },
+    { no: 20, name: "fillerEnable", kind: "message", T: OptionalBool },
+    { no: 21, name: "minQp", kind: "message", T: OptionalInt },
+    { no: 22, name: "maxQp", kind: "message", T: OptionalInt },
+    { no: 23, name: "maxDeltaQp", kind: "message", T: OptionalInt },
+    { no: 24, name: "cuLevelRCEnable", kind: "message", T: OptionalBool },
+    { no: 25, name: "lookAheadDepth", kind: "message", T: OptionalInt },
+    { no: 26, name: "vbvBufferSize", kind: "message", T: OptionalInt },
+    { no: 27, name: "vbvMaxRate", 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: NVIDIA_HEVC_TIER_MAIN = 0;
+   * @generated from enum value: QUADRA_H264_PROFILE_HIGH = 4;
    */
-  MAIN = 0,
+  HIGH = 4,
 
   /**
-   * @generated from enum value: NVIDIA_HEVC_TIER_HIGH = 1;
+   * @generated from enum value: QUADRA_H264_PROFILE_HIGH10 = 5;
    */
-  HIGH = 1,
+  HIGH10 = 5,
 }
-// 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(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.QuadraH264
+ * @generated from message norsk.api.media.QuadraHevc
  */
-export class QuadraH264 extends Message<QuadraH264> {
+export class QuadraHevc extends Message<QuadraHevc> {
   /**
    * @generated from field: string extraOpts = 1;
    */
@@ -17508,22 +18596,32 @@ export class QuadraH264 extends Message<QuadraH264> {
   intraPeriod?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.QuadraH264.QuadraH264Profile profile = 11;
+   * @generated from field: norsk.api.media.QuadraHevc.QuadraHevcTier tier = 11;
    */
-  profile = QuadraH264_QuadraH264Profile.DEFAULT;
+  tier = QuadraHevc_QuadraHevcTier.MAIN;
 
   /**
-   * @generated from field: norsk.api.common.OptionalInt level = 12;
+   * @generated from field: norsk.api.media.QuadraHevc.QuadraHevcProfile profile = 12;
+   */
+  profile = QuadraHevc_QuadraHevcProfile.DEFAULT;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt level = 13;
    */
   level?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.common.OptionalBool rcEnable = 13;
+   * @generated from field: norsk.api.common.OptionalBool rcEnable = 14;
    */
   rcEnable?: OptionalBool;
 
   /**
-   * @generated from field: norsk.api.common.OptionalInt intraQp = 14;
+   * @generated from field: norsk.api.common.OptionalBool lossless = 15;
+   */
+  lossless?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt intraQp = 16;
    */
   intraQp?: OptionalInt;
 
@@ -17577,13 +18675,13 @@ export class QuadraH264 extends Message<QuadraH264> {
    */
   vbvMaxRate?: OptionalInt;
 
-  constructor(data?: PartialMessage<QuadraH264>) {
+  constructor(data?: PartialMessage<QuadraHevc>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.QuadraH264";
+  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 },
@@ -17593,10 +18691,12 @@ export class QuadraH264 extends Message<QuadraH264> {
     { no: 7, name: "crf", kind: "message", T: OptionalInt },
     { 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: 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: 18, name: "hrdEnable", kind: "message", T: OptionalBool },
     { no: 19, name: "dolbyVisionProfile", kind: "message", T: OptionalInt },
     { no: 20, name: "fillerEnable", kind: "message", T: OptionalBool },
@@ -17609,71 +18709,73 @@ export class QuadraH264 extends Message<QuadraH264> {
     { no: 27, name: "vbvMaxRate", kind: "message", T: OptionalInt },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuadraH264 {
-    return new QuadraH264().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuadraHevc {
+    return new QuadraHevc().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuadraH264 {
-    return new QuadraH264().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuadraHevc {
+    return new QuadraHevc().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuadraH264 {
-    return new QuadraH264().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuadraHevc {
+    return new QuadraHevc().fromJsonString(jsonString, options);
   }
 
-  static equals(a: QuadraH264 | PlainMessage<QuadraH264> | undefined, b: QuadraH264 | PlainMessage<QuadraH264> | undefined): boolean {
-    return proto3.util.equals(QuadraH264, 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.QuadraH264.QuadraH264Profile
+ * @generated from enum norsk.api.media.QuadraHevc.QuadraHevcProfile
  */
-export enum QuadraH264_QuadraH264Profile {
+export enum QuadraHevc_QuadraHevcProfile {
   /**
-   * @generated from enum value: QUADRA_H264_PROFILE_DEFAULT = 0;
+   * @generated from enum value: QUADRA_HEVC_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;
+   * @generated from enum value: QUADRA_HEVC_PROFILE_MAIN = 1;
    */
-  MAIN = 2,
+  MAIN = 1,
 
   /**
-   * @generated from enum value: QUADRA_H264_PROFILE_EXTENDED = 3;
+   * @generated from enum value: QUADRA_HEVC_PROFILE_MAIN10 = 2;
    */
-  EXTENDED = 3,
+  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_H264_PROFILE_HIGH = 4;
+   * @generated from enum value: QUADRA_HEVC_TIER_MAIN = 0;
    */
-  HIGH = 4,
+  MAIN = 0,
 
   /**
-   * @generated from enum value: QUADRA_H264_PROFILE_HIGH10 = 5;
+   * @generated from enum value: QUADRA_HEVC_TIER_HIGH = 1;
    */
-  HIGH10 = 5,
+  HIGH = 1,
 }
-// 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" },
+// 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.QuadraHevc
+ * @generated from message norsk.api.media.QuadraAv1
  */
-export class QuadraHevc extends Message<QuadraHevc> {
+export class QuadraAv1 extends Message<QuadraAv1> {
   /**
    * @generated from field: string extraOpts = 1;
    */
@@ -17715,14 +18817,14 @@ export class QuadraHevc extends Message<QuadraHevc> {
   intraPeriod?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.QuadraHevc.QuadraHevcTier tier = 11;
+   * @generated from field: norsk.api.media.QuadraAv1.QuadraAv1Tier tier = 11;
    */
-  tier = QuadraHevc_QuadraHevcTier.MAIN;
+  tier = QuadraAv1_QuadraAv1Tier.MAIN;
 
   /**
-   * @generated from field: norsk.api.media.QuadraHevc.QuadraHevcProfile profile = 12;
+   * @generated from field: norsk.api.media.QuadraAv1.QuadraAv1Profile profile = 12;
    */
-  profile = QuadraHevc_QuadraHevcProfile.DEFAULT;
+  profile = QuadraAv1_QuadraAv1Profile.MAIN_420_8;
 
   /**
    * @generated from field: norsk.api.common.OptionalInt level = 13;
@@ -17794,13 +18896,13 @@ export class QuadraHevc extends Message<QuadraHevc> {
    */
   vbvMaxRate?: OptionalInt;
 
-  constructor(data?: PartialMessage<QuadraHevc>) {
+  constructor(data?: PartialMessage<QuadraAv1>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.QuadraHevc";
+  static readonly typeName = "norsk.api.media.QuadraAv1";
   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 },
@@ -17810,8 +18912,8 @@ export class QuadraHevc extends Message<QuadraHevc> {
     { no: 7, name: "crf", kind: "message", T: OptionalInt },
     { 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: 11, name: "tier", kind: "enum", T: proto3.getEnumType(QuadraAv1_QuadraAv1Tier) },
+    { no: 12, name: "profile", kind: "enum", T: proto3.getEnumType(QuadraAv1_QuadraAv1Profile) },
     { no: 13, name: "level", kind: "message", T: OptionalInt },
     { no: 14, name: "rcEnable", kind: "message", T: OptionalBool },
     { no: 15, name: "lossless", kind: "message", T: OptionalBool },
@@ -17828,67 +18930,55 @@ export class QuadraHevc extends Message<QuadraHevc> {
     { no: 27, name: "vbvMaxRate", kind: "message", T: OptionalInt },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuadraHevc {
-    return new QuadraHevc().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuadraAv1 {
+    return new QuadraAv1().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuadraHevc {
-    return new QuadraHevc().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuadraAv1 {
+    return new QuadraAv1().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuadraHevc {
-    return new QuadraHevc().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuadraAv1 {
+    return new QuadraAv1().fromJsonString(jsonString, options);
   }
 
-  static equals(a: QuadraHevc | PlainMessage<QuadraHevc> | undefined, b: QuadraHevc | PlainMessage<QuadraHevc> | undefined): boolean {
-    return proto3.util.equals(QuadraHevc, a, b);
+  static equals(a: QuadraAv1 | PlainMessage<QuadraAv1> | undefined, b: QuadraAv1 | PlainMessage<QuadraAv1> | undefined): boolean {
+    return proto3.util.equals(QuadraAv1, a, b);
   }
 }
 
 /**
- * @generated from enum norsk.api.media.QuadraHevc.QuadraHevcProfile
+ * @generated from enum norsk.api.media.QuadraAv1.QuadraAv1Profile
  */
-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,
-
+export enum QuadraAv1_QuadraAv1Profile {
   /**
-   * @generated from enum value: QUADRA_HEVC_PROFILE_MAIN10 = 2;
+   * @generated from enum value: QUADRA_AV1_PROFILE_MAIN_420_8 = 0;
    */
-  MAIN10 = 2,
+  MAIN_420_8 = 0,
 }
-// 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" },
+// Retrieve enum metadata with: proto3.getEnumType(QuadraAv1_QuadraAv1Profile)
+proto3.util.setEnumType(QuadraAv1_QuadraAv1Profile, "norsk.api.media.QuadraAv1.QuadraAv1Profile", [
+  { no: 0, name: "QUADRA_AV1_PROFILE_MAIN_420_8" },
 ]);
 
 /**
- * @generated from enum norsk.api.media.QuadraHevc.QuadraHevcTier
+ * @generated from enum norsk.api.media.QuadraAv1.QuadraAv1Tier
  */
-export enum QuadraHevc_QuadraHevcTier {
+export enum QuadraAv1_QuadraAv1Tier {
   /**
-   * @generated from enum value: QUADRA_HEVC_TIER_MAIN = 0;
+   * @generated from enum value: QUADRA_AV1_TIER_MAIN = 0;
    */
   MAIN = 0,
 
   /**
-   * @generated from enum value: QUADRA_HEVC_TIER_HIGH = 1;
+   * @generated from enum value: QUADRA_AV1_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" },
+// Retrieve enum metadata with: proto3.getEnumType(QuadraAv1_QuadraAv1Tier)
+proto3.util.setEnumType(QuadraAv1_QuadraAv1Tier, "norsk.api.media.QuadraAv1.QuadraAv1Tier", [
+  { no: 0, name: "QUADRA_AV1_TIER_MAIN" },
+  { no: 1, name: "QUADRA_AV1_TIER_HIGH" },
 ]);
 
 /**
@@ -19282,6 +20372,95 @@ proto3.util.setEnumType(AmdMA35DHevc_AmdMA35DHevcTier, "norsk.api.media.AmdMA35D
   { no: 1, name: "AMD_MA35D_HEVC_TIER_HIGH" },
 ]);
 
+/**
+ * @generated from message norsk.api.media.AmdMA35DAv1
+ */
+export class AmdMA35DAv1 extends Message<AmdMA35DAv1> {
+  /**
+   * @generated from field: norsk.api.media.AmdMA35DAv1.AmdMA35DAv1Tier tier = 1;
+   */
+  tier = AmdMA35DAv1_AmdMA35DAv1Tier.AMD_MA35D_AV1_TIER_MAIN;
+
+  /**
+   * @generated from field: norsk.api.media.AmdMA35DAv1.AmdMA35DAv1Profile profile = 2;
+   */
+  profile = AmdMA35DAv1_AmdMA35DAv1Profile.AMD_MA35D_AV1_PROFILE_MAIN;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt level = 3;
+   */
+  level?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.AmdMA35DEncodeCommon common = 4;
+   */
+  common?: AmdMA35DEncodeCommon;
+
+  constructor(data?: PartialMessage<AmdMA35DAv1>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AmdMA35DAv1";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "tier", kind: "enum", T: proto3.getEnumType(AmdMA35DAv1_AmdMA35DAv1Tier) },
+    { no: 2, name: "profile", kind: "enum", T: proto3.getEnumType(AmdMA35DAv1_AmdMA35DAv1Profile) },
+    { no: 3, name: "level", kind: "message", T: OptionalInt },
+    { no: 4, name: "common", kind: "message", T: AmdMA35DEncodeCommon },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AmdMA35DAv1 {
+    return new AmdMA35DAv1().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AmdMA35DAv1 {
+    return new AmdMA35DAv1().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AmdMA35DAv1 {
+    return new AmdMA35DAv1().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AmdMA35DAv1 | PlainMessage<AmdMA35DAv1> | undefined, b: AmdMA35DAv1 | PlainMessage<AmdMA35DAv1> | undefined): boolean {
+    return proto3.util.equals(AmdMA35DAv1, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.AmdMA35DAv1.AmdMA35DAv1Profile
+ */
+export enum AmdMA35DAv1_AmdMA35DAv1Profile {
+  /**
+   * @generated from enum value: AMD_MA35D_AV1_PROFILE_MAIN = 0;
+   */
+  AMD_MA35D_AV1_PROFILE_MAIN = 0,
+}
+// Retrieve enum metadata with: proto3.getEnumType(AmdMA35DAv1_AmdMA35DAv1Profile)
+proto3.util.setEnumType(AmdMA35DAv1_AmdMA35DAv1Profile, "norsk.api.media.AmdMA35DAv1.AmdMA35DAv1Profile", [
+  { no: 0, name: "AMD_MA35D_AV1_PROFILE_MAIN" },
+]);
+
+/**
+ * @generated from enum norsk.api.media.AmdMA35DAv1.AmdMA35DAv1Tier
+ */
+export enum AmdMA35DAv1_AmdMA35DAv1Tier {
+  /**
+   * @generated from enum value: AMD_MA35D_AV1_TIER_MAIN = 0;
+   */
+  AMD_MA35D_AV1_TIER_MAIN = 0,
+
+  /**
+   * @generated from enum value: AMD_MA35D_AV1_TIER_HIGH = 1;
+   */
+  AMD_MA35D_AV1_TIER_HIGH = 1,
+}
+// Retrieve enum metadata with: proto3.getEnumType(AmdMA35DAv1_AmdMA35DAv1Tier)
+proto3.util.setEnumType(AmdMA35DAv1_AmdMA35DAv1Tier, "norsk.api.media.AmdMA35DAv1.AmdMA35DAv1Tier", [
+  { no: 0, name: "AMD_MA35D_AV1_TIER_MAIN" },
+  { no: 1, name: "AMD_MA35D_AV1_TIER_HIGH" },
+]);
+
 /**
  * @generated from message norsk.api.media.NoDeinterlace
  */
@@ -21724,6 +22903,13 @@ export class StreamSwitchSmoothSwitch extends Message<StreamSwitchSmoothSwitch>
    */
   newActiveSource?: InputPin;
 
+  /**
+   * Optionally the duration of the transition (otherwise the configured default transition duration is used)
+   *
+   * @generated from field: norsk.api.common.OptionalFloat transition_duration_ms = 2;
+   */
+  transitionDurationMs?: OptionalFloat;
+
   constructor(data?: PartialMessage<StreamSwitchSmoothSwitch>) {
     super();
     proto3.util.initPartial(data, this);
@@ -21733,6 +22919,7 @@ export class StreamSwitchSmoothSwitch extends Message<StreamSwitchSmoothSwitch>
   static readonly typeName = "norsk.api.media.StreamSwitchSmoothSwitch";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "new_active_source", kind: "message", T: InputPin },
+    { no: 2, name: "transition_duration_ms", kind: "message", T: OptionalFloat },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchSmoothSwitch {
@@ -27022,6 +28209,28 @@ export class StartMediaStoreCut extends Message<StartMediaStoreCut> {
    */
   fastStart = false;
 
+  /**
+   * @generated from oneof norsk.api.media.StartMediaStoreCut.partial_encode_settings
+   */
+  partialEncodeSettings: {
+    /**
+     * @generated from field: norsk.api.media.X264Codec x264_params = 7;
+     */
+    value: X264Codec;
+    case: "x264Params";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.X265Codec x265_params = 8;
+     */
+    value: X265Codec;
+    case: "x265Params";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  /**
+   * @generated from field: norsk.api.media.StartMediaStoreCut.SequenceHeaderHandling sequence_header_handling = 9;
+   */
+  sequenceHeaderHandling = StartMediaStoreCut_SequenceHeaderHandling.SINGLE_HEADER;
+
   constructor(data?: PartialMessage<StartMediaStoreCut>) {
     super();
     proto3.util.initPartial(data, this);
@@ -27036,6 +28245,9 @@ export class StartMediaStoreCut extends Message<StartMediaStoreCut> {
     { no: 4, name: "file_format", kind: "enum", T: proto3.getEnumType(StartMediaStoreCut_FileFormat) },
     { no: 5, name: "language_mapping", kind: "message", T: LanguageMapping, repeated: true },
     { no: 6, name: "fast_start", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 7, name: "x264_params", kind: "message", T: X264Codec, oneof: "partial_encode_settings" },
+    { no: 8, name: "x265_params", kind: "message", T: X265Codec, oneof: "partial_encode_settings" },
+    { no: 9, name: "sequence_header_handling", kind: "enum", T: proto3.getEnumType(StartMediaStoreCut_SequenceHeaderHandling) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StartMediaStoreCut {
@@ -27069,6 +28281,26 @@ proto3.util.setEnumType(StartMediaStoreCut_FileFormat, "norsk.api.media.StartMed
   { no: 0, name: "CUT_MP4" },
 ]);
 
+/**
+ * @generated from enum norsk.api.media.StartMediaStoreCut.SequenceHeaderHandling
+ */
+export enum StartMediaStoreCut_SequenceHeaderHandling {
+  /**
+   * @generated from enum value: SINGLE_HEADER = 0;
+   */
+  SINGLE_HEADER = 0,
+
+  /**
+   * @generated from enum value: MULTIPLE_HEADERS = 1;
+   */
+  MULTIPLE_HEADERS = 1,
+}
+// Retrieve enum metadata with: proto3.getEnumType(StartMediaStoreCut_SequenceHeaderHandling)
+proto3.util.setEnumType(StartMediaStoreCut_SequenceHeaderHandling, "norsk.api.media.StartMediaStoreCut.SequenceHeaderHandling", [
+  { no: 0, name: "SINGLE_HEADER" },
+  { no: 1, name: "MULTIPLE_HEADERS" },
+]);
+
 /**
  * @generated from message norsk.api.media.CancelMediaStoreCut
  */