@norskvideo/norsk-api 1.0.343 → 1.0.345

package/lib/media_pb.ts

@@ -621,6 +621,32 @@ proto3.util.setEnumType(SrtMode, "norsk.api.media.SrtMode", [
   { no: 1, name: "Caller" },
 ]);
 
+/**
+ * @generated from enum norsk.api.media.TestCardPattern
+ */
+export enum TestCardPattern {
+  /**
+   * @generated from enum value: Black = 0;
+   */
+  Black = 0,
+
+  /**
+   * @generated from enum value: Smpte75 = 1;
+   */
+  Smpte75 = 1,
+
+  /**
+   * @generated from enum value: Smpte100 = 2;
+   */
+  Smpte100 = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(TestCardPattern)
+proto3.util.setEnumType(TestCardPattern, "norsk.api.media.TestCardPattern", [
+  { no: 0, name: "Black" },
+  { no: 1, name: "Smpte75" },
+  { no: 2, name: "Smpte100" },
+]);
+
 /**
  * ///////////////////////////////
  * DeckLink Input
@@ -1982,6 +2008,51 @@ export class Resolution extends Message<Resolution> {
   }
 }
 
+/**
+ * A time interval measured as ticks / (ticks per second)
+ *
+ * @generated from message norsk.api.media.Interval
+ */
+export class Interval extends Message<Interval> {
+  /**
+   * @generated from field: uint32 n = 1;
+   */
+  n = 0;
+
+  /**
+   * @generated from field: uint32 d = 2;
+   */
+  d = 0;
+
+  constructor(data?: PartialMessage<Interval>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Interval";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "n", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "d", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Interval {
+    return new Interval().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Interval {
+    return new Interval().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Interval {
+    return new Interval().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Interval | PlainMessage<Interval> | undefined, b: Interval | PlainMessage<Interval> | undefined): boolean {
+    return proto3.util.equals(Interval, a, b);
+  }
+}
+
 /**
  * ////////////////////////////////////////////////////////////////////////////
  * Context
@@ -2647,6 +2718,13 @@ export class StreamMetadata_VideoMetadata extends Message<StreamMetadata_VideoMe
    */
   bitrate = 0;
 
+  /**
+   * The framerate of this video
+   *
+   * @generated from field: norsk.api.media.FrameRate frame_rate = 6;
+   */
+  frameRate?: FrameRate;
+
   constructor(data?: PartialMessage<StreamMetadata_VideoMetadata>) {
     super();
     proto3.util.initPartial(data, this);
@@ -2659,6 +2737,7 @@ export class StreamMetadata_VideoMetadata extends Message<StreamMetadata_VideoMe
     { no: 3, name: "width", kind: "scalar", T: 17 /* ScalarType.SINT32 */ },
     { no: 4, name: "height", kind: "scalar", T: 17 /* ScalarType.SINT32 */ },
     { no: 5, name: "bitrate", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 6, name: "frame_rate", kind: "message", T: FrameRate },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadata_VideoMetadata {
@@ -6068,15 +6147,30 @@ export class TestCardVideoConfiguration extends Message<TestCardVideoConfigurati
   resolution?: Resolution;
 
   /**
-   * @generated from field: string source_name = 2;
+   * @generated from field: norsk.api.media.FrameRate frame_rate = 2;
+   */
+  frameRate?: FrameRate;
+
+  /**
+   * @generated from field: string source_name = 3;
    */
   sourceName = "";
 
   /**
-   * @generated from field: int32 number_of_frames = 3;
+   * @generated from field: int32 number_of_frames = 4;
    */
   numberOfFrames = 0;
 
+  /**
+   * @generated from field: bool realtime = 5;
+   */
+  realtime = false;
+
+  /**
+   * @generated from field: norsk.api.media.TestCardPattern pattern = 6;
+   */
+  pattern = TestCardPattern.Black;
+
   constructor(data?: PartialMessage<TestCardVideoConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -6086,8 +6180,11 @@ export class TestCardVideoConfiguration extends Message<TestCardVideoConfigurati
   static readonly typeName = "norsk.api.media.TestCardVideoConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "resolution", kind: "message", T: Resolution },
-    { no: 2, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: "number_of_frames", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 2, name: "frame_rate", kind: "message", T: FrameRate },
+    { no: 3, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "number_of_frames", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 5, name: "realtime", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 6, name: "pattern", kind: "enum", T: proto3.getEnumType(TestCardPattern) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TestCardVideoConfiguration {
@@ -6176,12 +6273,6 @@ export class VideoTestCardGeneratorEvent extends Message<VideoTestCardGeneratorE
      */
     value: Context;
     case: "outboundContext";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 3;
-     */
-    value: SubscriptionResponse;
-    case: "subscriptionResponse";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<VideoTestCardGeneratorEvent>) {
@@ -6194,7 +6285,6 @@ export class VideoTestCardGeneratorEvent extends Message<VideoTestCardGeneratorE
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
     { no: 2, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
-    { no: 3, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoTestCardGeneratorEvent {
@@ -16985,54 +17075,70 @@ export class StreamSyncEvent extends Message<StreamSyncEvent> {
 }
 
 /**
- * @generated from message norsk.api.media.StreamProgramJoinConfiguration
+ * @generated from message norsk.api.media.StreamAlignConfiguration
  */
-export class StreamProgramJoinConfiguration extends Message<StreamProgramJoinConfiguration> {
+export class StreamAlignConfiguration extends Message<StreamAlignConfiguration> {
   /**
    * @generated from field: norsk.api.media.MediaNodeId id = 1;
    */
   id?: MediaNodeId;
 
-  constructor(data?: PartialMessage<StreamProgramJoinConfiguration>) {
+  /**
+   * The normalisd sample rate of the audio output
+   *
+   * @generated from field: norsk.api.media.SampleRate sample_rate = 2;
+   */
+  sampleRate = SampleRate.RATE_8000;
+
+  /**
+   * The normalised frame rate of the video output
+   *
+   * @generated from field: norsk.api.media.FrameRate frame_rate = 3;
+   */
+  frameRate?: FrameRate;
+
+  constructor(data?: PartialMessage<StreamAlignConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.StreamProgramJoinConfiguration";
+  static readonly typeName = "norsk.api.media.StreamAlignConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "sample_rate", kind: "enum", T: proto3.getEnumType(SampleRate) },
+    { no: 3, name: "frame_rate", kind: "message", T: FrameRate },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamProgramJoinConfiguration {
-    return new StreamProgramJoinConfiguration().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamAlignConfiguration {
+    return new StreamAlignConfiguration().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamProgramJoinConfiguration {
-    return new StreamProgramJoinConfiguration().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamAlignConfiguration {
+    return new StreamAlignConfiguration().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamProgramJoinConfiguration {
-    return new StreamProgramJoinConfiguration().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamAlignConfiguration {
+    return new StreamAlignConfiguration().fromJsonString(jsonString, options);
   }
 
-  static equals(a: StreamProgramJoinConfiguration | PlainMessage<StreamProgramJoinConfiguration> | undefined, b: StreamProgramJoinConfiguration | PlainMessage<StreamProgramJoinConfiguration> | undefined): boolean {
-    return proto3.util.equals(StreamProgramJoinConfiguration, a, b);
+  static equals(a: StreamAlignConfiguration | PlainMessage<StreamAlignConfiguration> | undefined, b: StreamAlignConfiguration | PlainMessage<StreamAlignConfiguration> | undefined): boolean {
+    return proto3.util.equals(StreamAlignConfiguration, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.StreamProgramJoinMessage
+ * @generated from message norsk.api.media.StreamAlignMessage
  */
-export class StreamProgramJoinMessage extends Message<StreamProgramJoinMessage> {
+export class StreamAlignMessage extends Message<StreamAlignMessage> {
   /**
-   * @generated from oneof norsk.api.media.StreamProgramJoinMessage.message
+   * @generated from oneof norsk.api.media.StreamAlignMessage.message
    */
   message: {
     /**
-     * @generated from field: norsk.api.media.StreamProgramJoinConfiguration initial_config = 1;
+     * @generated from field: norsk.api.media.StreamAlignConfiguration initial_config = 1;
      */
-    value: StreamProgramJoinConfiguration;
+    value: StreamAlignConfiguration;
     case: "initialConfig";
   } | {
     /**
@@ -17042,41 +17148,41 @@ export class StreamProgramJoinMessage extends Message<StreamProgramJoinMessage>
     case: "subscription";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<StreamProgramJoinMessage>) {
+  constructor(data?: PartialMessage<StreamAlignMessage>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.StreamProgramJoinMessage";
+  static readonly typeName = "norsk.api.media.StreamAlignMessage";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "initial_config", kind: "message", T: StreamProgramJoinConfiguration, oneof: "message" },
+    { no: 1, name: "initial_config", kind: "message", T: StreamAlignConfiguration, oneof: "message" },
     { no: 2, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamProgramJoinMessage {
-    return new StreamProgramJoinMessage().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamAlignMessage {
+    return new StreamAlignMessage().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamProgramJoinMessage {
-    return new StreamProgramJoinMessage().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamAlignMessage {
+    return new StreamAlignMessage().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamProgramJoinMessage {
-    return new StreamProgramJoinMessage().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamAlignMessage {
+    return new StreamAlignMessage().fromJsonString(jsonString, options);
   }
 
-  static equals(a: StreamProgramJoinMessage | PlainMessage<StreamProgramJoinMessage> | undefined, b: StreamProgramJoinMessage | PlainMessage<StreamProgramJoinMessage> | undefined): boolean {
-    return proto3.util.equals(StreamProgramJoinMessage, a, b);
+  static equals(a: StreamAlignMessage | PlainMessage<StreamAlignMessage> | undefined, b: StreamAlignMessage | PlainMessage<StreamAlignMessage> | undefined): boolean {
+    return proto3.util.equals(StreamAlignMessage, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.StreamProgramJoinEvent
+ * @generated from message norsk.api.media.StreamAlignEvent
  */
-export class StreamProgramJoinEvent extends Message<StreamProgramJoinEvent> {
+export class StreamAlignEvent extends Message<StreamAlignEvent> {
   /**
-   * @generated from oneof norsk.api.media.StreamProgramJoinEvent.message
+   * @generated from oneof norsk.api.media.StreamAlignEvent.message
    */
   message: {
     /**
@@ -17104,13 +17210,13 @@ export class StreamProgramJoinEvent extends Message<StreamProgramJoinEvent> {
     case: "inboundContext";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<StreamProgramJoinEvent>) {
+  constructor(data?: PartialMessage<StreamAlignEvent>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.StreamProgramJoinEvent";
+  static readonly typeName = "norsk.api.media.StreamAlignEvent";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
     { no: 2, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
@@ -17118,20 +17224,20 @@ export class StreamProgramJoinEvent extends Message<StreamProgramJoinEvent> {
     { no: 4, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamProgramJoinEvent {
-    return new StreamProgramJoinEvent().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamAlignEvent {
+    return new StreamAlignEvent().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamProgramJoinEvent {
-    return new StreamProgramJoinEvent().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamAlignEvent {
+    return new StreamAlignEvent().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamProgramJoinEvent {
-    return new StreamProgramJoinEvent().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamAlignEvent {
+    return new StreamAlignEvent().fromJsonString(jsonString, options);
   }
 
-  static equals(a: StreamProgramJoinEvent | PlainMessage<StreamProgramJoinEvent> | undefined, b: StreamProgramJoinEvent | PlainMessage<StreamProgramJoinEvent> | undefined): boolean {
-    return proto3.util.equals(StreamProgramJoinEvent, a, b);
+  static equals(a: StreamAlignEvent | PlainMessage<StreamAlignEvent> | undefined, b: StreamAlignEvent | PlainMessage<StreamAlignEvent> | undefined): boolean {
+    return proto3.util.equals(StreamAlignEvent, a, b);
   }
 }
 
@@ -17491,6 +17597,8 @@ export class StreamSwitchSmoothConfiguration extends Message<StreamSwitchSmoothC
   transitionDurationMs = 0;
 
   /**
+   * Resolution of the normalised output
+   *
    * @generated from field: norsk.api.media.Resolution output_resolution = 5;
    */
   outputResolution?: Resolution;
@@ -17502,6 +17610,27 @@ export class StreamSwitchSmoothConfiguration extends Message<StreamSwitchSmoothC
    */
   sampleRate = SampleRate.RATE_8000;
 
+  /**
+   * The frame rate of the output
+   *
+   * @generated from field: norsk.api.media.FrameRate frame_rate = 7;
+   */
+  frameRate?: FrameRate;
+
+  /**
+   * The channel layout of the output
+   *
+   * @generated from field: norsk.api.media.ChannelLayout channel_layout = 8;
+   */
+  channelLayout?: ChannelLayout;
+
+  /**
+   * Align all timestamps to minimise timestamp jitter on mixed streams
+   *
+   * @generated from field: norsk.api.media.StreamSwitchSmoothConfiguration.Alignment alignment = 9;
+   */
+  alignment = StreamSwitchSmoothConfiguration_Alignment.ALIGNED;
+
   constructor(data?: PartialMessage<StreamSwitchSmoothConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -17516,6 +17645,9 @@ export class StreamSwitchSmoothConfiguration extends Message<StreamSwitchSmoothC
     { no: 4, name: "transition_duration_ms", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 5, name: "output_resolution", kind: "message", T: Resolution },
     { no: 6, name: "sample_rate", kind: "enum", T: proto3.getEnumType(SampleRate) },
+    { no: 7, name: "frame_rate", kind: "message", T: FrameRate },
+    { no: 8, name: "channel_layout", kind: "message", T: ChannelLayout },
+    { no: 9, name: "alignment", kind: "enum", T: proto3.getEnumType(StreamSwitchSmoothConfiguration_Alignment) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchSmoothConfiguration {
@@ -17535,6 +17667,28 @@ export class StreamSwitchSmoothConfiguration extends Message<StreamSwitchSmoothC
   }
 }
 
+/**
+ * Whether to align all the incoming timestamps
+ *
+ * @generated from enum norsk.api.media.StreamSwitchSmoothConfiguration.Alignment
+ */
+export enum StreamSwitchSmoothConfiguration_Alignment {
+  /**
+   * @generated from enum value: ALIGNED = 0;
+   */
+  ALIGNED = 0,
+
+  /**
+   * @generated from enum value: NO_ALIGNMENT = 1;
+   */
+  NO_ALIGNMENT = 1,
+}
+// Retrieve enum metadata with: proto3.getEnumType(StreamSwitchSmoothConfiguration_Alignment)
+proto3.util.setEnumType(StreamSwitchSmoothConfiguration_Alignment, "norsk.api.media.StreamSwitchSmoothConfiguration.Alignment", [
+  { no: 0, name: "ALIGNED" },
+  { no: 1, name: "NO_ALIGNMENT" },
+]);
+
 /**
  * @generated from message norsk.api.media.StreamSwitchSmoothSwitch
  */
@@ -18280,51 +18434,6 @@ export class AudioMeasureLevelsMessage extends Message<AudioMeasureLevelsMessage
   }
 }
 
-/**
- * A time interval measured as ticks / (ticks per second)
- *
- * @generated from message norsk.api.media.Interval
- */
-export class Interval extends Message<Interval> {
-  /**
-   * @generated from field: uint32 n = 1;
-   */
-  n = 0;
-
-  /**
-   * @generated from field: uint32 d = 2;
-   */
-  d = 0;
-
-  constructor(data?: PartialMessage<Interval>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.Interval";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "n", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-    { no: 2, name: "d", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Interval {
-    return new Interval().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Interval {
-    return new Interval().fromJson(jsonValue, options);
-  }
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Interval {
-    return new Interval().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: Interval | PlainMessage<Interval> | undefined, b: Interval | PlainMessage<Interval> | undefined): boolean {
-    return proto3.util.equals(Interval, a, b);
-  }
-}
-
 /**
  * @generated from message norsk.api.media.Db
  */
@@ -18533,6 +18642,200 @@ export class AudioMeasureLevelsEvent extends Message<AudioMeasureLevelsEvent> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.StreamTimestampReportConfiguration
+ */
+export class StreamTimestampReportConfiguration extends Message<StreamTimestampReportConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  constructor(data?: PartialMessage<StreamTimestampReportConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamTimestampReportConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamTimestampReportConfiguration {
+    return new StreamTimestampReportConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamTimestampReportConfiguration {
+    return new StreamTimestampReportConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamTimestampReportConfiguration {
+    return new StreamTimestampReportConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamTimestampReportConfiguration | PlainMessage<StreamTimestampReportConfiguration> | undefined, b: StreamTimestampReportConfiguration | PlainMessage<StreamTimestampReportConfiguration> | undefined): boolean {
+    return proto3.util.equals(StreamTimestampReportConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.StreamTimestampReportMessage
+ */
+export class StreamTimestampReportMessage extends Message<StreamTimestampReportMessage> {
+  /**
+   * @generated from oneof norsk.api.media.StreamTimestampReportMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Subscription subscription = 1;
+     */
+    value: Subscription;
+    case: "subscription";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.StreamTimestampReportConfiguration configuration = 2;
+     */
+    value: StreamTimestampReportConfiguration;
+    case: "configuration";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<StreamTimestampReportMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamTimestampReportMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+    { no: 2, name: "configuration", kind: "message", T: StreamTimestampReportConfiguration, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamTimestampReportMessage {
+    return new StreamTimestampReportMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamTimestampReportMessage {
+    return new StreamTimestampReportMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamTimestampReportMessage {
+    return new StreamTimestampReportMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamTimestampReportMessage | PlainMessage<StreamTimestampReportMessage> | undefined, b: StreamTimestampReportMessage | PlainMessage<StreamTimestampReportMessage> | undefined): boolean {
+    return proto3.util.equals(StreamTimestampReportMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.StreamTimestampReport
+ */
+export class StreamTimestampReport extends Message<StreamTimestampReport> {
+  /**
+   * @generated from field: norsk.api.media.StreamKey stream = 1;
+   */
+  stream?: StreamKey;
+
+  /**
+   * @generated from field: norsk.api.media.Interval pts = 2;
+   */
+  pts?: Interval;
+
+  constructor(data?: PartialMessage<StreamTimestampReport>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamTimestampReport";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "stream", kind: "message", T: StreamKey },
+    { no: 2, name: "pts", kind: "message", T: Interval },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamTimestampReport {
+    return new StreamTimestampReport().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamTimestampReport {
+    return new StreamTimestampReport().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamTimestampReport {
+    return new StreamTimestampReport().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamTimestampReport | PlainMessage<StreamTimestampReport> | undefined, b: StreamTimestampReport | PlainMessage<StreamTimestampReport> | undefined): boolean {
+    return proto3.util.equals(StreamTimestampReport, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.StreamTimestampReportEvent
+ */
+export class StreamTimestampReportEvent extends Message<StreamTimestampReportEvent> {
+  /**
+   * @generated from oneof norsk.api.media.StreamTimestampReportEvent.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.MediaNodeId node_id = 1;
+     */
+    value: MediaNodeId;
+    case: "nodeId";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.StreamTimestampReport report = 2;
+     */
+    value: StreamTimestampReport;
+    case: "report";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 3;
+     */
+    value: SubscriptionResponse;
+    case: "subscriptionResponse";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context inbound_context = 4;
+     */
+    value: Context;
+    case: "inboundContext";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<StreamTimestampReportEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamTimestampReportEvent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
+    { no: 2, name: "report", kind: "message", T: StreamTimestampReport, oneof: "message" },
+    { no: 3, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
+    { no: 4, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamTimestampReportEvent {
+    return new StreamTimestampReportEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamTimestampReportEvent {
+    return new StreamTimestampReportEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamTimestampReportEvent {
+    return new StreamTimestampReportEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamTimestampReportEvent | PlainMessage<StreamTimestampReportEvent> | undefined, b: StreamTimestampReportEvent | PlainMessage<StreamTimestampReportEvent> | undefined): boolean {
+    return proto3.util.equals(StreamTimestampReportEvent, a, b);
+  }
+}
+
 /**
  * ///////////////////////////////
  * RTP Input