@norskvideo/norsk-api 1.0.358 → 1.0.360

package/lib/media_pb.ts

@@ -601,6 +601,94 @@ proto3.util.setEnumType(AudioCodec, "norsk.api.media.AudioCodec", [
   { no: 7, name: "AC3" },
 ]);
 
+/**
+ * @generated from enum norsk.api.media.SubtitleFormat
+ */
+export enum SubtitleFormat {
+  /**
+   * @generated from enum value: SUBTITLE_FORMAT_UNKNOWN = 0;
+   */
+  UNKNOWN = 0,
+
+  /**
+   * @generated from enum value: SUBTITLE_FORMAT_TRANSCRIBED = 1;
+   */
+  TRANSCRIBED = 1,
+
+  /**
+   * @generated from enum value: SUBTITLE_FORMAT_TRANSLATED = 2;
+   */
+  TRANSLATED = 2,
+
+  /**
+   * @generated from enum value: SUBTITLE_FORMAT_WEBVTT = 3;
+   */
+  WEBVTT = 3,
+
+  /**
+   * @generated from enum value: SUBTITLE_FORMAT_CTA608 = 4;
+   */
+  CTA608 = 4,
+
+  /**
+   * @generated from enum value: SUBTITLE_FORMAT_CTA708 = 5;
+   */
+  CTA708 = 5,
+
+  /**
+   * @generated from enum value: SUBTITLE_FORMAT_TELETEXT = 6;
+   */
+  TELETEXT = 6,
+
+  /**
+   * @generated from enum value: SUBTITLE_FORMAT_TTML = 7;
+   */
+  TTML = 7,
+}
+// Retrieve enum metadata with: proto3.getEnumType(SubtitleFormat)
+proto3.util.setEnumType(SubtitleFormat, "norsk.api.media.SubtitleFormat", [
+  { no: 0, name: "SUBTITLE_FORMAT_UNKNOWN" },
+  { no: 1, name: "SUBTITLE_FORMAT_TRANSCRIBED" },
+  { no: 2, name: "SUBTITLE_FORMAT_TRANSLATED" },
+  { no: 3, name: "SUBTITLE_FORMAT_WEBVTT" },
+  { no: 4, name: "SUBTITLE_FORMAT_CTA608" },
+  { no: 5, name: "SUBTITLE_FORMAT_CTA708" },
+  { no: 6, name: "SUBTITLE_FORMAT_TELETEXT" },
+  { no: 7, name: "SUBTITLE_FORMAT_TTML" },
+]);
+
+/**
+ * @generated from enum norsk.api.media.AncillaryType
+ */
+export enum AncillaryType {
+  /**
+   * @generated from enum value: ANCILLARY_TYPE_OTHER = 0;
+   */
+  OTHER = 0,
+
+  /**
+   * @generated from enum value: ANCILLARY_TYPE_SCTE35 = 1;
+   */
+  SCTE35 = 1,
+
+  /**
+   * @generated from enum value: ANCILLARY_TYPE_SMTPE2038 = 2;
+   */
+  SMTPE2038 = 2,
+
+  /**
+   * @generated from enum value: ANCILLARY_TYPE_METADATA = 3;
+   */
+  METADATA = 3,
+}
+// Retrieve enum metadata with: proto3.getEnumType(AncillaryType)
+proto3.util.setEnumType(AncillaryType, "norsk.api.media.AncillaryType", [
+  { no: 0, name: "ANCILLARY_TYPE_OTHER" },
+  { no: 1, name: "ANCILLARY_TYPE_SCTE35" },
+  { no: 2, name: "ANCILLARY_TYPE_SMTPE2038" },
+  { no: 3, name: "ANCILLARY_TYPE_METADATA" },
+]);
+
 /**
  * @generated from enum norsk.api.media.SrtMode
  */
@@ -1480,6 +1568,32 @@ proto3.util.setEnumType(SentenceStabilizationMode, "norsk.api.media.SentenceStab
   { no: 2, name: "Low" },
 ]);
 
+/**
+ * @generated from enum norsk.api.media.MetadataKind
+ */
+export enum MetadataKind {
+  /**
+   * @generated from enum value: METADATA_KIND_OTHER = 0;
+   */
+  OTHER = 0,
+
+  /**
+   * @generated from enum value: METADATA_KIND_ID3 = 1;
+   */
+  ID3 = 1,
+
+  /**
+   * @generated from enum value: METADATA_KIND_KLV = 2;
+   */
+  KLV = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(MetadataKind)
+proto3.util.setEnumType(MetadataKind, "norsk.api.media.MetadataKind", [
+  { no: 0, name: "METADATA_KIND_OTHER" },
+  { no: 1, name: "METADATA_KIND_ID3" },
+  { no: 2, name: "METADATA_KIND_KLV" },
+]);
+
 /**
  * @generated from enum norsk.api.media.VancPayloadFormat
  */
@@ -2377,6 +2491,13 @@ export class StreamMetadata_AudioMetadata extends Message<StreamMetadata_AudioMe
    */
   bitrate = 0;
 
+  /**
+   * The audio language (if specified)
+   *
+   * @generated from field: string language = 6;
+   */
+  language = "";
+
   constructor(data?: PartialMessage<StreamMetadata_AudioMetadata>) {
     super();
     proto3.util.initPartial(data, this);
@@ -2389,6 +2510,7 @@ export class StreamMetadata_AudioMetadata extends Message<StreamMetadata_AudioMe
     { no: 3, name: "sample_rate", kind: "enum", T: proto3.getEnumType(SampleRate) },
     { no: 4, name: "channel_layout", kind: "message", T: ChannelLayout },
     { no: 5, name: "bitrate", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 6, name: "language", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadata_AudioMetadata {
@@ -2487,6 +2609,20 @@ export class StreamMetadata_VideoMetadata extends Message<StreamMetadata_VideoMe
  * @generated from message norsk.api.media.StreamMetadata.SubtitleMetadata
  */
 export class StreamMetadata_SubtitleMetadata extends Message<StreamMetadata_SubtitleMetadata> {
+  /**
+   * The subtitle format or source
+   *
+   * @generated from field: norsk.api.media.SubtitleFormat format = 2;
+   */
+  format = SubtitleFormat.UNKNOWN;
+
+  /**
+   * Subtitle language (if specified)
+   *
+   * @generated from field: string language = 3;
+   */
+  language = "";
+
   constructor(data?: PartialMessage<StreamMetadata_SubtitleMetadata>) {
     super();
     proto3.util.initPartial(data, this);
@@ -2495,6 +2631,8 @@ export class StreamMetadata_SubtitleMetadata extends Message<StreamMetadata_Subt
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.media.StreamMetadata.SubtitleMetadata";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 2, name: "format", kind: "enum", T: proto3.getEnumType(SubtitleFormat) },
+    { no: 3, name: "language", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadata_SubtitleMetadata {
@@ -2561,6 +2699,16 @@ export class StreamMetadata_PlaylistMetadata extends Message<StreamMetadata_Play
  * @generated from message norsk.api.media.StreamMetadata.AncillaryMetadata
  */
 export class StreamMetadata_AncillaryMetadata extends Message<StreamMetadata_AncillaryMetadata> {
+  /**
+   * @generated from field: norsk.api.media.AncillaryType type = 2;
+   */
+  type = AncillaryType.OTHER;
+
+  /**
+   * @generated from field: string ancillary_subtype = 3;
+   */
+  ancillarySubtype = "";
+
   constructor(data?: PartialMessage<StreamMetadata_AncillaryMetadata>) {
     super();
     proto3.util.initPartial(data, this);
@@ -2569,6 +2717,8 @@ export class StreamMetadata_AncillaryMetadata extends Message<StreamMetadata_Anc
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.media.StreamMetadata.AncillaryMetadata";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 2, name: "type", kind: "enum", T: proto3.getEnumType(AncillaryType) },
+    { no: 3, name: "ancillary_subtype", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadata_AncillaryMetadata {
@@ -2650,8 +2800,8 @@ export class Context extends Message<Context> {
  * certain nodes that are permitted non-disjoint context keys
  * .
  * Once received, your code **must** acknowledge the context change
- * with a call to `Media.UnblockCall`,
- * passing in the `blockingCallRef`; note that if using the
+ * with a call through a subscription channel `Media.createSubscriptionChannel`,
+ * passing in the `blockingCallRef` to an 'unblock' message; note that if using the
  * JavaScript SDK then this is automatically handled.
  *
  * @generated from message norsk.api.media.MultipleContext
@@ -2852,6 +3002,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 +3014,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 +6565,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 +6762,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 +6780,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 +6800,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
  */
@@ -13339,6 +13689,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>) {
@@ -13353,6 +13709,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 {
@@ -13372,6 +13729,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
  */
@@ -17169,10 +17546,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 };
 
   /**
@@ -17272,7 +17649,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 },
@@ -17592,9 +17969,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;
    */
@@ -17610,33 +17987,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);
   }
 }
 
@@ -20857,6 +21234,12 @@ export class StreamStatisticsEvent extends Message<StreamStatisticsEvent> {
      */
     value: Context;
     case: "inboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.GopStructure gop_structure = 6;
+     */
+    value: GopStructure;
+    case: "gopStructure";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<StreamStatisticsEvent>) {
@@ -20872,6 +21255,7 @@ export class StreamStatisticsEvent extends Message<StreamStatisticsEvent> {
     { no: 3, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
     { no: 4, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
     { no: 5, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
+    { no: 6, name: "gop_structure", kind: "message", T: GopStructure, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamStatisticsEvent {
@@ -22931,6 +23315,12 @@ export class AncillaryMessage extends Message<AncillaryMessage> {
      */
     value: Scte35Event;
     case: "scte35Event";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.MetadataMessage metadata = 6;
+     */
+    value: MetadataMessage;
+    case: "metadata";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<AncillaryMessage>) {
@@ -22944,6 +23334,7 @@ export class AncillaryMessage extends Message<AncillaryMessage> {
     { no: 1, name: "initial_config", kind: "message", T: AncillaryConfiguration, oneof: "message" },
     { no: 2, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
     { no: 3, name: "scte35_event", kind: "message", T: Scte35Event, oneof: "message" },
+    { no: 6, name: "metadata", kind: "message", T: MetadataMessage, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AncillaryMessage {
@@ -22963,6 +23354,75 @@ export class AncillaryMessage extends Message<AncillaryMessage> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.MetadataMessage
+ */
+export class MetadataMessage extends Message<MetadataMessage> {
+  /**
+   * @generated from field: norsk.api.media.StreamKey stream = 1;
+   */
+  stream?: StreamKey;
+
+  /**
+   * The raw data of the metadata message, excluding Metadata Access Unit wrapper if present
+   *
+   * @generated from field: bytes data = 2;
+   */
+  data = new Uint8Array(0);
+
+  /**
+   * Metadata service id, if present
+   *
+   * @generated from field: uint32 metadata_service_id = 3;
+   */
+  metadataServiceId = 0;
+
+  /**
+   * Timestamp of the metadata message
+   *
+   * @generated from field: norsk.api.media.Interval pts = 4;
+   */
+  pts?: Interval;
+
+  /**
+   * The form of metadata being transported
+   *
+   * @generated from field: norsk.api.media.MetadataKind format = 5;
+   */
+  format = MetadataKind.OTHER;
+
+  constructor(data?: PartialMessage<MetadataMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MetadataMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "stream", kind: "message", T: StreamKey },
+    { no: 2, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
+    { no: 3, name: "metadata_service_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 4, name: "pts", kind: "message", T: Interval },
+    { no: 5, name: "format", kind: "enum", T: proto3.getEnumType(MetadataKind) },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MetadataMessage {
+    return new MetadataMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MetadataMessage {
+    return new MetadataMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MetadataMessage {
+    return new MetadataMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MetadataMessage | PlainMessage<MetadataMessage> | undefined, b: MetadataMessage | PlainMessage<MetadataMessage> | undefined): boolean {
+    return proto3.util.equals(MetadataMessage, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.AncillaryEvent
  */
@@ -23006,6 +23466,12 @@ export class AncillaryEvent extends Message<AncillaryEvent> {
      */
     value: Context;
     case: "inboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.MetadataMessage metadata = 8;
+     */
+    value: MetadataMessage;
+    case: "metadata";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<AncillaryEvent>) {
@@ -23022,6 +23488,7 @@ export class AncillaryEvent extends Message<AncillaryEvent> {
     { no: 4, name: "scte35_event", kind: "message", T: Scte35Event, oneof: "message" },
     { no: 6, name: "smpte2038_message", kind: "message", T: Smpte2038Message, oneof: "message" },
     { no: 7, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
+    { no: 8, name: "metadata", kind: "message", T: MetadataMessage, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AncillaryEvent {
@@ -23055,6 +23522,13 @@ export class Scte35Event extends Message<Scte35Event> {
    */
   info?: Scte35SpliceInfoSection;
 
+  /**
+   * Timestamp assigned to the SCTE-35 message in processing
+   *
+   * @generated from field: norsk.api.media.Interval pts = 3;
+   */
+  pts?: Interval;
+
   constructor(data?: PartialMessage<Scte35Event>) {
     super();
     proto3.util.initPartial(data, this);
@@ -23065,6 +23539,7 @@ export class Scte35Event extends Message<Scte35Event> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "stream", kind: "message", T: StreamKey },
     { no: 2, name: "info", kind: "message", T: Scte35SpliceInfoSection },
+    { no: 3, name: "pts", kind: "message", T: Interval },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35Event {
@@ -23123,6 +23598,13 @@ export class Smpte2038Message extends Message<Smpte2038Message> {
    */
   userData = new Uint8Array(0);
 
+  /**
+   * Timestamp of the SMPTE-2038 message
+   *
+   * @generated from field: norsk.api.media.Interval pts = 8;
+   */
+  pts?: Interval;
+
   constructor(data?: PartialMessage<Smpte2038Message>) {
     super();
     proto3.util.initPartial(data, this);
@@ -23138,6 +23620,7 @@ export class Smpte2038Message extends Message<Smpte2038Message> {
     { no: 5, name: "payload_format", kind: "enum", T: proto3.getEnumType(VancPayloadFormat) },
     { no: 6, name: "ancillary_id", kind: "message", T: VancType2AncillaryId },
     { no: 7, name: "user_data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
+    { no: 8, name: "pts", kind: "message", T: Interval },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Smpte2038Message {
@@ -23200,6 +23683,157 @@ export class VancType2AncillaryId extends Message<VancType2AncillaryId> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.StreamConditionConfiguration
+ */
+export class StreamConditionConfiguration extends Message<StreamConditionConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  constructor(data?: PartialMessage<StreamConditionConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamConditionConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamConditionConfiguration {
+    return new StreamConditionConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamConditionConfiguration {
+    return new StreamConditionConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamConditionConfiguration {
+    return new StreamConditionConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamConditionConfiguration | PlainMessage<StreamConditionConfiguration> | undefined, b: StreamConditionConfiguration | PlainMessage<StreamConditionConfiguration> | undefined): boolean {
+    return proto3.util.equals(StreamConditionConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.StreamConditionMessage
+ */
+export class StreamConditionMessage extends Message<StreamConditionMessage> {
+  /**
+   * @generated from oneof norsk.api.media.StreamConditionMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.StreamConditionConfiguration initial_config = 1;
+     */
+    value: StreamConditionConfiguration;
+    case: "initialConfig";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Subscription subscription = 2;
+     */
+    value: Subscription;
+    case: "subscription";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<StreamConditionMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamConditionMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "initial_config", kind: "message", T: StreamConditionConfiguration, oneof: "message" },
+    { no: 2, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamConditionMessage {
+    return new StreamConditionMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamConditionMessage {
+    return new StreamConditionMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamConditionMessage {
+    return new StreamConditionMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamConditionMessage | PlainMessage<StreamConditionMessage> | undefined, b: StreamConditionMessage | PlainMessage<StreamConditionMessage> | undefined): boolean {
+    return proto3.util.equals(StreamConditionMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.StreamConditionEvent
+ */
+export class StreamConditionEvent extends Message<StreamConditionEvent> {
+  /**
+   * @generated from oneof norsk.api.media.StreamConditionEvent.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.MediaNodeId node_id = 1;
+     */
+    value: MediaNodeId;
+    case: "nodeId";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context inbound_context = 2;
+     */
+    value: Context;
+    case: "inboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context outbound_context = 3;
+     */
+    value: Context;
+    case: "outboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 4;
+     */
+    value: SubscriptionResponse;
+    case: "subscriptionResponse";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<StreamConditionEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamConditionEvent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
+    { no: 2, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
+    { no: 3, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
+    { no: 4, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamConditionEvent {
+    return new StreamConditionEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamConditionEvent {
+    return new StreamConditionEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamConditionEvent {
+    return new StreamConditionEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamConditionEvent | PlainMessage<StreamConditionEvent> | undefined, b: StreamConditionEvent | PlainMessage<StreamConditionEvent> | undefined): boolean {
+    return proto3.util.equals(StreamConditionEvent, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.Scte35SpliceInfoSection
  */
@@ -23547,6 +24181,8 @@ export class Scte35InsertCommandMode extends Message<Scte35InsertCommandMode> {
  */
 export class Scte35InsertCommandMode_InsertProgram extends Message<Scte35InsertCommandMode_InsertProgram> {
   /**
+   * Splice time (optional - omitted is splice immediate)
+   *
    * @generated from field: norsk.api.media.Scte35SpliceTime splice_time = 1;
    */
   spliceTime?: Scte35SpliceTime;
@@ -23626,6 +24262,8 @@ export class Scte35InsertCommandComponent extends Message<Scte35InsertCommandCom
   componentTag = 0;
 
   /**
+   * Splice time (optional - omitted is splice immediate)
+   *
    * @generated from field: norsk.api.media.Scte35SpliceTime splice_time = 2;
    */
   spliceTime?: Scte35SpliceTime;
@@ -23664,6 +24302,8 @@ export class Scte35InsertCommandComponent extends Message<Scte35InsertCommandCom
  */
 export class Scte35SpliceTime extends Message<Scte35SpliceTime> {
   /**
+   * Splice time if specified (otherwise represents the default splice time in Component Splice Mode, see SCTE 35 9.9.2.1)
+   *
    * @generated from field: norsk.api.common.OptionalInt pts_time = 1;
    */
   ptsTime?: OptionalInt;
@@ -26760,3 +27400,84 @@ export class NorskStatusEvent extends Message<NorskStatusEvent> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.SubscriptionChannelMessage
+ */
+export class SubscriptionChannelMessage extends Message<SubscriptionChannelMessage> {
+  /**
+   * @generated from oneof norsk.api.media.SubscriptionChannelMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.BlockingCallRef unblock = 1;
+     */
+    value: BlockingCallRef;
+    case: "unblock";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.ValidationResponse validation_response = 2;
+     */
+    value: ValidationResponse;
+    case: "validationResponse";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<SubscriptionChannelMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SubscriptionChannelMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "unblock", kind: "message", T: BlockingCallRef, oneof: "message" },
+    { no: 2, name: "validation_response", kind: "message", T: ValidationResponse, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscriptionChannelMessage {
+    return new SubscriptionChannelMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubscriptionChannelMessage {
+    return new SubscriptionChannelMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubscriptionChannelMessage {
+    return new SubscriptionChannelMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SubscriptionChannelMessage | PlainMessage<SubscriptionChannelMessage> | undefined, b: SubscriptionChannelMessage | PlainMessage<SubscriptionChannelMessage> | undefined): boolean {
+    return proto3.util.equals(SubscriptionChannelMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SubscriptionChannelResponse
+ */
+export class SubscriptionChannelResponse extends Message<SubscriptionChannelResponse> {
+  constructor(data?: PartialMessage<SubscriptionChannelResponse>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SubscriptionChannelResponse";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscriptionChannelResponse {
+    return new SubscriptionChannelResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubscriptionChannelResponse {
+    return new SubscriptionChannelResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubscriptionChannelResponse {
+    return new SubscriptionChannelResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SubscriptionChannelResponse | PlainMessage<SubscriptionChannelResponse> | undefined, b: SubscriptionChannelResponse | PlainMessage<SubscriptionChannelResponse> | undefined): boolean {
+    return proto3.util.equals(SubscriptionChannelResponse, a, b);
+  }
+}
+