@norskvideo/norsk-api 1.0.336 → 1.0.338

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
  */
@@ -7046,51 +7116,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;
    */
-  reportedServers: WebRtcIceServer[] = [];
+  reportedIceServers: WebRtcIceServer[] = [];
 
-  constructor(data?: PartialMessage<WebRtcIceServerConfiguration>) {
+  /**
+   * 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;
+   */
+  serverReflexiveIps: string[] = [];
+
+  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 +7253,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 +7270,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 {
@@ -11321,9 +11407,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 +11426,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 +11585,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 +11604,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 +13389,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 +13423,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 +14671,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 +18168,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 +18233,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 +18259,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 +18322,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
  */

package/package.json

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