@norskvideo/norsk-api 1.0.357 → 1.0.358

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 {
@@ -8228,8 +8228,6 @@ export enum Easing_SimpleEasing {
   LINEAR = 0,
 
   /**
-   * EASE = 1;
-   *
    * @generated from enum value: EASE_IN = 2;
    */
   EASE_IN = 2,
@@ -8796,7 +8794,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 +10439,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 +10507,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 +10522,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 +10661,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 +10813,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 +10967,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 +11114,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 +11134,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 +12151,6 @@ export class HlsTsCombinedPushConfiguration extends Message<HlsTsCombinedPushCon
   segmentDurationSeconds = 0;
 
   /**
-   * float delay_output_ms = 4;
-   *
    * @generated from field: string playlist_name = 5;
    */
   playlistName = "";
@@ -12188,7 +12161,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;
    */
@@ -14114,6 +14087,156 @@ export class FileMp4OutputEvent extends Message<FileMp4OutputEvent> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.FileWebVttOutputConfiguration
+ */
+export class FileWebVttOutputConfiguration extends Message<FileWebVttOutputConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * @generated from field: string file_name = 2;
+   */
+  fileName = "";
+
+  constructor(data?: PartialMessage<FileWebVttOutputConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FileWebVttOutputConfiguration";
+  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>): FileWebVttOutputConfiguration {
+    return new FileWebVttOutputConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileWebVttOutputConfiguration {
+    return new FileWebVttOutputConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileWebVttOutputConfiguration {
+    return new FileWebVttOutputConfiguration().fromJsonString(jsonString, options);
+  }
+
+  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.FileWebVttOutputMessage
+ */
+export class FileWebVttOutputMessage extends Message<FileWebVttOutputMessage> {
+  /**
+   * @generated from oneof norsk.api.media.FileWebVttOutputMessage.message
+   */
+  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<FileWebVttOutputMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FileWebVttOutputMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { 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>): FileWebVttOutputMessage {
+    return new FileWebVttOutputMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileWebVttOutputMessage {
+    return new FileWebVttOutputMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileWebVttOutputMessage {
+    return new FileWebVttOutputMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FileWebVttOutputMessage | PlainMessage<FileWebVttOutputMessage> | undefined, b: FileWebVttOutputMessage | PlainMessage<FileWebVttOutputMessage> | undefined): boolean {
+    return proto3.util.equals(FileWebVttOutputMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.FileWebVttOutputEvent
+ */
+export class FileWebVttOutputEvent extends Message<FileWebVttOutputEvent> {
+  /**
+   * @generated from oneof norsk.api.media.FileWebVttOutputEvent.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.MediaNodeId node_id = 1;
+     */
+    value: MediaNodeId;
+    case: "nodeId";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 2;
+     */
+    value: SubscriptionResponse;
+    case: "subscriptionResponse";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context inbound_context = 3;
+     */
+    value: Context;
+    case: "inboundContext";
+  } | { 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
  */
@@ -14323,7 +14446,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 +14867,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 +15676,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 +17044,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
  */
@@ -18451,7 +18668,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 +18753,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 +19253,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 +19730,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 +22210,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 +22237,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 +22258,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 +22695,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 +22927,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 +22990,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 +26720,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 +26740,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 {