@norskvideo/norsk-api 1.0.338 → 1.0.339

package/lib/media_pb.ts

@@ -2499,6 +2499,14 @@ export class StreamMetadata extends Message<StreamMetadata> {
      */
     value: StreamMetadata_AncillaryMetadata;
     case: "ancillary";
+  } | {
+    /**
+     * Playlist metadata
+     *
+     * @generated from field: norsk.api.media.StreamMetadata.PlaylistMetadata playlist = 6;
+     */
+    value: StreamMetadata_PlaylistMetadata;
+    case: "playlist";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<StreamMetadata>) {
@@ -2514,6 +2522,7 @@ export class StreamMetadata extends Message<StreamMetadata> {
     { no: 3, name: "video", kind: "message", T: StreamMetadata_VideoMetadata, oneof: "message" },
     { no: 4, name: "subtitle", kind: "message", T: StreamMetadata_SubtitleMetadata, oneof: "message" },
     { no: 5, name: "ancillary", kind: "message", T: StreamMetadata_AncillaryMetadata, oneof: "message" },
+    { no: 6, name: "playlist", kind: "message", T: StreamMetadata_PlaylistMetadata, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadata {
@@ -2680,6 +2689,39 @@ export class StreamMetadata_SubtitleMetadata extends Message<StreamMetadata_Subt
   }
 }
 
+/**
+ * Metadata for a playlist stream
+ *
+ * @generated from message norsk.api.media.StreamMetadata.PlaylistMetadata
+ */
+export class StreamMetadata_PlaylistMetadata extends Message<StreamMetadata_PlaylistMetadata> {
+  constructor(data?: PartialMessage<StreamMetadata_PlaylistMetadata>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamMetadata.PlaylistMetadata";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadata_PlaylistMetadata {
+    return new StreamMetadata_PlaylistMetadata().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamMetadata_PlaylistMetadata {
+    return new StreamMetadata_PlaylistMetadata().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamMetadata_PlaylistMetadata {
+    return new StreamMetadata_PlaylistMetadata().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamMetadata_PlaylistMetadata | PlainMessage<StreamMetadata_PlaylistMetadata> | undefined, b: StreamMetadata_PlaylistMetadata | PlainMessage<StreamMetadata_PlaylistMetadata> | undefined): boolean {
+    return proto3.util.equals(StreamMetadata_PlaylistMetadata, a, b);
+  }
+}
+
 /**
  * Metadata for an ancillary stream
  *
@@ -3266,6 +3308,418 @@ export class StreamStatisticsSampling extends Message<StreamStatisticsSampling>
   }
 }
 
+/**
+ * @generated from message norsk.api.media.CodecPictureStructure
+ */
+export class CodecPictureStructure extends Message<CodecPictureStructure> {
+  /**
+   * @generated from oneof norsk.api.media.CodecPictureStructure.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.CodecPictureStructure.Mpeg2PictureStructure mpeg2video = 1;
+     */
+    value: CodecPictureStructure_Mpeg2PictureStructure;
+    case: "mpeg2video";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.CodecPictureStructure.H264PictureStructure h264 = 2;
+     */
+    value: CodecPictureStructure_H264PictureStructure;
+    case: "h264";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.CodecPictureStructure.HEVCPictureStructure hevc = 3;
+     */
+    value: CodecPictureStructure_HEVCPictureStructure;
+    case: "hevc";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<CodecPictureStructure>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.CodecPictureStructure";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "mpeg2video", kind: "message", T: CodecPictureStructure_Mpeg2PictureStructure, oneof: "message" },
+    { no: 2, name: "h264", kind: "message", T: CodecPictureStructure_H264PictureStructure, oneof: "message" },
+    { no: 3, name: "hevc", kind: "message", T: CodecPictureStructure_HEVCPictureStructure, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CodecPictureStructure {
+    return new CodecPictureStructure().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CodecPictureStructure {
+    return new CodecPictureStructure().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CodecPictureStructure {
+    return new CodecPictureStructure().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: CodecPictureStructure | PlainMessage<CodecPictureStructure> | undefined, b: CodecPictureStructure | PlainMessage<CodecPictureStructure> | undefined): boolean {
+    return proto3.util.equals(CodecPictureStructure, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.CodecPictureStructure.Mpeg2PictureStructure
+ */
+export class CodecPictureStructure_Mpeg2PictureStructure extends Message<CodecPictureStructure_Mpeg2PictureStructure> {
+  /**
+   * @generated from field: norsk.api.media.CodecPictureStructure.Mpeg2PictureStructure.Mpeg2GopInfo gop_info = 1;
+   */
+  gopInfo = CodecPictureStructure_Mpeg2PictureStructure_Mpeg2GopInfo.MPEG2_GOP_UNKNOWN;
+
+  constructor(data?: PartialMessage<CodecPictureStructure_Mpeg2PictureStructure>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.CodecPictureStructure.Mpeg2PictureStructure";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "gop_info", kind: "enum", T: proto3.getEnumType(CodecPictureStructure_Mpeg2PictureStructure_Mpeg2GopInfo) },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CodecPictureStructure_Mpeg2PictureStructure {
+    return new CodecPictureStructure_Mpeg2PictureStructure().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CodecPictureStructure_Mpeg2PictureStructure {
+    return new CodecPictureStructure_Mpeg2PictureStructure().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CodecPictureStructure_Mpeg2PictureStructure {
+    return new CodecPictureStructure_Mpeg2PictureStructure().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: CodecPictureStructure_Mpeg2PictureStructure | PlainMessage<CodecPictureStructure_Mpeg2PictureStructure> | undefined, b: CodecPictureStructure_Mpeg2PictureStructure | PlainMessage<CodecPictureStructure_Mpeg2PictureStructure> | undefined): boolean {
+    return proto3.util.equals(CodecPictureStructure_Mpeg2PictureStructure, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.CodecPictureStructure.Mpeg2PictureStructure.Mpeg2GopInfo
+ */
+export enum CodecPictureStructure_Mpeg2PictureStructure_Mpeg2GopInfo {
+  /**
+   * There is no gop information, either because it is not coded or this is not the start of a gop
+   *
+   * @generated from enum value: MPEG2_GOP_UNKNOWN = 0;
+   */
+  MPEG2_GOP_UNKNOWN = 0,
+
+  /**
+   * Indicates gop information is present and this is the start of a closed gop
+   *
+   * @generated from enum value: MPEG2_GOP_CLOSED = 1;
+   */
+  MPEG2_GOP_CLOSED = 1,
+
+  /**
+   * Indicates gop information is present and this is the start of an open gop
+   *
+   * @generated from enum value: MPEG2_GOP_OPEN = 2;
+   */
+  MPEG2_GOP_OPEN = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(CodecPictureStructure_Mpeg2PictureStructure_Mpeg2GopInfo)
+proto3.util.setEnumType(CodecPictureStructure_Mpeg2PictureStructure_Mpeg2GopInfo, "norsk.api.media.CodecPictureStructure.Mpeg2PictureStructure.Mpeg2GopInfo", [
+  { no: 0, name: "MPEG2_GOP_UNKNOWN" },
+  { no: 1, name: "MPEG2_GOP_CLOSED" },
+  { no: 2, name: "MPEG2_GOP_OPEN" },
+]);
+
+/**
+ * @generated from message norsk.api.media.CodecPictureStructure.H264PictureStructure
+ */
+export class CodecPictureStructure_H264PictureStructure extends Message<CodecPictureStructure_H264PictureStructure> {
+  /**
+   * @generated from field: bool idr_frame = 1;
+   */
+  idrFrame = false;
+
+  /**
+   * @generated from field: repeated norsk.api.media.CodecPictureStructure.H264PictureStructure.H264SliceType slice_types = 2;
+   */
+  sliceTypes: CodecPictureStructure_H264PictureStructure_H264SliceType[] = [];
+
+  constructor(data?: PartialMessage<CodecPictureStructure_H264PictureStructure>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.CodecPictureStructure.H264PictureStructure";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "idr_frame", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 2, name: "slice_types", kind: "enum", T: proto3.getEnumType(CodecPictureStructure_H264PictureStructure_H264SliceType), repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CodecPictureStructure_H264PictureStructure {
+    return new CodecPictureStructure_H264PictureStructure().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CodecPictureStructure_H264PictureStructure {
+    return new CodecPictureStructure_H264PictureStructure().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CodecPictureStructure_H264PictureStructure {
+    return new CodecPictureStructure_H264PictureStructure().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: CodecPictureStructure_H264PictureStructure | PlainMessage<CodecPictureStructure_H264PictureStructure> | undefined, b: CodecPictureStructure_H264PictureStructure | PlainMessage<CodecPictureStructure_H264PictureStructure> | undefined): boolean {
+    return proto3.util.equals(CodecPictureStructure_H264PictureStructure, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.CodecPictureStructure.H264PictureStructure.H264SliceType
+ */
+export enum CodecPictureStructure_H264PictureStructure_H264SliceType {
+  /**
+   * @generated from enum value: H264_SLICE_TYPE_UNKNOWN = 0;
+   */
+  UNKNOWN = 0,
+
+  /**
+   * @generated from enum value: H264_SLICE_TYPE_I = 1;
+   */
+  I = 1,
+
+  /**
+   * @generated from enum value: H264_SLICE_TYPE_P = 2;
+   */
+  P = 2,
+
+  /**
+   * @generated from enum value: H264_SLICE_TYPE_B = 3;
+   */
+  B = 3,
+
+  /**
+   * @generated from enum value: H264_SLICE_TYPE_SI = 4;
+   */
+  SI = 4,
+
+  /**
+   * @generated from enum value: H264_SLICE_TYPE_SP = 5;
+   */
+  SP = 5,
+}
+// Retrieve enum metadata with: proto3.getEnumType(CodecPictureStructure_H264PictureStructure_H264SliceType)
+proto3.util.setEnumType(CodecPictureStructure_H264PictureStructure_H264SliceType, "norsk.api.media.CodecPictureStructure.H264PictureStructure.H264SliceType", [
+  { no: 0, name: "H264_SLICE_TYPE_UNKNOWN" },
+  { no: 1, name: "H264_SLICE_TYPE_I" },
+  { no: 2, name: "H264_SLICE_TYPE_P" },
+  { no: 3, name: "H264_SLICE_TYPE_B" },
+  { no: 4, name: "H264_SLICE_TYPE_SI" },
+  { no: 5, name: "H264_SLICE_TYPE_SP" },
+]);
+
+/**
+ * @generated from message norsk.api.media.CodecPictureStructure.HEVCPictureStructure
+ */
+export class CodecPictureStructure_HEVCPictureStructure extends Message<CodecPictureStructure_HEVCPictureStructure> {
+  /**
+   * @generated from field: bool irap_frame = 1;
+   */
+  irapFrame = false;
+
+  /**
+   * @generated from field: bool idr_frame = 2;
+   */
+  idrFrame = false;
+
+  /**
+   * @generated from field: repeated norsk.api.media.CodecPictureStructure.HEVCPictureStructure.HEVCSliceType slice_types = 3;
+   */
+  sliceTypes: CodecPictureStructure_HEVCPictureStructure_HEVCSliceType[] = [];
+
+  constructor(data?: PartialMessage<CodecPictureStructure_HEVCPictureStructure>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.CodecPictureStructure.HEVCPictureStructure";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "irap_frame", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 2, name: "idr_frame", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 3, name: "slice_types", kind: "enum", T: proto3.getEnumType(CodecPictureStructure_HEVCPictureStructure_HEVCSliceType), repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CodecPictureStructure_HEVCPictureStructure {
+    return new CodecPictureStructure_HEVCPictureStructure().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CodecPictureStructure_HEVCPictureStructure {
+    return new CodecPictureStructure_HEVCPictureStructure().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CodecPictureStructure_HEVCPictureStructure {
+    return new CodecPictureStructure_HEVCPictureStructure().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: CodecPictureStructure_HEVCPictureStructure | PlainMessage<CodecPictureStructure_HEVCPictureStructure> | undefined, b: CodecPictureStructure_HEVCPictureStructure | PlainMessage<CodecPictureStructure_HEVCPictureStructure> | undefined): boolean {
+    return proto3.util.equals(CodecPictureStructure_HEVCPictureStructure, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.CodecPictureStructure.HEVCPictureStructure.HEVCSliceType
+ */
+export enum CodecPictureStructure_HEVCPictureStructure_HEVCSliceType {
+  /**
+   * @generated from enum value: HEVC_SLICE_TYPE_UNKNOWN = 0;
+   */
+  HEVC_SLICE_TYPE_UNKNOWN = 0,
+
+  /**
+   * @generated from enum value: HEVC_SLICE_TYPE_I = 1;
+   */
+  HEVC_SLICE_TYPE_I = 1,
+
+  /**
+   * @generated from enum value: HEVC_SLICE_TYPE_P = 2;
+   */
+  HEVC_SLICE_TYPE_P = 2,
+
+  /**
+   * @generated from enum value: HEVC_SLICE_TYPE_B = 3;
+   */
+  HEVC_SLICE_TYPE_B = 3,
+}
+// Retrieve enum metadata with: proto3.getEnumType(CodecPictureStructure_HEVCPictureStructure_HEVCSliceType)
+proto3.util.setEnumType(CodecPictureStructure_HEVCPictureStructure_HEVCSliceType, "norsk.api.media.CodecPictureStructure.HEVCPictureStructure.HEVCSliceType", [
+  { no: 0, name: "HEVC_SLICE_TYPE_UNKNOWN" },
+  { no: 1, name: "HEVC_SLICE_TYPE_I" },
+  { no: 2, name: "HEVC_SLICE_TYPE_P" },
+  { no: 3, name: "HEVC_SLICE_TYPE_B" },
+]);
+
+/**
+ * @generated from message norsk.api.media.GopStructure
+ */
+export class GopStructure extends Message<GopStructure> {
+  /**
+   * @generated from field: norsk.api.media.StreamKey stream_key = 1;
+   */
+  streamKey?: StreamKey;
+
+  /**
+   * @generated from field: repeated norsk.api.media.GopStructure.SinglePictureStructure pictures = 2;
+   */
+  pictures: GopStructure_SinglePictureStructure[] = [];
+
+  constructor(data?: PartialMessage<GopStructure>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.GopStructure";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "stream_key", kind: "message", T: StreamKey },
+    { no: 2, name: "pictures", kind: "message", T: GopStructure_SinglePictureStructure, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GopStructure {
+    return new GopStructure().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GopStructure {
+    return new GopStructure().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GopStructure {
+    return new GopStructure().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: GopStructure | PlainMessage<GopStructure> | undefined, b: GopStructure | PlainMessage<GopStructure> | undefined): boolean {
+    return proto3.util.equals(GopStructure, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.GopStructure.PictureType
+ */
+export enum GopStructure_PictureType {
+  /**
+   * @generated from enum value: PICTURE_TYPE_UNKNOWN = 0;
+   */
+  UNKNOWN = 0,
+
+  /**
+   * @generated from enum value: PICTURE_TYPE_I = 1;
+   */
+  I = 1,
+
+  /**
+   * @generated from enum value: PICTURE_TYPE_P = 2;
+   */
+  P = 2,
+
+  /**
+   * @generated from enum value: PICTURE_TYPE_B = 3;
+   */
+  B = 3,
+}
+// Retrieve enum metadata with: proto3.getEnumType(GopStructure_PictureType)
+proto3.util.setEnumType(GopStructure_PictureType, "norsk.api.media.GopStructure.PictureType", [
+  { no: 0, name: "PICTURE_TYPE_UNKNOWN" },
+  { no: 1, name: "PICTURE_TYPE_I" },
+  { no: 2, name: "PICTURE_TYPE_P" },
+  { no: 3, name: "PICTURE_TYPE_B" },
+]);
+
+/**
+ * @generated from message norsk.api.media.GopStructure.SinglePictureStructure
+ */
+export class GopStructure_SinglePictureStructure extends Message<GopStructure_SinglePictureStructure> {
+  /**
+   * @generated from field: norsk.api.media.GopStructure.PictureType generic_picture_type = 1;
+   */
+  genericPictureType = GopStructure_PictureType.UNKNOWN;
+
+  /**
+   * @generated from field: norsk.api.media.CodecPictureStructure codec_structure = 2;
+   */
+  codecStructure?: CodecPictureStructure;
+
+  constructor(data?: PartialMessage<GopStructure_SinglePictureStructure>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.GopStructure.SinglePictureStructure";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "generic_picture_type", kind: "enum", T: proto3.getEnumType(GopStructure_PictureType) },
+    { no: 2, name: "codec_structure", kind: "message", T: CodecPictureStructure },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GopStructure_SinglePictureStructure {
+    return new GopStructure_SinglePictureStructure().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GopStructure_SinglePictureStructure {
+    return new GopStructure_SinglePictureStructure().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GopStructure_SinglePictureStructure {
+    return new GopStructure_SinglePictureStructure().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: GopStructure_SinglePictureStructure | PlainMessage<GopStructure_SinglePictureStructure> | undefined, b: GopStructure_SinglePictureStructure | PlainMessage<GopStructure_SinglePictureStructure> | undefined): boolean {
+    return proto3.util.equals(GopStructure_SinglePictureStructure, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.ConnectionId
  */
@@ -4074,6 +4528,12 @@ export class RtmpServerInputEvent extends Message<RtmpServerInputEvent> {
      */
     value: RtmpBytesRead;
     case: "bytesRead";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.GopStructure gop_structure = 9;
+     */
+    value: GopStructure;
+    case: "gopStructure";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<RtmpServerInputEvent>) {
@@ -4092,6 +4552,7 @@ export class RtmpServerInputEvent extends Message<RtmpServerInputEvent> {
     { no: 6, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
     { no: 7, name: "error", kind: "message", T: RtmpError, oneof: "message" },
     { no: 8, name: "bytes_read", kind: "message", T: RtmpBytesRead, oneof: "message" },
+    { no: 9, name: "gop_structure", kind: "message", T: GopStructure, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpServerInputEvent {
@@ -4412,6 +4873,12 @@ export class TsInputEvent extends Message<TsInputEvent> {
      */
     value: MultiStreamStatistics;
     case: "streamStatistics";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.GopStructure gop_structure = 6;
+     */
+    value: GopStructure;
+    case: "gopStructure";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<TsInputEvent>) {
@@ -4427,6 +4894,7 @@ export class TsInputEvent extends Message<TsInputEvent> {
     { no: 3, name: "ts_context", kind: "message", T: TsContext, oneof: "message" },
     { no: 4, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
     { no: 5, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
+    { no: 6, name: "gop_structure", kind: "message", T: GopStructure, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TsInputEvent {
@@ -5196,6 +5664,12 @@ export class SrtInputEvent extends Message<SrtInputEvent> {
      */
     value: MultiStreamStatistics;
     case: "streamStatistics";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.GopStructure gop_structure = 8;
+     */
+    value: GopStructure;
+    case: "gopStructure";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<SrtInputEvent>) {
@@ -5212,6 +5686,7 @@ export class SrtInputEvent extends Message<SrtInputEvent> {
     { no: 5, name: "on_connected", kind: "message", T: SrtConnectMessage, oneof: "message" },
     { no: 6, name: "status", kind: "message", T: SrtInputStatus, oneof: "message" },
     { no: 7, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
+    { no: 8, name: "gop_structure", kind: "message", T: GopStructure, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SrtInputEvent {
@@ -10801,6 +11276,12 @@ export class HlsOutputEvent extends Message<HlsOutputEvent> {
      */
     value: MultiStreamStatistics;
     case: "streamStatistics";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context outbound_context = 5;
+     */
+    value: Context;
+    case: "outboundContext";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<HlsOutputEvent>) {
@@ -10815,6 +11296,7 @@ export class HlsOutputEvent extends Message<HlsOutputEvent> {
     { 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: "outbound_context", kind: "message", T: Context, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsOutputEvent {

package/package.json

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