@norskvideo/norsk-api 1.0.359 → 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
@@ -21084,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>) {
@@ -21099,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 {
@@ -23158,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>) {
@@ -23171,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 {
@@ -23190,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
  */
@@ -23233,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>) {
@@ -23249,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 {
@@ -23282,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);
@@ -23292,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 {
@@ -23350,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);
@@ -23365,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 {
@@ -23427,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
  */
@@ -23774,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;
@@ -23853,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;
@@ -23891,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;
@@ -26987,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);
+  }
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@norskvideo/norsk-api",
-  "version": "1.0.359",
+  "version": "1.0.360",
   "license": "MIT",
   "dependencies": {
     "@bufbuild/protobuf": "^0.3.0",