@norskvideo/norsk-api 1.0.337 → 1.0.339

package/lib/media_pb.ts

@@ -1448,6 +1448,76 @@ proto3.util.setEnumType(SentenceStabilizationMode, "norsk.api.media.SentenceStab
   { no: 2, name: "Low" },
 ]);
 
+/**
+ * @generated from enum norsk.api.media.VancPayloadFormat
+ */
+export enum VancPayloadFormat {
+  /**
+   * Other format - see ancillary_id
+   *
+   * @generated from enum value: VANC_OTHER = 0;
+   */
+  VANC_OTHER = 0,
+
+  /**
+   * @generated from enum value: VANC_AFD_BAR = 1;
+   */
+  VANC_AFD_BAR = 1,
+
+  /**
+   * @generated from enum value: VANC_PAN_SCAN = 2;
+   */
+  VANC_PAN_SCAN = 2,
+
+  /**
+   * @generated from enum value: VANC_SCTE_104 = 3;
+   */
+  VANC_SCTE_104 = 3,
+
+  /**
+   * @generated from enum value: VANC_DVB_SCTE_VBI = 4;
+   */
+  VANC_DVB_SCTE_VBI = 4,
+
+  /**
+   * @generated from enum value: VANC_OP47_SDP = 5;
+   */
+  VANC_OP47_SDP = 5,
+
+  /**
+   * @generated from enum value: VANC_OP47_VANC_MULTIPACKET = 6;
+   */
+  VANC_OP47_VANC_MULTIPACKET = 6,
+
+  /**
+   * @generated from enum value: VANC_ANCILLARY_TIME_CODE = 7;
+   */
+  VANC_ANCILLARY_TIME_CODE = 7,
+
+  /**
+   * @generated from enum value: VANC_EIA_708D = 8;
+   */
+  VANC_EIA_708D = 8,
+
+  /**
+   * @generated from enum value: VANC_EIA_608 = 9;
+   */
+  VANC_EIA_608 = 9,
+}
+// Retrieve enum metadata with: proto3.getEnumType(VancPayloadFormat)
+proto3.util.setEnumType(VancPayloadFormat, "norsk.api.media.VancPayloadFormat", [
+  { no: 0, name: "VANC_OTHER" },
+  { no: 1, name: "VANC_AFD_BAR" },
+  { no: 2, name: "VANC_PAN_SCAN" },
+  { no: 3, name: "VANC_SCTE_104" },
+  { no: 4, name: "VANC_DVB_SCTE_VBI" },
+  { no: 5, name: "VANC_OP47_SDP" },
+  { no: 6, name: "VANC_OP47_VANC_MULTIPACKET" },
+  { no: 7, name: "VANC_ANCILLARY_TIME_CODE" },
+  { no: 8, name: "VANC_EIA_708D" },
+  { no: 9, name: "VANC_EIA_608" },
+]);
+
 /**
  * @generated from enum norsk.api.media.VideoConnection
  */
@@ -2429,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>) {
@@ -2444,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 {
@@ -2610,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
  *
@@ -3196,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
  */
@@ -4004,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>) {
@@ -4022,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 {
@@ -4342,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>) {
@@ -4357,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 {
@@ -5126,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>) {
@@ -5142,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 {
@@ -7046,51 +7591,67 @@ export class BrowserInputEvent extends Message<BrowserInputEvent> {
 }
 
 /**
- * @generated from message norsk.api.media.WebRtcIceServerConfiguration
+ * @generated from message norsk.api.media.WebRtcConfiguration
  */
-export class WebRtcIceServerConfiguration extends Message<WebRtcIceServerConfiguration> {
+export class WebRtcConfiguration extends Message<WebRtcConfiguration> {
   /**
    * STUN/TURN servers to use for the Norsk server (and by default report to
    * clients)
    *
-   * @generated from field: repeated norsk.api.media.WebRtcIceServer servers = 1;
+   * @generated from field: repeated norsk.api.media.WebRtcIceServer ice_servers = 1;
    */
-  servers: WebRtcIceServer[] = [];
+  iceServers: WebRtcIceServer[] = [];
 
   /**
    * STUN/TURN servers to report to a connecting client (eg via WHIP/WHEP). If
    * specified overrides the configuration in servers
    *
-   * @generated from field: repeated norsk.api.media.WebRtcIceServer reported_servers = 2;
+   * @generated from field: repeated norsk.api.media.WebRtcIceServer reported_ice_servers = 2;
+   */
+  reportedIceServers: WebRtcIceServer[] = [];
+
+  /**
+   * Server IPs to use instead of the local server IP (optional)
+   *
+   * @generated from field: repeated string hostIps = 3;
+   */
+  hostIps: string[] = [];
+
+  /**
+   * IPs to report as server relexive candiates at session startup (optional)
+   *
+   * @generated from field: repeated string serverReflexiveIps = 4;
    */
-  reportedServers: WebRtcIceServer[] = [];
+  serverReflexiveIps: string[] = [];
 
-  constructor(data?: PartialMessage<WebRtcIceServerConfiguration>) {
+  constructor(data?: PartialMessage<WebRtcConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.WebRtcIceServerConfiguration";
+  static readonly typeName = "norsk.api.media.WebRtcConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "servers", kind: "message", T: WebRtcIceServer, repeated: true },
-    { no: 2, name: "reported_servers", kind: "message", T: WebRtcIceServer, repeated: true },
+    { no: 1, name: "ice_servers", kind: "message", T: WebRtcIceServer, repeated: true },
+    { no: 2, name: "reported_ice_servers", kind: "message", T: WebRtcIceServer, repeated: true },
+    { no: 3, name: "hostIps", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+    { no: 4, name: "serverReflexiveIps", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRtcIceServerConfiguration {
-    return new WebRtcIceServerConfiguration().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRtcConfiguration {
+    return new WebRtcConfiguration().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRtcIceServerConfiguration {
-    return new WebRtcIceServerConfiguration().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRtcConfiguration {
+    return new WebRtcConfiguration().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRtcIceServerConfiguration {
-    return new WebRtcIceServerConfiguration().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRtcConfiguration {
+    return new WebRtcConfiguration().fromJsonString(jsonString, options);
   }
 
-  static equals(a: WebRtcIceServerConfiguration | PlainMessage<WebRtcIceServerConfiguration> | undefined, b: WebRtcIceServerConfiguration | PlainMessage<WebRtcIceServerConfiguration> | undefined): boolean {
-    return proto3.util.equals(WebRtcIceServerConfiguration, a, b);
+  static equals(a: WebRtcConfiguration | PlainMessage<WebRtcConfiguration> | undefined, b: WebRtcConfiguration | PlainMessage<WebRtcConfiguration> | undefined): boolean {
+    return proto3.util.equals(WebRtcConfiguration, a, b);
   }
 }
 
@@ -7167,11 +7728,11 @@ export class WhipInputConfiguration extends Message<WhipInputConfiguration> {
   statsSampling?: StreamStatisticsSampling;
 
   /**
-   * Optionally configure ICE servers (STUN/TURN)
+   * Optionally configure ICE servers (STUN/TURN...)
    *
-   * @generated from field: norsk.api.media.WebRtcIceServerConfiguration ice_server_configuration = 4;
+   * @generated from field: norsk.api.media.WebRtcConfiguration server_configuration = 4;
    */
-  iceServerConfiguration?: WebRtcIceServerConfiguration;
+  serverConfiguration?: WebRtcConfiguration;
 
   constructor(data?: PartialMessage<WhipInputConfiguration>) {
     super();
@@ -7184,7 +7745,7 @@ export class WhipInputConfiguration extends Message<WhipInputConfiguration> {
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
-    { no: 4, name: "ice_server_configuration", kind: "message", T: WebRtcIceServerConfiguration },
+    { no: 4, name: "server_configuration", kind: "message", T: WebRtcConfiguration },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhipInputConfiguration {
@@ -10715,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>) {
@@ -10729,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 {
@@ -11321,9 +11889,9 @@ export class WebRTCBrowserDuplexConfiguration extends Message<WebRTCBrowserDuple
   /**
    * Optionally configure ICE servers (STUN/TURN)
    *
-   * @generated from field: norsk.api.media.WebRtcIceServerConfiguration ice_server_configuration = 3;
+   * @generated from field: norsk.api.media.WebRtcConfiguration server_configuration = 3;
    */
-  iceServerConfiguration?: WebRtcIceServerConfiguration;
+  serverConfiguration?: WebRtcConfiguration;
 
   /**
    * @generated from field: uint32 buffer_delay_ms = 4;
@@ -11340,7 +11908,7 @@ export class WebRTCBrowserDuplexConfiguration extends Message<WebRTCBrowserDuple
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
-    { no: 3, name: "ice_server_configuration", kind: "message", T: WebRtcIceServerConfiguration },
+    { no: 3, name: "server_configuration", kind: "message", T: WebRtcConfiguration },
     { no: 4, name: "buffer_delay_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
   ]);
 
@@ -11499,9 +12067,9 @@ export class WhepOutputConfiguration extends Message<WhepOutputConfiguration> {
   /**
    * Optionally configure ICE servers (STUN/TURN)
    *
-   * @generated from field: norsk.api.media.WebRtcIceServerConfiguration ice_server_configuration = 3;
+   * @generated from field: norsk.api.media.WebRtcConfiguration server_configuration = 3;
    */
-  iceServerConfiguration?: WebRtcIceServerConfiguration;
+  serverConfiguration?: WebRtcConfiguration;
 
   /**
    * @generated from field: uint32 buffer_delay_ms = 4;
@@ -11518,7 +12086,7 @@ export class WhepOutputConfiguration extends Message<WhepOutputConfiguration> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
-    { no: 3, name: "ice_server_configuration", kind: "message", T: WebRtcIceServerConfiguration },
+    { no: 3, name: "server_configuration", kind: "message", T: WebRtcConfiguration },
     { no: 4, name: "buffer_delay_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
   ]);
 
@@ -13303,6 +13871,18 @@ export class VideoEncodeStream extends Message<VideoEncodeStream> {
      */
     value: QuadraHevc;
     case: "quadraHevc";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.XilinxH264 xilinxH264 = 13;
+     */
+    value: XilinxH264;
+    case: "xilinxH264";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.XilinxHevc xilinxHevc = 14;
+     */
+    value: XilinxHevc;
+    case: "xilinxHevc";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<VideoEncodeStream>) {
@@ -13325,6 +13905,8 @@ export class VideoEncodeStream extends Message<VideoEncodeStream> {
     { no: 10, name: "loganHevc", kind: "message", T: LoganHevc, oneof: "codec" },
     { no: 11, name: "quadraH264", kind: "message", T: QuadraH264, oneof: "codec" },
     { no: 12, name: "quadraHevc", kind: "message", T: QuadraHevc, oneof: "codec" },
+    { no: 13, name: "xilinxH264", kind: "message", T: XilinxH264, oneof: "codec" },
+    { no: 14, name: "xilinxHevc", kind: "message", T: XilinxHevc, oneof: "codec" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncodeStream {
@@ -14571,6 +15153,188 @@ proto3.util.setEnumType(LoganHevc_LoganHevcTier, "norsk.api.media.LoganHevc.Loga
   { no: 1, name: "LOGAN_HEVC_TIER_HIGH" },
 ]);
 
+/**
+ * @generated from message norsk.api.media.XilinxH264
+ */
+export class XilinxH264 extends Message<XilinxH264> {
+  /**
+   * @generated from field: norsk.api.media.XilinxH264.XilinxH264Profile profile = 1;
+   */
+  profile = XilinxH264_XilinxH264Profile.DEFAULT;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt level = 2;
+   */
+  level?: OptionalInt;
+
+  constructor(data?: PartialMessage<XilinxH264>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.XilinxH264";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "profile", kind: "enum", T: proto3.getEnumType(XilinxH264_XilinxH264Profile) },
+    { no: 2, name: "level", kind: "message", T: OptionalInt },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): XilinxH264 {
+    return new XilinxH264().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): XilinxH264 {
+    return new XilinxH264().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): XilinxH264 {
+    return new XilinxH264().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: XilinxH264 | PlainMessage<XilinxH264> | undefined, b: XilinxH264 | PlainMessage<XilinxH264> | undefined): boolean {
+    return proto3.util.equals(XilinxH264, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.XilinxH264.XilinxH264Profile
+ */
+export enum XilinxH264_XilinxH264Profile {
+  /**
+   * @generated from enum value: XILINX_H264_PROFILE_DEFAULT = 0;
+   */
+  DEFAULT = 0,
+
+  /**
+   * @generated from enum value: XILINX_H264_PROFILE_BASELINE = 1;
+   */
+  BASELINE = 1,
+
+  /**
+   * @generated from enum value: XILINX_H264_PROFILE_MAIN = 2;
+   */
+  MAIN = 2,
+
+  /**
+   * @generated from enum value: XILINX_H264_PROFILE_EXTENDED = 3;
+   */
+  EXTENDED = 3,
+
+  /**
+   * @generated from enum value: XILINX_H264_PROFILE_HIGH = 4;
+   */
+  HIGH = 4,
+
+  /**
+   * @generated from enum value: XILINX_H264_PROFILE_HIGH10 = 5;
+   */
+  HIGH10 = 5,
+}
+// Retrieve enum metadata with: proto3.getEnumType(XilinxH264_XilinxH264Profile)
+proto3.util.setEnumType(XilinxH264_XilinxH264Profile, "norsk.api.media.XilinxH264.XilinxH264Profile", [
+  { no: 0, name: "XILINX_H264_PROFILE_DEFAULT" },
+  { no: 1, name: "XILINX_H264_PROFILE_BASELINE" },
+  { no: 2, name: "XILINX_H264_PROFILE_MAIN" },
+  { no: 3, name: "XILINX_H264_PROFILE_EXTENDED" },
+  { no: 4, name: "XILINX_H264_PROFILE_HIGH" },
+  { no: 5, name: "XILINX_H264_PROFILE_HIGH10" },
+]);
+
+/**
+ * @generated from message norsk.api.media.XilinxHevc
+ */
+export class XilinxHevc extends Message<XilinxHevc> {
+  /**
+   * @generated from field: norsk.api.media.XilinxHevc.XilinxHevcTier tier = 1;
+   */
+  tier = XilinxHevc_XilinxHevcTier.MAIN;
+
+  /**
+   * @generated from field: norsk.api.media.XilinxHevc.XilinxHevcProfile profile = 2;
+   */
+  profile = XilinxHevc_XilinxHevcProfile.DEFAULT;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt level = 3;
+   */
+  level?: OptionalInt;
+
+  constructor(data?: PartialMessage<XilinxHevc>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.XilinxHevc";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "tier", kind: "enum", T: proto3.getEnumType(XilinxHevc_XilinxHevcTier) },
+    { no: 2, name: "profile", kind: "enum", T: proto3.getEnumType(XilinxHevc_XilinxHevcProfile) },
+    { no: 3, name: "level", kind: "message", T: OptionalInt },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): XilinxHevc {
+    return new XilinxHevc().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): XilinxHevc {
+    return new XilinxHevc().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): XilinxHevc {
+    return new XilinxHevc().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: XilinxHevc | PlainMessage<XilinxHevc> | undefined, b: XilinxHevc | PlainMessage<XilinxHevc> | undefined): boolean {
+    return proto3.util.equals(XilinxHevc, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.XilinxHevc.XilinxHevcProfile
+ */
+export enum XilinxHevc_XilinxHevcProfile {
+  /**
+   * @generated from enum value: XILINX_HEVC_PROFILE_DEFAULT = 0;
+   */
+  DEFAULT = 0,
+
+  /**
+   * @generated from enum value: XILINX_HEVC_PROFILE_MAIN = 1;
+   */
+  MAIN = 1,
+
+  /**
+   * @generated from enum value: XILINX_HEVC_PROFILE_MAIN10 = 2;
+   */
+  MAIN10 = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(XilinxHevc_XilinxHevcProfile)
+proto3.util.setEnumType(XilinxHevc_XilinxHevcProfile, "norsk.api.media.XilinxHevc.XilinxHevcProfile", [
+  { no: 0, name: "XILINX_HEVC_PROFILE_DEFAULT" },
+  { no: 1, name: "XILINX_HEVC_PROFILE_MAIN" },
+  { no: 2, name: "XILINX_HEVC_PROFILE_MAIN10" },
+]);
+
+/**
+ * @generated from enum norsk.api.media.XilinxHevc.XilinxHevcTier
+ */
+export enum XilinxHevc_XilinxHevcTier {
+  /**
+   * @generated from enum value: XILINX_HEVC_TIER_MAIN = 0;
+   */
+  MAIN = 0,
+
+  /**
+   * @generated from enum value: XILINX_HEVC_TIER_HIGH = 1;
+   */
+  HIGH = 1,
+}
+// Retrieve enum metadata with: proto3.getEnumType(XilinxHevc_XilinxHevcTier)
+proto3.util.setEnumType(XilinxHevc_XilinxHevcTier, "norsk.api.media.XilinxHevc.XilinxHevcTier", [
+  { no: 0, name: "XILINX_HEVC_TIER_MAIN" },
+  { no: 1, name: "XILINX_HEVC_TIER_HIGH" },
+]);
+
 /**
  * @generated from message norsk.api.media.VideoTransformConfiguration
  */
@@ -17886,6 +18650,8 @@ export class AncillaryMessage extends Message<AncillaryMessage> {
     case: "subscription";
   } | {
     /**
+     * Scte104Event scte104_event = 4;
+     *
      * @generated from field: norsk.api.media.Scte35Event scte35_event = 3;
      */
     value: Scte35Event;
@@ -17949,10 +18715,18 @@ export class AncillaryEvent extends Message<AncillaryEvent> {
     case: "subscriptionResponse";
   } | {
     /**
+     * Scte104Event scte104_event = 5;
+     *
      * @generated from field: norsk.api.media.Scte35Event scte35_event = 4;
      */
     value: Scte35Event;
     case: "scte35Event";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Smpte2038Message smpte2038_message = 6;
+     */
+    value: Smpte2038Message;
+    case: "smpte2038Message";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<AncillaryEvent>) {
@@ -17967,6 +18741,7 @@ export class AncillaryEvent extends Message<AncillaryEvent> {
     { no: 2, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
     { no: 3, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
     { no: 4, name: "scte35_event", kind: "message", T: Scte35Event, oneof: "message" },
+    { no: 6, name: "smpte2038_message", kind: "message", T: Smpte2038Message, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AncillaryEvent {
@@ -18029,6 +18804,122 @@ export class Scte35Event extends Message<Scte35Event> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.Smpte2038Message
+ */
+export class Smpte2038Message extends Message<Smpte2038Message> {
+  /**
+   * @generated from field: norsk.api.media.StreamKey stream = 1;
+   */
+  stream?: StreamKey;
+
+  /**
+   * @generated from field: bool c_not_y_channel_flag = 2;
+   */
+  cNotYChannelFlag = false;
+
+  /**
+   * @generated from field: uint32 line_number = 3;
+   */
+  lineNumber = 0;
+
+  /**
+   * @generated from field: uint32 horizontal_offset = 4;
+   */
+  horizontalOffset = 0;
+
+  /**
+   * @generated from field: norsk.api.media.VancPayloadFormat payload_format = 5;
+   */
+  payloadFormat = VancPayloadFormat.VANC_OTHER;
+
+  /**
+   * @generated from field: norsk.api.media.VancType2AncillaryId ancillary_id = 6;
+   */
+  ancillaryId?: VancType2AncillaryId;
+
+  /**
+   * @generated from field: bytes user_data = 7;
+   */
+  userData = new Uint8Array(0);
+
+  constructor(data?: PartialMessage<Smpte2038Message>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Smpte2038Message";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "stream", kind: "message", T: StreamKey },
+    { no: 2, name: "c_not_y_channel_flag", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 3, name: "line_number", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 4, name: "horizontal_offset", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { 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 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Smpte2038Message {
+    return new Smpte2038Message().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Smpte2038Message {
+    return new Smpte2038Message().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Smpte2038Message {
+    return new Smpte2038Message().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Smpte2038Message | PlainMessage<Smpte2038Message> | undefined, b: Smpte2038Message | PlainMessage<Smpte2038Message> | undefined): boolean {
+    return proto3.util.equals(Smpte2038Message, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.VancType2AncillaryId
+ */
+export class VancType2AncillaryId extends Message<VancType2AncillaryId> {
+  /**
+   * @generated from field: uint32 did = 1;
+   */
+  did = 0;
+
+  /**
+   * @generated from field: uint32 sdid = 2;
+   */
+  sdid = 0;
+
+  constructor(data?: PartialMessage<VancType2AncillaryId>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.VancType2AncillaryId";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "did", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "sdid", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VancType2AncillaryId {
+    return new VancType2AncillaryId().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VancType2AncillaryId {
+    return new VancType2AncillaryId().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VancType2AncillaryId {
+    return new VancType2AncillaryId().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: VancType2AncillaryId | PlainMessage<VancType2AncillaryId> | undefined, b: VancType2AncillaryId | PlainMessage<VancType2AncillaryId> | undefined): boolean {
+    return proto3.util.equals(VancType2AncillaryId, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.Scte35SpliceInfoSection
  */