@norskvideo/norsk-api 1.0.338 → 1.0.340

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 {
@@ -7872,6 +8347,11 @@ export class VideoComposeConfiguration extends Message<VideoComposeConfiguration
    */
   missingStreamBehaviour = VideoComposeConfiguration_MissingStreamBehaviour.UNSPECIFIED_BEHAVIOUR;
 
+  /**
+   * @generated from field: norsk.api.media.VideoComposeConfiguration.ComposeHardwareAcceleration hardware_acceleration = 8;
+   */
+  hardwareAcceleration = VideoComposeConfiguration_ComposeHardwareAcceleration.NONE;
+
   constructor(data?: PartialMessage<VideoComposeConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -7887,6 +8367,7 @@ export class VideoComposeConfiguration extends Message<VideoComposeConfiguration
     { no: 5, name: "output_resolution", kind: "message", T: Resolution },
     { no: 6, name: "output_pixel_format", kind: "enum", T: proto3.getEnumType(VideoComposeConfiguration_PixelFormat) },
     { no: 7, name: "missing_stream_behaviour", kind: "enum", T: proto3.getEnumType(VideoComposeConfiguration_MissingStreamBehaviour) },
+    { no: 8, name: "hardware_acceleration", kind: "enum", T: proto3.getEnumType(VideoComposeConfiguration_ComposeHardwareAcceleration) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoComposeConfiguration {
@@ -7906,6 +8387,26 @@ export class VideoComposeConfiguration extends Message<VideoComposeConfiguration
   }
 }
 
+/**
+ * @generated from enum norsk.api.media.VideoComposeConfiguration.ComposeHardwareAcceleration
+ */
+export enum VideoComposeConfiguration_ComposeHardwareAcceleration {
+  /**
+   * @generated from enum value: NONE = 0;
+   */
+  NONE = 0,
+
+  /**
+   * @generated from enum value: QUADRA = 1;
+   */
+  QUADRA = 1,
+}
+// Retrieve enum metadata with: proto3.getEnumType(VideoComposeConfiguration_ComposeHardwareAcceleration)
+proto3.util.setEnumType(VideoComposeConfiguration_ComposeHardwareAcceleration, "norsk.api.media.VideoComposeConfiguration.ComposeHardwareAcceleration", [
+  { no: 0, name: "NONE" },
+  { no: 1, name: "QUADRA" },
+]);
+
 /**
  * @generated from enum norsk.api.media.VideoComposeConfiguration.PixelFormat
  */
@@ -10443,9 +10944,9 @@ export class CmafWebVttMessage extends Message<CmafWebVttMessage> {
 }
 
 /**
- * @generated from message norsk.api.media.CmafMasterConfiguration
+ * @generated from message norsk.api.media.CmafMultiVariantConfiguration
  */
-export class CmafMasterConfiguration extends Message<CmafMasterConfiguration> {
+export class CmafMultiVariantConfiguration extends Message<CmafMultiVariantConfiguration> {
   /**
    * @generated from field: norsk.api.media.MediaNodeId id = 1;
    */
@@ -10467,7 +10968,7 @@ export class CmafMasterConfiguration extends Message<CmafMasterConfiguration> {
   destinations: CMAFDestination[] = [];
 
   /**
-   * Directives to add to the m3u master playlist
+   * Directives to add to the m3u multi variant playlist
    *
    * @generated from field: string m3u_additions = 5;
    */
@@ -10480,13 +10981,13 @@ export class CmafMasterConfiguration extends Message<CmafMasterConfiguration> {
    */
   mpdAdditions = "";
 
-  constructor(data?: PartialMessage<CmafMasterConfiguration>) {
+  constructor(data?: PartialMessage<CmafMultiVariantConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.CmafMasterConfiguration";
+  static readonly typeName = "norsk.api.media.CmafMultiVariantConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "playlist_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
@@ -10496,29 +10997,29 @@ export class CmafMasterConfiguration extends Message<CmafMasterConfiguration> {
     { no: 6, name: "mpd_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafMasterConfiguration {
-    return new CmafMasterConfiguration().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafMultiVariantConfiguration {
+    return new CmafMultiVariantConfiguration().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafMasterConfiguration {
-    return new CmafMasterConfiguration().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafMultiVariantConfiguration {
+    return new CmafMultiVariantConfiguration().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafMasterConfiguration {
-    return new CmafMasterConfiguration().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafMultiVariantConfiguration {
+    return new CmafMultiVariantConfiguration().fromJsonString(jsonString, options);
   }
 
-  static equals(a: CmafMasterConfiguration | PlainMessage<CmafMasterConfiguration> | undefined, b: CmafMasterConfiguration | PlainMessage<CmafMasterConfiguration> | undefined): boolean {
-    return proto3.util.equals(CmafMasterConfiguration, a, b);
+  static equals(a: CmafMultiVariantConfiguration | PlainMessage<CmafMultiVariantConfiguration> | undefined, b: CmafMultiVariantConfiguration | PlainMessage<CmafMultiVariantConfiguration> | undefined): boolean {
+    return proto3.util.equals(CmafMultiVariantConfiguration, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.CmafMasterMessage
+ * @generated from message norsk.api.media.CmafMultiVariantMessage
  */
-export class CmafMasterMessage extends Message<CmafMasterMessage> {
+export class CmafMultiVariantMessage extends Message<CmafMultiVariantMessage> {
   /**
-   * @generated from oneof norsk.api.media.CmafMasterMessage.message
+   * @generated from oneof norsk.api.media.CmafMultiVariantMessage.message
    */
   message: {
     /**
@@ -10528,9 +11029,9 @@ export class CmafMasterMessage extends Message<CmafMasterMessage> {
     case: "subscription";
   } | {
     /**
-     * @generated from field: norsk.api.media.CmafMasterConfiguration configuration = 2;
+     * @generated from field: norsk.api.media.CmafMultiVariantConfiguration configuration = 2;
      */
-    value: CmafMasterConfiguration;
+    value: CmafMultiVariantConfiguration;
     case: "configuration";
   } | {
     /**
@@ -10540,33 +11041,33 @@ export class CmafMasterMessage extends Message<CmafMasterMessage> {
     case: "updateCredentials";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<CmafMasterMessage>) {
+  constructor(data?: PartialMessage<CmafMultiVariantMessage>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.CmafMasterMessage";
+  static readonly typeName = "norsk.api.media.CmafMultiVariantMessage";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
-    { no: 2, name: "configuration", kind: "message", T: CmafMasterConfiguration, oneof: "message" },
+    { no: 2, name: "configuration", kind: "message", T: CmafMultiVariantConfiguration, oneof: "message" },
     { no: 3, name: "update_credentials", kind: "message", T: UpdateCredentials, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafMasterMessage {
-    return new CmafMasterMessage().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafMultiVariantMessage {
+    return new CmafMultiVariantMessage().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafMasterMessage {
-    return new CmafMasterMessage().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafMultiVariantMessage {
+    return new CmafMultiVariantMessage().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafMasterMessage {
-    return new CmafMasterMessage().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafMultiVariantMessage {
+    return new CmafMultiVariantMessage().fromJsonString(jsonString, options);
   }
 
-  static equals(a: CmafMasterMessage | PlainMessage<CmafMasterMessage> | undefined, b: CmafMasterMessage | PlainMessage<CmafMasterMessage> | undefined): boolean {
-    return proto3.util.equals(CmafMasterMessage, a, b);
+  static equals(a: CmafMultiVariantMessage | PlainMessage<CmafMultiVariantMessage> | undefined, b: CmafMultiVariantMessage | PlainMessage<CmafMultiVariantMessage> | undefined): boolean {
+    return proto3.util.equals(CmafMultiVariantMessage, a, b);
   }
 }
 
@@ -10801,6 +11302,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 +11322,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 {
@@ -13983,11 +14491,6 @@ export class QuadraH264 extends Message<QuadraH264> {
    */
   bitrate?: OptionalInt;
 
-  /**
-   * @generated from field: norsk.api.media.OptionalBool flushGop = 5;
-   */
-  flushGop?: OptionalBool;
-
   /**
    * @generated from field: norsk.api.media.OptionalBool enableVfr = 6;
    */
@@ -13998,11 +14501,6 @@ export class QuadraH264 extends Message<QuadraH264> {
    */
   crf?: OptionalInt;
 
-  /**
-   * @generated from field: norsk.api.media.OptionalBool cbr = 8;
-   */
-  cbr?: OptionalBool;
-
   /**
    * @generated from field: norsk.api.media.OptionalInt gopPresetIndex = 9;
    */
@@ -14034,9 +14532,54 @@ export class QuadraH264 extends Message<QuadraH264> {
   intraQp?: OptionalInt;
 
   /**
-   * @generated from field: norsk.api.media.OptionalInt rcInitDelay = 15;
+   * @generated from field: norsk.api.media.OptionalBool hrdEnable = 18;
    */
-  rcInitDelay?: OptionalInt;
+  hrdEnable?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt dolbyVisionProfile = 19;
+   */
+  dolbyVisionProfile?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool fillerEnable = 20;
+   */
+  fillerEnable?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt minQp = 21;
+   */
+  minQp?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt maxQp = 22;
+   */
+  maxQp?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt maxDeltaQp = 23;
+   */
+  maxDeltaQp?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool cuLevelRCEnable = 24;
+   */
+  cuLevelRCEnable?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt lookAheadDepth = 25;
+   */
+  lookAheadDepth?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt vbvBufferSize = 26;
+   */
+  vbvBufferSize?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt vbvMaxRate = 27;
+   */
+  vbvMaxRate?: OptionalInt;
 
   constructor(data?: PartialMessage<QuadraH264>) {
     super();
@@ -14050,17 +14593,24 @@ export class QuadraH264 extends Message<QuadraH264> {
     { no: 2, name: "enableAud", kind: "message", T: OptionalBool },
     { no: 3, name: "gpuIndex", kind: "message", T: OptionalInt },
     { no: 4, name: "bitrate", kind: "message", T: OptionalInt },
-    { no: 5, name: "flushGop", kind: "message", T: OptionalBool },
     { no: 6, name: "enableVfr", kind: "message", T: OptionalBool },
     { no: 7, name: "crf", kind: "message", T: OptionalInt },
-    { no: 8, name: "cbr", kind: "message", T: OptionalBool },
     { no: 9, name: "gopPresetIndex", kind: "message", T: OptionalInt },
     { no: 10, name: "intraPeriod", kind: "message", T: OptionalInt },
     { no: 11, name: "profile", kind: "enum", T: proto3.getEnumType(QuadraH264_QuadraH264Profile) },
     { no: 12, name: "level", kind: "message", T: OptionalInt },
     { no: 13, name: "rcEnable", kind: "message", T: OptionalBool },
     { no: 14, name: "intraQp", kind: "message", T: OptionalInt },
-    { no: 15, name: "rcInitDelay", kind: "message", T: OptionalInt },
+    { no: 18, name: "hrdEnable", kind: "message", T: OptionalBool },
+    { no: 19, name: "dolbyVisionProfile", kind: "message", T: OptionalInt },
+    { no: 20, name: "fillerEnable", kind: "message", T: OptionalBool },
+    { no: 21, name: "minQp", kind: "message", T: OptionalInt },
+    { no: 22, name: "maxQp", kind: "message", T: OptionalInt },
+    { no: 23, name: "maxDeltaQp", kind: "message", T: OptionalInt },
+    { no: 24, name: "cuLevelRCEnable", kind: "message", T: OptionalBool },
+    { no: 25, name: "lookAheadDepth", kind: "message", T: OptionalInt },
+    { no: 26, name: "vbvBufferSize", kind: "message", T: OptionalInt },
+    { no: 27, name: "vbvMaxRate", kind: "message", T: OptionalInt },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuadraH264 {
@@ -14148,11 +14698,6 @@ export class QuadraHevc extends Message<QuadraHevc> {
    */
   bitrate?: OptionalInt;
 
-  /**
-   * @generated from field: norsk.api.media.OptionalBool flushGop = 5;
-   */
-  flushGop?: OptionalBool;
-
   /**
    * @generated from field: norsk.api.media.OptionalBool enableVfr = 6;
    */
@@ -14163,11 +14708,6 @@ export class QuadraHevc extends Message<QuadraHevc> {
    */
   crf?: OptionalInt;
 
-  /**
-   * @generated from field: norsk.api.media.OptionalBool cbr = 8;
-   */
-  cbr?: OptionalBool;
-
   /**
    * @generated from field: norsk.api.media.OptionalInt gopPresetIndex = 9;
    */
@@ -14208,11 +14748,6 @@ export class QuadraHevc extends Message<QuadraHevc> {
    */
   intraQp?: OptionalInt;
 
-  /**
-   * @generated from field: norsk.api.media.OptionalInt rcInitDelay = 17;
-   */
-  rcInitDelay?: OptionalInt;
-
   /**
    * @generated from field: norsk.api.media.OptionalBool hrdEnable = 18;
    */
@@ -14223,6 +14758,46 @@ export class QuadraHevc extends Message<QuadraHevc> {
    */
   dolbyVisionProfile?: OptionalInt;
 
+  /**
+   * @generated from field: norsk.api.media.OptionalBool fillerEnable = 20;
+   */
+  fillerEnable?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt minQp = 21;
+   */
+  minQp?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt maxQp = 22;
+   */
+  maxQp?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt maxDeltaQp = 23;
+   */
+  maxDeltaQp?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalBool cuLevelRCEnable = 24;
+   */
+  cuLevelRCEnable?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt lookAheadDepth = 25;
+   */
+  lookAheadDepth?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt vbvBufferSize = 26;
+   */
+  vbvBufferSize?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt vbvMaxRate = 27;
+   */
+  vbvMaxRate?: OptionalInt;
+
   constructor(data?: PartialMessage<QuadraHevc>) {
     super();
     proto3.util.initPartial(data, this);
@@ -14235,10 +14810,8 @@ export class QuadraHevc extends Message<QuadraHevc> {
     { no: 2, name: "enableAud", kind: "message", T: OptionalBool },
     { no: 3, name: "gpuIndex", kind: "message", T: OptionalInt },
     { no: 4, name: "bitrate", kind: "message", T: OptionalInt },
-    { no: 5, name: "flushGop", kind: "message", T: OptionalBool },
     { no: 6, name: "enableVfr", kind: "message", T: OptionalBool },
     { no: 7, name: "crf", kind: "message", T: OptionalInt },
-    { no: 8, name: "cbr", kind: "message", T: OptionalBool },
     { no: 9, name: "gopPresetIndex", kind: "message", T: OptionalInt },
     { no: 10, name: "intraPeriod", kind: "message", T: OptionalInt },
     { no: 11, name: "tier", kind: "enum", T: proto3.getEnumType(QuadraHevc_QuadraHevcTier) },
@@ -14247,9 +14820,16 @@ export class QuadraHevc extends Message<QuadraHevc> {
     { no: 14, name: "rcEnable", kind: "message", T: OptionalBool },
     { no: 15, name: "lossless", kind: "message", T: OptionalBool },
     { no: 16, name: "intraQp", kind: "message", T: OptionalInt },
-    { no: 17, name: "rcInitDelay", kind: "message", T: OptionalInt },
     { no: 18, name: "hrdEnable", kind: "message", T: OptionalBool },
     { no: 19, name: "dolbyVisionProfile", kind: "message", T: OptionalInt },
+    { no: 20, name: "fillerEnable", kind: "message", T: OptionalBool },
+    { no: 21, name: "minQp", kind: "message", T: OptionalInt },
+    { no: 22, name: "maxQp", kind: "message", T: OptionalInt },
+    { no: 23, name: "maxDeltaQp", kind: "message", T: OptionalInt },
+    { no: 24, name: "cuLevelRCEnable", kind: "message", T: OptionalBool },
+    { no: 25, name: "lookAheadDepth", kind: "message", T: OptionalInt },
+    { no: 26, name: "vbvBufferSize", kind: "message", T: OptionalInt },
+    { no: 27, name: "vbvMaxRate", kind: "message", T: OptionalInt },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuadraHevc {