@norskvideo/norsk-api 1.0.357 → 1.0.359

package/lib/media_pb.ts

@@ -1739,14 +1739,14 @@ export class Resolution extends Message<Resolution> {
  */
 export class Interval extends Message<Interval> {
   /**
-   * @generated from field: uint32 n = 1;
+   * @generated from field: uint64 n = 1;
    */
-  n = 0;
+  n = protoInt64.zero;
 
   /**
-   * @generated from field: uint32 d = 2;
+   * @generated from field: uint64 d = 2;
    */
-  d = 0;
+  d = protoInt64.zero;
 
   constructor(data?: PartialMessage<Interval>) {
     super();
@@ -1756,8 +1756,8 @@ export class Interval extends Message<Interval> {
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.media.Interval";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "n", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-    { no: 2, name: "d", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 1, name: "n", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+    { no: 2, name: "d", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Interval {
@@ -2852,6 +2852,11 @@ export enum ValidationResponse_ContextValidationResponse {
    * @generated from enum value: CONTEXT_VALIDATION_DENY_AND_QUEUE = 3;
    */
   CONTEXT_VALIDATION_DENY_AND_QUEUE = 3,
+
+  /**
+   * @generated from enum value: CONTEXT_VALIDATION_DENY_AND_DROP = 4;
+   */
+  CONTEXT_VALIDATION_DENY_AND_DROP = 4,
 }
 // Retrieve enum metadata with: proto3.getEnumType(ValidationResponse_ContextValidationResponse)
 proto3.util.setEnumType(ValidationResponse_ContextValidationResponse, "norsk.api.media.ValidationResponse.ContextValidationResponse", [
@@ -2859,6 +2864,7 @@ proto3.util.setEnumType(ValidationResponse_ContextValidationResponse, "norsk.api
   { no: 1, name: "CONTEXT_VALIDATION_ALLOW" },
   { no: 2, name: "CONTEXT_VALIDATION_ALLOW_AND_TERMINATE" },
   { no: 3, name: "CONTEXT_VALIDATION_DENY_AND_QUEUE" },
+  { no: 4, name: "CONTEXT_VALIDATION_DENY_AND_DROP" },
 ]);
 
 /**
@@ -6409,6 +6415,174 @@ export class DeckLinkInputEvent extends Message<DeckLinkInputEvent> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.DeltacastInputConfiguration
+ */
+export class DeltacastInputConfiguration extends Message<DeltacastInputConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * @generated from field: string source_name = 2;
+   */
+  sourceName = "";
+
+  /**
+   * @generated from field: uint32 device_id = 3;
+   */
+  deviceId = 0;
+
+  /**
+   * @generated from field: uint32 card_index = 4;
+   */
+  cardIndex = 0;
+
+  /**
+   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 5;
+   */
+  statsSampling?: StreamStatisticsSampling;
+
+  constructor(data?: PartialMessage<DeltacastInputConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.DeltacastInputConfiguration";
+  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: "device_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 4, name: "card_index", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 5, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeltacastInputConfiguration {
+    return new DeltacastInputConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeltacastInputConfiguration {
+    return new DeltacastInputConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeltacastInputConfiguration {
+    return new DeltacastInputConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: DeltacastInputConfiguration | PlainMessage<DeltacastInputConfiguration> | undefined, b: DeltacastInputConfiguration | PlainMessage<DeltacastInputConfiguration> | undefined): boolean {
+    return proto3.util.equals(DeltacastInputConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.DeltacastInputMessage
+ */
+export class DeltacastInputMessage extends Message<DeltacastInputMessage> {
+  /**
+   * @generated from oneof norsk.api.media.DeltacastInputMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.DeltacastInputConfiguration initial_config = 1;
+     */
+    value: DeltacastInputConfiguration;
+    case: "initialConfig";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.TimestampNudge nudge = 2;
+     */
+    value: TimestampNudge;
+    case: "nudge";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<DeltacastInputMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.DeltacastInputMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "initial_config", kind: "message", T: DeltacastInputConfiguration, oneof: "message" },
+    { no: 2, name: "nudge", kind: "message", T: TimestampNudge, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeltacastInputMessage {
+    return new DeltacastInputMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeltacastInputMessage {
+    return new DeltacastInputMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeltacastInputMessage {
+    return new DeltacastInputMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: DeltacastInputMessage | PlainMessage<DeltacastInputMessage> | undefined, b: DeltacastInputMessage | PlainMessage<DeltacastInputMessage> | undefined): boolean {
+    return proto3.util.equals(DeltacastInputMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.DeltacastInputEvent
+ */
+export class DeltacastInputEvent extends Message<DeltacastInputEvent> {
+  /**
+   * @generated from oneof norsk.api.media.DeltacastInputEvent.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.MultiStreamStatistics stream_statistics = 3;
+     */
+    value: MultiStreamStatistics;
+    case: "streamStatistics";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<DeltacastInputEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.DeltacastInputEvent";
+  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: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeltacastInputEvent {
+    return new DeltacastInputEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeltacastInputEvent {
+    return new DeltacastInputEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeltacastInputEvent {
+    return new DeltacastInputEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: DeltacastInputEvent | PlainMessage<DeltacastInputEvent> | undefined, b: DeltacastInputEvent | PlainMessage<DeltacastInputEvent> | undefined): boolean {
+    return proto3.util.equals(DeltacastInputEvent, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.FileImageInputConfiguration
  */
@@ -6438,6 +6612,11 @@ export class FileImageInputConfiguration extends Message<FileImageInputConfigura
    */
   statsSampling?: StreamStatisticsSampling;
 
+  /**
+   * @generated from field: norsk.api.media.FileImageInputConfiguration.FileImageHardwareAcceleration hardware_acceleration = 6;
+   */
+  hardwareAcceleration = FileImageInputConfiguration_FileImageHardwareAcceleration.FILEIMAGE_NONE;
+
   constructor(data?: PartialMessage<FileImageInputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -6451,6 +6630,7 @@ export class FileImageInputConfiguration extends Message<FileImageInputConfigura
     { no: 3, name: "file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 4, name: "image_format", kind: "enum", T: proto3.getEnumType(FileImageInputConfiguration_ImageFormat) },
     { no: 5, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 6, name: "hardware_acceleration", kind: "enum", T: proto3.getEnumType(FileImageInputConfiguration_FileImageHardwareAcceleration) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileImageInputConfiguration {
@@ -6470,6 +6650,26 @@ export class FileImageInputConfiguration extends Message<FileImageInputConfigura
   }
 }
 
+/**
+ * @generated from enum norsk.api.media.FileImageInputConfiguration.FileImageHardwareAcceleration
+ */
+export enum FileImageInputConfiguration_FileImageHardwareAcceleration {
+  /**
+   * @generated from enum value: FILEIMAGE_NONE = 0;
+   */
+  FILEIMAGE_NONE = 0,
+
+  /**
+   * @generated from enum value: FILEIMAGE_QUADRA = 1;
+   */
+  FILEIMAGE_QUADRA = 1,
+}
+// Retrieve enum metadata with: proto3.getEnumType(FileImageInputConfiguration_FileImageHardwareAcceleration)
+proto3.util.setEnumType(FileImageInputConfiguration_FileImageHardwareAcceleration, "norsk.api.media.FileImageInputConfiguration.FileImageHardwareAcceleration", [
+  { no: 0, name: "FILEIMAGE_NONE" },
+  { no: 1, name: "FILEIMAGE_QUADRA" },
+]);
+
 /**
  * @generated from enum norsk.api.media.FileImageInputConfiguration.ImageFormat
  */
@@ -8228,8 +8428,6 @@ export enum Easing_SimpleEasing {
   LINEAR = 0,
 
   /**
-   * EASE = 1;
-   *
    * @generated from enum value: EASE_IN = 2;
    */
   EASE_IN = 2,
@@ -8796,7 +8994,8 @@ export class MetadataCombineConfiguration extends Message<MetadataCombineConfigu
   streamKey?: StreamKey;
 
   /**
-   * Max delta to allow for sync purposes, may vary according to source offsets and message frequency
+   * Max delta to allow for sync purposes, may vary according to source offsets
+   * and message frequency
    *
    * @generated from field: norsk.api.common.OptionalInt max_sync_delta = 3;
    */
@@ -10440,8 +10639,6 @@ export class CMAFDestination extends Message<CMAFDestination> {
    */
   message: {
     /**
-     * GenericPushDestination generic_destination = 1;
-     *
      * @generated from field: norsk.api.media.HlsPushDestination hls_push_destination = 1;
      */
     value: HlsPushDestination;
@@ -10510,8 +10707,6 @@ export class CmafVideoConfiguration extends Message<CmafVideoConfiguration> {
   partDurationSeconds = 0;
 
   /**
-   * float delay_output_ms = 4;
-   *
    * @generated from field: norsk.api.media.Mp4Encryption encryption = 5;
    */
   encryption?: Mp4Encryption;
@@ -10527,7 +10722,7 @@ export class CmafVideoConfiguration extends Message<CmafVideoConfiguration> {
   destinations: CMAFDestination[] = [];
 
   /**
-   * Directives to add to the m3u media playlist
+   * Directives to add to the m3u8 media playlist
    *
    * @generated from field: string m3u_additions = 8;
    */
@@ -10666,8 +10861,6 @@ export class HlsTsVideoConfiguration extends Message<HlsTsVideoConfiguration> {
   segmentDurationSeconds = 0;
 
   /**
-   * float delay_output_ms = 3;
-   *
    * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
    */
   statsSampling?: StreamStatisticsSampling;
@@ -10820,8 +11013,6 @@ export class CmafAudioConfiguration extends Message<CmafAudioConfiguration> {
   partDurationSeconds = 0;
 
   /**
-   * float delay_output_ms = 4;
-   *
    * @generated from field: norsk.api.media.Mp4Encryption encryption = 6;
    */
   encryption?: Mp4Encryption;
@@ -10976,8 +11167,6 @@ export class HlsTsAudioConfiguration extends Message<HlsTsAudioConfiguration> {
   segmentDurationSeconds = 0;
 
   /**
-   * float delay_output_ms = 3;
-   *
    * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
    */
   statsSampling?: StreamStatisticsSampling;
@@ -11125,22 +11314,10 @@ export class CmafWebVttConfiguration extends Message<CmafWebVttConfiguration> {
   segmentDurationSeconds = 0;
 
   /**
-   * float delay_output_ms = 3;
-   *
    * @generated from field: repeated norsk.api.media.CMAFDestination destinations = 5;
    */
   destinations: CMAFDestination[] = [];
 
-  /**
-   * @generated from field: string hls_cache_directory = 6;
-   */
-  hlsCacheDirectory = "";
-
-  /**
-   * @generated from field: norsk.api.media.Interval pts_adjustment = 8;
-   */
-  ptsAdjustment?: Interval;
-
   /**
    * @generated from field: norsk.api.common.OptionalString name = 9;
    */
@@ -11157,8 +11334,6 @@ export class CmafWebVttConfiguration extends Message<CmafWebVttConfiguration> {
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "segment_duration_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 5, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
-    { no: 6, name: "hls_cache_directory", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 8, name: "pts_adjustment", kind: "message", T: Interval },
     { no: 9, name: "name", kind: "message", T: OptionalString },
   ]);
 
@@ -12176,8 +12351,6 @@ export class HlsTsCombinedPushConfiguration extends Message<HlsTsCombinedPushCon
   segmentDurationSeconds = 0;
 
   /**
-   * float delay_output_ms = 4;
-   *
    * @generated from field: string playlist_name = 5;
    */
   playlistName = "";
@@ -12188,7 +12361,7 @@ export class HlsTsCombinedPushConfiguration extends Message<HlsTsCombinedPushCon
   statsSampling?: StreamStatisticsSampling;
 
   /**
-   * Directives to add to the m3u media playlists
+   * Directives to add to the m3u8 media playlists
    *
    * @generated from field: string m3u_additions = 7;
    */
@@ -13366,6 +13539,12 @@ export class WhepOutputEvent extends Message<WhepOutputEvent> {
      */
     value: MultiStreamStatistics;
     case: "streamStatistics";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.WhepOutputEvent.State status = 5;
+     */
+    value: WhepOutputEvent_State;
+    case: "status";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<WhepOutputEvent>) {
@@ -13380,6 +13559,7 @@ export class WhepOutputEvent extends Message<WhepOutputEvent> {
     { 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: 5, name: "status", kind: "enum", T: proto3.getEnumType(WhepOutputEvent_State), oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhepOutputEvent {
@@ -13399,6 +13579,26 @@ export class WhepOutputEvent extends Message<WhepOutputEvent> {
   }
 }
 
+/**
+ * @generated from enum norsk.api.media.WhepOutputEvent.State
+ */
+export enum WhepOutputEvent_State {
+  /**
+   * @generated from enum value: WHEP_OUTPUT_STATUS_UNKNOWN = 0;
+   */
+  WHEP_OUTPUT_STATUS_UNKNOWN = 0,
+
+  /**
+   * @generated from enum value: WHEP_OUTPUT_STATUS_READY = 1;
+   */
+  WHEP_OUTPUT_STATUS_READY = 1,
+}
+// Retrieve enum metadata with: proto3.getEnumType(WhepOutputEvent_State)
+proto3.util.setEnumType(WhepOutputEvent_State, "norsk.api.media.WhepOutputEvent.State", [
+  { no: 0, name: "WHEP_OUTPUT_STATUS_UNKNOWN" },
+  { no: 1, name: "WHEP_OUTPUT_STATUS_READY" },
+]);
+
 /**
  * @generated from message norsk.api.media.RtmpOutputConfiguration
  */
@@ -14115,127 +14315,277 @@ export class FileMp4OutputEvent extends Message<FileMp4OutputEvent> {
 }
 
 /**
- * @generated from message norsk.api.media.FrameRate
+ * @generated from message norsk.api.media.FileWebVttOutputConfiguration
  */
-export class FrameRate extends Message<FrameRate> {
+export class FileWebVttOutputConfiguration extends Message<FileWebVttOutputConfiguration> {
   /**
-   * @generated from field: uint32 frames = 1;
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
    */
-  frames = 0;
+  id?: MediaNodeId;
 
   /**
-   * @generated from field: uint32 seconds = 2;
+   * @generated from field: string file_name = 2;
    */
-  seconds = 0;
+  fileName = "";
 
-  constructor(data?: PartialMessage<FrameRate>) {
+  constructor(data?: PartialMessage<FileWebVttOutputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameRate";
+  static readonly typeName = "norsk.api.media.FileWebVttOutputConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "frames", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-    { no: 2, name: "seconds", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { 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>): FrameRate {
-    return new FrameRate().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileWebVttOutputConfiguration {
+    return new FileWebVttOutputConfiguration().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameRate {
-    return new FrameRate().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileWebVttOutputConfiguration {
+    return new FileWebVttOutputConfiguration().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameRate {
-    return new FrameRate().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileWebVttOutputConfiguration {
+    return new FileWebVttOutputConfiguration().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameRate | PlainMessage<FrameRate> | undefined, b: FrameRate | PlainMessage<FrameRate> | undefined): boolean {
-    return proto3.util.equals(FrameRate, a, b);
+  static equals(a: FileWebVttOutputConfiguration | PlainMessage<FileWebVttOutputConfiguration> | undefined, b: FileWebVttOutputConfiguration | PlainMessage<FileWebVttOutputConfiguration> | undefined): boolean {
+    return proto3.util.equals(FileWebVttOutputConfiguration, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.SampleAspectRatio
+ * @generated from message norsk.api.media.FileWebVttOutputMessage
  */
-export class SampleAspectRatio extends Message<SampleAspectRatio> {
-  /**
-   * @generated from field: uint32 x = 1;
-   */
-  x = 0;
-
+export class FileWebVttOutputMessage extends Message<FileWebVttOutputMessage> {
   /**
-   * @generated from field: uint32 y = 2;
+   * @generated from oneof norsk.api.media.FileWebVttOutputMessage.message
    */
-  y = 0;
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Subscription subscription = 1;
+     */
+    value: Subscription;
+    case: "subscription";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.FileWebVttOutputConfiguration configuration = 2;
+     */
+    value: FileWebVttOutputConfiguration;
+    case: "configuration";
+  } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<SampleAspectRatio>) {
+  constructor(data?: PartialMessage<FileWebVttOutputMessage>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.SampleAspectRatio";
+  static readonly typeName = "norsk.api.media.FileWebVttOutputMessage";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "x", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-    { no: 2, name: "y", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+    { no: 2, name: "configuration", kind: "message", T: FileWebVttOutputConfiguration, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SampleAspectRatio {
-    return new SampleAspectRatio().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileWebVttOutputMessage {
+    return new FileWebVttOutputMessage().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SampleAspectRatio {
-    return new SampleAspectRatio().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileWebVttOutputMessage {
+    return new FileWebVttOutputMessage().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SampleAspectRatio {
-    return new SampleAspectRatio().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileWebVttOutputMessage {
+    return new FileWebVttOutputMessage().fromJsonString(jsonString, options);
   }
 
-  static equals(a: SampleAspectRatio | PlainMessage<SampleAspectRatio> | undefined, b: SampleAspectRatio | PlainMessage<SampleAspectRatio> | undefined): boolean {
-    return proto3.util.equals(SampleAspectRatio, a, b);
+  static equals(a: FileWebVttOutputMessage | PlainMessage<FileWebVttOutputMessage> | undefined, b: FileWebVttOutputMessage | PlainMessage<FileWebVttOutputMessage> | undefined): boolean {
+    return proto3.util.equals(FileWebVttOutputMessage, a, b);
   }
 }
 
 /**
- * Parameters for tuning the x264 encoder
- *
- * @generated from message norsk.api.media.X264Codec
+ * @generated from message norsk.api.media.FileWebVttOutputEvent
  */
-export class X264Codec extends Message<X264Codec> {
-  /**
-   * @generated from field: norsk.api.common.OptionalInt threads = 23;
-   */
-  threads?: OptionalInt;
-
+export class FileWebVttOutputEvent extends Message<FileWebVttOutputEvent> {
   /**
-   * Rate control options - one of abr, cqp or crf
-   *
-   * @generated from oneof norsk.api.media.X264Codec.bitrateMode
+   * @generated from oneof norsk.api.media.FileWebVttOutputEvent.message
    */
-  bitrateMode: {
+  message: {
     /**
-     * Encode in average bitrate mode, specified in kilobits/sec (note, 1
-     * kilobit is 1000 bits).  You can make use of the vbv settings to control
-     * the bounds on how much the actual bitrate can fluctuate within the bounds
-     * of the average.recommeb
-     *
-     * @generated from field: uint32 abr = 20;
+     * @generated from field: norsk.api.media.MediaNodeId node_id = 1;
      */
-    value: number;
-    case: "abr";
+    value: MediaNodeId;
+    case: "nodeId";
   } | {
     /**
-     * Encode in constant quantizer mode.  In general, crf will give better
-     * results, although cqp can be faster to encode
-     *
-     * @generated from field: uint32 cqp = 21;
+     * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 2;
      */
-    value: number;
-    case: "cqp";
+    value: SubscriptionResponse;
+    case: "subscriptionResponse";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context inbound_context = 3;
+     */
+    value: Context;
+    case: "inboundContext";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<FileWebVttOutputEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FileWebVttOutputEvent";
+  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" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileWebVttOutputEvent {
+    return new FileWebVttOutputEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileWebVttOutputEvent {
+    return new FileWebVttOutputEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileWebVttOutputEvent {
+    return new FileWebVttOutputEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FileWebVttOutputEvent | PlainMessage<FileWebVttOutputEvent> | undefined, b: FileWebVttOutputEvent | PlainMessage<FileWebVttOutputEvent> | undefined): boolean {
+    return proto3.util.equals(FileWebVttOutputEvent, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.FrameRate
+ */
+export class FrameRate extends Message<FrameRate> {
+  /**
+   * @generated from field: uint32 frames = 1;
+   */
+  frames = 0;
+
+  /**
+   * @generated from field: uint32 seconds = 2;
+   */
+  seconds = 0;
+
+  constructor(data?: PartialMessage<FrameRate>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FrameRate";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "frames", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "seconds", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameRate {
+    return new FrameRate().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameRate {
+    return new FrameRate().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameRate {
+    return new FrameRate().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FrameRate | PlainMessage<FrameRate> | undefined, b: FrameRate | PlainMessage<FrameRate> | undefined): boolean {
+    return proto3.util.equals(FrameRate, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SampleAspectRatio
+ */
+export class SampleAspectRatio extends Message<SampleAspectRatio> {
+  /**
+   * @generated from field: uint32 x = 1;
+   */
+  x = 0;
+
+  /**
+   * @generated from field: uint32 y = 2;
+   */
+  y = 0;
+
+  constructor(data?: PartialMessage<SampleAspectRatio>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SampleAspectRatio";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "x", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "y", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SampleAspectRatio {
+    return new SampleAspectRatio().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SampleAspectRatio {
+    return new SampleAspectRatio().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SampleAspectRatio {
+    return new SampleAspectRatio().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SampleAspectRatio | PlainMessage<SampleAspectRatio> | undefined, b: SampleAspectRatio | PlainMessage<SampleAspectRatio> | undefined): boolean {
+    return proto3.util.equals(SampleAspectRatio, a, b);
+  }
+}
+
+/**
+ * Parameters for tuning the x264 encoder
+ *
+ * @generated from message norsk.api.media.X264Codec
+ */
+export class X264Codec extends Message<X264Codec> {
+  /**
+   * @generated from field: norsk.api.common.OptionalInt threads = 23;
+   */
+  threads?: OptionalInt;
+
+  /**
+   * Rate control options - one of abr, cqp or crf
+   *
+   * @generated from oneof norsk.api.media.X264Codec.bitrateMode
+   */
+  bitrateMode: {
+    /**
+     * Encode in average bitrate mode, specified in kilobits/sec (note, 1
+     * kilobit is 1000 bits).  You can make use of the vbv settings to control
+     * the bounds on how much the actual bitrate can fluctuate within the bounds
+     * of the average.recommeb
+     *
+     * @generated from field: uint32 abr = 20;
+     */
+    value: number;
+    case: "abr";
+  } | {
+    /**
+     * Encode in constant quantizer mode.  In general, crf will give better
+     * results, although cqp can be faster to encode
+     *
+     * @generated from field: uint32 cqp = 21;
+     */
+    value: number;
+    case: "cqp";
   } | {
     /**
      * Encode in constant rate factor mode.  This will give a constant 'quality'
@@ -14323,7 +14673,8 @@ export class X264Codec extends Message<X264Codec> {
   cabac?: OptionalBool;
 
   /**
-   * Sets the maximum rate the VBV buffer should be assumed to refill at (kbit/s)
+   * Sets the maximum rate the VBV buffer should be assumed to refill at
+   * (kbit/s)
    *
    * @generated from field: norsk.api.common.OptionalInt vbv_max_rate = 11;
    */
@@ -14743,7 +15094,8 @@ export class X265Codec extends Message<X265Codec> {
   frameReference?: OptionalInt;
 
   /**
-   * Sets the maximum rate the VBV buffer should be assumed to refill at (kbit/s)
+   * Sets the maximum rate the VBV buffer should be assumed to refill at
+   * (kbit/s)
    *
    * @generated from field: norsk.api.common.OptionalInt vbv_max_rate = 11;
    */
@@ -15551,8 +15903,8 @@ export class NvidiaRateControl extends Message<NvidiaRateControl> {
 
   /**
    * * Enable lookahead or not:
-   * Note: enabling lookahead will introduce scene cuts unless this is specifically disabled
-   * elswhere in the codec settings
+   * Note: enabling lookahead will introduce scene cuts unless this is
+   * specifically disabled elswhere in the codec settings
    *
    *
    * @generated from field: norsk.api.common.OptionalBool enableLookahead = 6;
@@ -16919,6 +17271,98 @@ proto3.util.setEnumType(AmdU30Hevc_AmdU30HevcTier, "norsk.api.media.AmdU30Hevc.A
   { no: 1, name: "AMD_U30_HEVC_TIER_HIGH" },
 ]);
 
+/**
+ * @generated from message norsk.api.media.AmdMA35DLoad
+ */
+export class AmdMA35DLoad extends Message<AmdMA35DLoad> {
+  /**
+   * @generated from field: uint32 device_index = 1;
+   */
+  deviceIndex = 0;
+
+  /**
+   * @generated from field: repeated norsk.api.media.AmdMA35DLoad.ComputeUnitLoad compute_unit_load = 2;
+   */
+  computeUnitLoad: AmdMA35DLoad_ComputeUnitLoad[] = [];
+
+  constructor(data?: PartialMessage<AmdMA35DLoad>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AmdMA35DLoad";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "device_index", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "compute_unit_load", kind: "message", T: AmdMA35DLoad_ComputeUnitLoad, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AmdMA35DLoad {
+    return new AmdMA35DLoad().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AmdMA35DLoad {
+    return new AmdMA35DLoad().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AmdMA35DLoad {
+    return new AmdMA35DLoad().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AmdMA35DLoad | PlainMessage<AmdMA35DLoad> | undefined, b: AmdMA35DLoad | PlainMessage<AmdMA35DLoad> | undefined): boolean {
+    return proto3.util.equals(AmdMA35DLoad, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.AmdMA35DLoad.ComputeUnitLoad
+ */
+export class AmdMA35DLoad_ComputeUnitLoad extends Message<AmdMA35DLoad_ComputeUnitLoad> {
+  /**
+   * @generated from field: string name = 1;
+   */
+  name = "";
+
+  /**
+   * @generated from field: uint32 instances = 2;
+   */
+  instances = 0;
+
+  /**
+   * @generated from field: float load = 3;
+   */
+  load = 0;
+
+  constructor(data?: PartialMessage<AmdMA35DLoad_ComputeUnitLoad>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AmdMA35DLoad.ComputeUnitLoad";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "instances", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 3, name: "load", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AmdMA35DLoad_ComputeUnitLoad {
+    return new AmdMA35DLoad_ComputeUnitLoad().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AmdMA35DLoad_ComputeUnitLoad {
+    return new AmdMA35DLoad_ComputeUnitLoad().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AmdMA35DLoad_ComputeUnitLoad {
+    return new AmdMA35DLoad_ComputeUnitLoad().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AmdMA35DLoad_ComputeUnitLoad | PlainMessage<AmdMA35DLoad_ComputeUnitLoad> | undefined, b: AmdMA35DLoad_ComputeUnitLoad | PlainMessage<AmdMA35DLoad_ComputeUnitLoad> | undefined): boolean {
+    return proto3.util.equals(AmdMA35DLoad_ComputeUnitLoad, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.AmdMA35DEncodeCommon
  */
@@ -16952,10 +17396,10 @@ export class AmdMA35DEncodeCommon extends Message<AmdMA35DEncodeCommon> {
     case: "constrainedVbr";
   } | {
     /**
-     * @generated from field: norsk.api.media.AmdMA35DEncodeCommon.ConstrainedABR constrained_abr = 5;
+     * @generated from field: norsk.api.media.AmdMA35DEncodeCommon.ContentAdaptive content_adaptive = 5;
      */
-    value: AmdMA35DEncodeCommon_ConstrainedABR;
-    case: "constrainedAbr";
+    value: AmdMA35DEncodeCommon_ContentAdaptive;
+    case: "contentAdaptive";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   /**
@@ -17055,7 +17499,7 @@ export class AmdMA35DEncodeCommon extends Message<AmdMA35DEncodeCommon> {
     { no: 2, name: "cbr", kind: "message", T: AmdMA35DEncodeCommon_CBR, oneof: "rateControl" },
     { no: 3, name: "vbr", kind: "message", T: AmdMA35DEncodeCommon_VBR, oneof: "rateControl" },
     { no: 4, name: "constrained_vbr", kind: "message", T: AmdMA35DEncodeCommon_ConstrainedVBR, oneof: "rateControl" },
-    { no: 5, name: "constrained_abr", kind: "message", T: AmdMA35DEncodeCommon_ConstrainedABR, oneof: "rateControl" },
+    { no: 5, name: "content_adaptive", kind: "message", T: AmdMA35DEncodeCommon_ContentAdaptive, oneof: "rateControl" },
     { no: 6, name: "lookahead_depth", kind: "message", T: OptionalInt },
     { no: 7, name: "gopSize", kind: "message", T: OptionalInt },
     { no: 8, name: "tempAqGain", kind: "message", T: OptionalInt },
@@ -17375,9 +17819,9 @@ export class AmdMA35DEncodeCommon_ConstrainedVBR extends Message<AmdMA35DEncodeC
 }
 
 /**
- * @generated from message norsk.api.media.AmdMA35DEncodeCommon.ConstrainedABR
+ * @generated from message norsk.api.media.AmdMA35DEncodeCommon.ContentAdaptive
  */
-export class AmdMA35DEncodeCommon_ConstrainedABR extends Message<AmdMA35DEncodeCommon_ConstrainedABR> {
+export class AmdMA35DEncodeCommon_ContentAdaptive extends Message<AmdMA35DEncodeCommon_ContentAdaptive> {
   /**
    * @generated from field: uint32 bitrate = 1;
    */
@@ -17393,33 +17837,33 @@ export class AmdMA35DEncodeCommon_ConstrainedABR extends Message<AmdMA35DEncodeC
    */
   bufSize = 0;
 
-  constructor(data?: PartialMessage<AmdMA35DEncodeCommon_ConstrainedABR>) {
+  constructor(data?: PartialMessage<AmdMA35DEncodeCommon_ContentAdaptive>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.AmdMA35DEncodeCommon.ConstrainedABR";
+  static readonly typeName = "norsk.api.media.AmdMA35DEncodeCommon.ContentAdaptive";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "bitrate", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
     { no: 2, name: "max_bitrate", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
     { no: 3, name: "buf_size", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AmdMA35DEncodeCommon_ConstrainedABR {
-    return new AmdMA35DEncodeCommon_ConstrainedABR().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AmdMA35DEncodeCommon_ContentAdaptive {
+    return new AmdMA35DEncodeCommon_ContentAdaptive().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AmdMA35DEncodeCommon_ConstrainedABR {
-    return new AmdMA35DEncodeCommon_ConstrainedABR().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AmdMA35DEncodeCommon_ContentAdaptive {
+    return new AmdMA35DEncodeCommon_ContentAdaptive().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AmdMA35DEncodeCommon_ConstrainedABR {
-    return new AmdMA35DEncodeCommon_ConstrainedABR().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AmdMA35DEncodeCommon_ContentAdaptive {
+    return new AmdMA35DEncodeCommon_ContentAdaptive().fromJsonString(jsonString, options);
   }
 
-  static equals(a: AmdMA35DEncodeCommon_ConstrainedABR | PlainMessage<AmdMA35DEncodeCommon_ConstrainedABR> | undefined, b: AmdMA35DEncodeCommon_ConstrainedABR | PlainMessage<AmdMA35DEncodeCommon_ConstrainedABR> | undefined): boolean {
-    return proto3.util.equals(AmdMA35DEncodeCommon_ConstrainedABR, a, b);
+  static equals(a: AmdMA35DEncodeCommon_ContentAdaptive | PlainMessage<AmdMA35DEncodeCommon_ContentAdaptive> | undefined, b: AmdMA35DEncodeCommon_ContentAdaptive | PlainMessage<AmdMA35DEncodeCommon_ContentAdaptive> | undefined): boolean {
+    return proto3.util.equals(AmdMA35DEncodeCommon_ContentAdaptive, a, b);
   }
 }
 
@@ -18451,7 +18895,8 @@ export class StreamMetadataOverrideConfiguration extends Message<StreamMetadataO
   subtitlesLanguage?: OptionalString;
 
   /**
-   * * Override the property of whether a subtitles string is the default/primary rendition or not 
+   * * Override the property of whether a subtitles string is the default/primary
+   * rendition or not 
    *
    * @generated from field: norsk.api.common.OptionalBool subtitles_default = 6;
    */
@@ -18535,7 +18980,8 @@ export class StreamMetadataOverrideUpdateConfiguration extends Message<StreamMet
   subtitlesLanguage?: OptionalString;
 
   /**
-   * * Override the property of whether a subtitles string is the default/primary rendition or not 
+   * * Override the property of whether a subtitles string is the default/primary
+   * rendition or not 
    *
    * @generated from field: norsk.api.common.OptionalBool subtitles_default = 6;
    */
@@ -19034,7 +19480,8 @@ export class StreamAlignConfiguration extends Message<StreamAlignConfiguration>
   frameRate?: FrameRate;
 
   /**
-   * Synchronise audio/video sources aggressively to start at the same timestamp by dropping frames until a video keyframe occurs
+   * Synchronise audio/video sources aggressively to start at the same timestamp
+   * by dropping frames until a video keyframe occurs
    *
    * @generated from field: bool sync_av = 4;
    */
@@ -19510,6 +19957,357 @@ export class AudioEncodeEvent extends Message<AudioEncodeEvent> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.WebVttEncodeConfiguration
+ */
+export class WebVttEncodeConfiguration extends Message<WebVttEncodeConfiguration> {
+  /**
+   * Maximum length of any line in the cue in characters
+   *
+   * @generated from field: norsk.api.common.OptionalInt maximum_line_length = 1;
+   */
+  maximumLineLength?: OptionalInt;
+
+  /**
+   * Minimum length of the overall cue in characters
+   *
+   * @generated from field: norsk.api.common.OptionalInt minimum_cue_length = 2;
+   */
+  minimumCueLength?: OptionalInt;
+
+  /**
+   * Maximum number of lines in a cue. 
+   *
+   * Consider using a value of 1 and a longer max line length and allowing the player to break lines: per the WebVTT standard
+   * "In general, therefore, authors are encouraged to write cues all on one line except when a line break is definitely necessary."
+   * However if the player does not do this adequately, using the actual max line length desired and more lines, hard line breaks 
+   * will be inserted. Note a maximum subtitle length of two lines is recommended (eg BBC guidance)
+   *
+   * @generated from field: norsk.api.common.OptionalInt maximum_num_lines = 3;
+   */
+  maximumNumLines?: OptionalInt;
+
+  constructor(data?: PartialMessage<WebVttEncodeConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.WebVttEncodeConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "maximum_line_length", kind: "message", T: OptionalInt },
+    { no: 2, name: "minimum_cue_length", kind: "message", T: OptionalInt },
+    { no: 3, name: "maximum_num_lines", kind: "message", T: OptionalInt },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebVttEncodeConfiguration {
+    return new WebVttEncodeConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebVttEncodeConfiguration {
+    return new WebVttEncodeConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebVttEncodeConfiguration {
+    return new WebVttEncodeConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: WebVttEncodeConfiguration | PlainMessage<WebVttEncodeConfiguration> | undefined, b: WebVttEncodeConfiguration | PlainMessage<WebVttEncodeConfiguration> | undefined): boolean {
+    return proto3.util.equals(WebVttEncodeConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Cta608EncodeConfiguration
+ */
+export class Cta608EncodeConfiguration extends Message<Cta608EncodeConfiguration> {
+  /**
+   * Caption style (default: selected according to source)
+   *
+   * @generated from field: norsk.api.media.Cta608EncodeConfiguration.Cta608EncodeStyle style = 1;
+   */
+  style = Cta608EncodeConfiguration_Cta608EncodeStyle.CTA_608_STYLE_DEFAULT;
+
+  /**
+   * The total/maximum number of lines to use for captioning
+   *
+   * @generated from field: norsk.api.common.OptionalInt lines = 2;
+   */
+  lines?: OptionalInt;
+
+  constructor(data?: PartialMessage<Cta608EncodeConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Cta608EncodeConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "style", kind: "enum", T: proto3.getEnumType(Cta608EncodeConfiguration_Cta608EncodeStyle) },
+    { no: 2, name: "lines", kind: "message", T: OptionalInt },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Cta608EncodeConfiguration {
+    return new Cta608EncodeConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Cta608EncodeConfiguration {
+    return new Cta608EncodeConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Cta608EncodeConfiguration {
+    return new Cta608EncodeConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Cta608EncodeConfiguration | PlainMessage<Cta608EncodeConfiguration> | undefined, b: Cta608EncodeConfiguration | PlainMessage<Cta608EncodeConfiguration> | undefined): boolean {
+    return proto3.util.equals(Cta608EncodeConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.Cta608EncodeConfiguration.Cta608EncodeStyle
+ */
+export enum Cta608EncodeConfiguration_Cta608EncodeStyle {
+  /**
+   * @generated from enum value: CTA_608_STYLE_DEFAULT = 0;
+   */
+  CTA_608_STYLE_DEFAULT = 0,
+
+  /**
+   * @generated from enum value: CTA_608_STYLE_ROLL_UP = 1;
+   */
+  CTA_608_STYLE_ROLL_UP = 1,
+
+  /**
+   * @generated from enum value: CTA_608_STYLE_POP_ON = 2;
+   */
+  CTA_608_STYLE_POP_ON = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(Cta608EncodeConfiguration_Cta608EncodeStyle)
+proto3.util.setEnumType(Cta608EncodeConfiguration_Cta608EncodeStyle, "norsk.api.media.Cta608EncodeConfiguration.Cta608EncodeStyle", [
+  { no: 0, name: "CTA_608_STYLE_DEFAULT" },
+  { no: 1, name: "CTA_608_STYLE_ROLL_UP" },
+  { no: 2, name: "CTA_608_STYLE_POP_ON" },
+]);
+
+/**
+ * @generated from message norsk.api.media.Cta708EncodeConfiguration
+ */
+export class Cta708EncodeConfiguration extends Message<Cta708EncodeConfiguration> {
+  constructor(data?: PartialMessage<Cta708EncodeConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Cta708EncodeConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Cta708EncodeConfiguration {
+    return new Cta708EncodeConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Cta708EncodeConfiguration {
+    return new Cta708EncodeConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Cta708EncodeConfiguration {
+    return new Cta708EncodeConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Cta708EncodeConfiguration | PlainMessage<Cta708EncodeConfiguration> | undefined, b: Cta708EncodeConfiguration | PlainMessage<Cta708EncodeConfiguration> | undefined): boolean {
+    return proto3.util.equals(Cta708EncodeConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SubtitleConvertConfiguration
+ */
+export class SubtitleConvertConfiguration extends Message<SubtitleConvertConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * @generated from oneof norsk.api.media.SubtitleConvertConfiguration.format
+   */
+  format: {
+    /**
+     * @generated from field: norsk.api.media.WebVttEncodeConfiguration webvtt = 2;
+     */
+    value: WebVttEncodeConfiguration;
+    case: "webvtt";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Cta608EncodeConfiguration cta608 = 3;
+     */
+    value: Cta608EncodeConfiguration;
+    case: "cta608";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Cta708EncodeConfiguration cta708 = 4;
+     */
+    value: Cta708EncodeConfiguration;
+    case: "cta708";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  /**
+   * For conversion from transcribed sources containing partial and complete transcriptions, filter to only include the transcription
+   * from a fully transcribed section/utterance. Note this may be multiple sentences and span up to 30s duration or beyond, making this
+   * generally an option for non-live flows
+   *
+   * @generated from field: bool only_complete = 5;
+   */
+  onlyComplete = false;
+
+  constructor(data?: PartialMessage<SubtitleConvertConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SubtitleConvertConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "webvtt", kind: "message", T: WebVttEncodeConfiguration, oneof: "format" },
+    { no: 3, name: "cta608", kind: "message", T: Cta608EncodeConfiguration, oneof: "format" },
+    { no: 4, name: "cta708", kind: "message", T: Cta708EncodeConfiguration, oneof: "format" },
+    { no: 5, name: "only_complete", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubtitleConvertConfiguration {
+    return new SubtitleConvertConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubtitleConvertConfiguration {
+    return new SubtitleConvertConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubtitleConvertConfiguration {
+    return new SubtitleConvertConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SubtitleConvertConfiguration | PlainMessage<SubtitleConvertConfiguration> | undefined, b: SubtitleConvertConfiguration | PlainMessage<SubtitleConvertConfiguration> | undefined): boolean {
+    return proto3.util.equals(SubtitleConvertConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SubtitleConvertMessage
+ */
+export class SubtitleConvertMessage extends Message<SubtitleConvertMessage> {
+  /**
+   * @generated from oneof norsk.api.media.SubtitleConvertMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Subscription subscription = 1;
+     */
+    value: Subscription;
+    case: "subscription";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.SubtitleConvertConfiguration configuration = 2;
+     */
+    value: SubtitleConvertConfiguration;
+    case: "configuration";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<SubtitleConvertMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SubtitleConvertMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+    { no: 2, name: "configuration", kind: "message", T: SubtitleConvertConfiguration, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubtitleConvertMessage {
+    return new SubtitleConvertMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubtitleConvertMessage {
+    return new SubtitleConvertMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubtitleConvertMessage {
+    return new SubtitleConvertMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SubtitleConvertMessage | PlainMessage<SubtitleConvertMessage> | undefined, b: SubtitleConvertMessage | PlainMessage<SubtitleConvertMessage> | undefined): boolean {
+    return proto3.util.equals(SubtitleConvertMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SubtitleConvertEvent
+ */
+export class SubtitleConvertEvent extends Message<SubtitleConvertEvent> {
+  /**
+   * @generated from oneof norsk.api.media.SubtitleConvertEvent.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.SubscriptionResponse subscription_response = 3;
+     */
+    value: SubscriptionResponse;
+    case: "subscriptionResponse";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context inbound_context = 4;
+     */
+    value: Context;
+    case: "inboundContext";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<SubtitleConvertEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SubtitleConvertEvent";
+  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: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
+    { no: 4, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubtitleConvertEvent {
+    return new SubtitleConvertEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubtitleConvertEvent {
+    return new SubtitleConvertEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubtitleConvertEvent {
+    return new SubtitleConvertEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SubtitleConvertEvent | PlainMessage<SubtitleConvertEvent> | undefined, b: SubtitleConvertEvent | PlainMessage<SubtitleConvertEvent> | undefined): boolean {
+    return proto3.util.equals(SubtitleConvertEvent, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.StreamSwitchSmoothConfiguration
  */
@@ -21639,9 +22437,18 @@ export class AudioTranscribeAzureConfiguration extends Message<AudioTranscribeAz
   azureRegion = "";
 
   /**
-   * @generated from field: norsk.api.common.OptionalInt maximum_line_length = 7;
+   * * Enable dictation mode (recognise dictated punctuation etc rather than transcribing the audio verbatim)  
+   *
+   * @generated from field: norsk.api.common.OptionalBool dictation = 8;
    */
-  maximumLineLength?: OptionalInt;
+  dictation?: OptionalBool;
+
+  /**
+   * * Profanity behaviour (whether to mask or remove profanity) 
+   *
+   * @generated from field: norsk.api.media.AudioTranscribeAzureConfiguration.ProfanityOption profanity = 9;
+   */
+  profanity = AudioTranscribeAzureConfiguration_ProfanityOption.AZURE_PROFANITY_DEFAULT;
 
   constructor(data?: PartialMessage<AudioTranscribeAzureConfiguration>) {
     super();
@@ -21657,7 +22464,8 @@ export class AudioTranscribeAzureConfiguration extends Message<AudioTranscribeAz
     { no: 4, name: "target_languages", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
     { no: 5, name: "azure_key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 6, name: "azure_region", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 7, name: "maximum_line_length", kind: "message", T: OptionalInt },
+    { no: 8, name: "dictation", kind: "message", T: OptionalBool },
+    { no: 9, name: "profanity", kind: "enum", T: proto3.getEnumType(AudioTranscribeAzureConfiguration_ProfanityOption) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioTranscribeAzureConfiguration {
@@ -21677,6 +22485,38 @@ export class AudioTranscribeAzureConfiguration extends Message<AudioTranscribeAz
   }
 }
 
+/**
+ * @generated from enum norsk.api.media.AudioTranscribeAzureConfiguration.ProfanityOption
+ */
+export enum AudioTranscribeAzureConfiguration_ProfanityOption {
+  /**
+   * @generated from enum value: AZURE_PROFANITY_DEFAULT = 0;
+   */
+  AZURE_PROFANITY_DEFAULT = 0,
+
+  /**
+   * @generated from enum value: AZURE_PROFANITY_MASKED = 1;
+   */
+  AZURE_PROFANITY_MASKED = 1,
+
+  /**
+   * @generated from enum value: AZURE_PROFANITY_REMOVED = 2;
+   */
+  AZURE_PROFANITY_REMOVED = 2,
+
+  /**
+   * @generated from enum value: AZURE_PROFANITY_RAW = 3;
+   */
+  AZURE_PROFANITY_RAW = 3,
+}
+// Retrieve enum metadata with: proto3.getEnumType(AudioTranscribeAzureConfiguration_ProfanityOption)
+proto3.util.setEnumType(AudioTranscribeAzureConfiguration_ProfanityOption, "norsk.api.media.AudioTranscribeAzureConfiguration.ProfanityOption", [
+  { no: 0, name: "AZURE_PROFANITY_DEFAULT" },
+  { no: 1, name: "AZURE_PROFANITY_MASKED" },
+  { no: 2, name: "AZURE_PROFANITY_REMOVED" },
+  { no: 3, name: "AZURE_PROFANITY_RAW" },
+]);
+
 /**
  * @generated from message norsk.api.media.AudioTranscribeAzureMessage
  */
@@ -22082,7 +22922,8 @@ export class SubtitleTranslateAwsConfiguration extends Message<SubtitleTranslate
   id?: MediaNodeId;
 
   /**
-   * / Source language code/tag, e.g. de or fr-CA (leave blank to use the source subtitle language / AWS automatic detection)
+   * / Source language code/tag, e.g. de or fr-CA (leave blank to use the source
+   * / subtitle language / AWS automatic detection)
    *
    * @generated from field: string source_language = 2;
    */
@@ -22313,8 +23154,6 @@ export class AncillaryMessage extends Message<AncillaryMessage> {
     case: "subscription";
   } | {
     /**
-     * Scte104Event scte104_event = 4;
-     *
      * @generated from field: norsk.api.media.Scte35Event scte35_event = 3;
      */
     value: Scte35Event;
@@ -22378,8 +23217,6 @@ export class AncillaryEvent extends Message<AncillaryEvent> {
     case: "subscriptionResponse";
   } | {
     /**
-     * Scte104Event scte104_event = 5;
-     *
      * @generated from field: norsk.api.media.Scte35Event scte35_event = 4;
      */
     value: Scte35Event;
@@ -26110,6 +26947,12 @@ export class NorskStatusEvent extends Message<NorskStatusEvent> {
      */
     value: Log;
     case: "logEvent";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.AmdMA35DLoad ma35d_load = 5;
+     */
+    value: AmdMA35DLoad;
+    case: "ma35dLoad";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<NorskStatusEvent>) {
@@ -26124,6 +26967,7 @@ export class NorskStatusEvent extends Message<NorskStatusEvent> {
     { no: 2, name: "current_load", kind: "message", T: CurrentLoad, oneof: "message" },
     { no: 3, name: "license_event", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "message" },
     { no: 4, name: "log_event", kind: "message", T: Log, oneof: "message" },
+    { no: 5, name: "ma35d_load", kind: "message", T: AmdMA35DLoad, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NorskStatusEvent {