@norskvideo/norsk-api 1.0.335 → 1.0.336

package/lib/media_pb.ts

@@ -4,7 +4,7 @@
 // @ts-nocheck
 
 import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
-import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
+import { Empty, Message, proto3, protoInt64 } from "@bufbuild/protobuf";
 import { CurrentLoad, Log, Version } from "./shared/common_pb.js";
 
 /**
@@ -2421,6 +2421,14 @@ export class StreamMetadata extends Message<StreamMetadata> {
      */
     value: StreamMetadata_SubtitleMetadata;
     case: "subtitle";
+  } | {
+    /**
+     * Ancillary metadata
+     *
+     * @generated from field: norsk.api.media.StreamMetadata.AncillaryMetadata ancillary = 5;
+     */
+    value: StreamMetadata_AncillaryMetadata;
+    case: "ancillary";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<StreamMetadata>) {
@@ -2435,6 +2443,7 @@ export class StreamMetadata extends Message<StreamMetadata> {
     { no: 2, name: "audio", kind: "message", T: StreamMetadata_AudioMetadata, oneof: "message" },
     { 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" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadata {
@@ -2601,6 +2610,39 @@ export class StreamMetadata_SubtitleMetadata extends Message<StreamMetadata_Subt
   }
 }
 
+/**
+ * Metadata for an ancillary stream
+ *
+ * @generated from message norsk.api.media.StreamMetadata.AncillaryMetadata
+ */
+export class StreamMetadata_AncillaryMetadata extends Message<StreamMetadata_AncillaryMetadata> {
+  constructor(data?: PartialMessage<StreamMetadata_AncillaryMetadata>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamMetadata.AncillaryMetadata";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadata_AncillaryMetadata {
+    return new StreamMetadata_AncillaryMetadata().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamMetadata_AncillaryMetadata {
+    return new StreamMetadata_AncillaryMetadata().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamMetadata_AncillaryMetadata {
+    return new StreamMetadata_AncillaryMetadata().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamMetadata_AncillaryMetadata | PlainMessage<StreamMetadata_AncillaryMetadata> | undefined, b: StreamMetadata_AncillaryMetadata | PlainMessage<StreamMetadata_AncillaryMetadata> | undefined): boolean {
+    return proto3.util.equals(StreamMetadata_AncillaryMetadata, a, b);
+  }
+}
+
 /**
  * *
  * The Context message is sent from Norsk in response to a
@@ -4104,6 +4146,11 @@ export enum TsProgram_TsStreamType {
    * @generated from enum value: HEVC = 10;
    */
   HEVC = 10,
+
+  /**
+   * @generated from enum value: SCTE35 = 11;
+   */
+  SCTE35 = 11,
 }
 // Retrieve enum metadata with: proto3.getEnumType(TsProgram_TsStreamType)
 proto3.util.setEnumType(TsProgram_TsStreamType, "norsk.api.media.TsProgram.TsStreamType", [
@@ -4118,6 +4165,7 @@ proto3.util.setEnumType(TsProgram_TsStreamType, "norsk.api.media.TsProgram.TsStr
   { no: 8, name: "H264" },
   { no: 9, name: "UNKNOWN" },
   { no: 10, name: "HEVC" },
+  { no: 11, name: "SCTE35" },
 ]);
 
 /**
@@ -4391,6 +4439,43 @@ export class FileTsInputConfiguration extends Message<FileTsInputConfiguration>
   }
 }
 
+/**
+ * @generated from message norsk.api.media.FileTsInputConfigurationUpdate
+ */
+export class FileTsInputConfigurationUpdate extends Message<FileTsInputConfigurationUpdate> {
+  /**
+   * @generated from field: norsk.api.media.OptionalBool loop = 1;
+   */
+  loop?: OptionalBool;
+
+  constructor(data?: PartialMessage<FileTsInputConfigurationUpdate>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FileTsInputConfigurationUpdate";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "loop", kind: "message", T: OptionalBool },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileTsInputConfigurationUpdate {
+    return new FileTsInputConfigurationUpdate().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileTsInputConfigurationUpdate {
+    return new FileTsInputConfigurationUpdate().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileTsInputConfigurationUpdate {
+    return new FileTsInputConfigurationUpdate().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FileTsInputConfigurationUpdate | PlainMessage<FileTsInputConfigurationUpdate> | undefined, b: FileTsInputConfigurationUpdate | PlainMessage<FileTsInputConfigurationUpdate> | undefined): boolean {
+    return proto3.util.equals(FileTsInputConfigurationUpdate, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.FileTsInputMessage
  */
@@ -4410,6 +4495,12 @@ export class FileTsInputMessage extends Message<FileTsInputMessage> {
      */
     value: TimestampProgramNudge;
     case: "nudge";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.FileTsInputConfigurationUpdate update_config = 3;
+     */
+    value: FileTsInputConfigurationUpdate;
+    case: "updateConfig";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<FileTsInputMessage>) {
@@ -4422,6 +4513,7 @@ export class FileTsInputMessage extends Message<FileTsInputMessage> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "initial_config", kind: "message", T: FileTsInputConfiguration, oneof: "message" },
     { no: 2, name: "nudge", kind: "message", T: TimestampProgramNudge, oneof: "message" },
+    { no: 3, name: "update_config", kind: "message", T: FileTsInputConfigurationUpdate, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileTsInputMessage {
@@ -4441,49 +4533,6 @@ export class FileTsInputMessage extends Message<FileTsInputMessage> {
   }
 }
 
-/**
- * @generated from message norsk.api.media.FileTsInputEvent
- */
-export class FileTsInputEvent extends Message<FileTsInputEvent> {
-  /**
-   * @generated from oneof norsk.api.media.FileTsInputEvent.message
-   */
-  message: {
-    /**
-     * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 1;
-     */
-    value: MultiStreamStatistics;
-    case: "streamStatistics";
-  } | { case: undefined; value?: undefined } = { case: undefined };
-
-  constructor(data?: PartialMessage<FileTsInputEvent>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FileTsInputEvent";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileTsInputEvent {
-    return new FileTsInputEvent().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileTsInputEvent {
-    return new FileTsInputEvent().fromJson(jsonValue, options);
-  }
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileTsInputEvent {
-    return new FileTsInputEvent().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: FileTsInputEvent | PlainMessage<FileTsInputEvent> | undefined, b: FileTsInputEvent | PlainMessage<FileTsInputEvent> | undefined): boolean {
-    return proto3.util.equals(FileTsInputEvent, a, b);
-  }
-}
-
 /**
  * @generated from message norsk.api.media.FileWebVttInputConfiguration
  */
@@ -5223,49 +5272,6 @@ export class UdpTsInputMessage extends Message<UdpTsInputMessage> {
   }
 }
 
-/**
- * @generated from message norsk.api.media.UdpTsInputEvent
- */
-export class UdpTsInputEvent extends Message<UdpTsInputEvent> {
-  /**
-   * @generated from oneof norsk.api.media.UdpTsInputEvent.message
-   */
-  message: {
-    /**
-     * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 1;
-     */
-    value: MultiStreamStatistics;
-    case: "streamStatistics";
-  } | { case: undefined; value?: undefined } = { case: undefined };
-
-  constructor(data?: PartialMessage<UdpTsInputEvent>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.UdpTsInputEvent";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UdpTsInputEvent {
-    return new UdpTsInputEvent().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UdpTsInputEvent {
-    return new UdpTsInputEvent().fromJson(jsonValue, options);
-  }
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UdpTsInputEvent {
-    return new UdpTsInputEvent().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: UdpTsInputEvent | PlainMessage<UdpTsInputEvent> | undefined, b: UdpTsInputEvent | PlainMessage<UdpTsInputEvent> | undefined): boolean {
-    return proto3.util.equals(UdpTsInputEvent, a, b);
-  }
-}
-
 /**
  * @generated from message norsk.api.media.M3u8MediaInputConfiguration
  */
@@ -6109,6 +6115,43 @@ export class FileMp4InputConfiguration extends Message<FileMp4InputConfiguration
   }
 }
 
+/**
+ * @generated from message norsk.api.media.FileMp4InputConfigurationUpdate
+ */
+export class FileMp4InputConfigurationUpdate extends Message<FileMp4InputConfigurationUpdate> {
+  /**
+   * @generated from field: norsk.api.media.OptionalBool loop = 1;
+   */
+  loop?: OptionalBool;
+
+  constructor(data?: PartialMessage<FileMp4InputConfigurationUpdate>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FileMp4InputConfigurationUpdate";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "loop", kind: "message", T: OptionalBool },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputConfigurationUpdate {
+    return new FileMp4InputConfigurationUpdate().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputConfigurationUpdate {
+    return new FileMp4InputConfigurationUpdate().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputConfigurationUpdate {
+    return new FileMp4InputConfigurationUpdate().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FileMp4InputConfigurationUpdate | PlainMessage<FileMp4InputConfigurationUpdate> | undefined, b: FileMp4InputConfigurationUpdate | PlainMessage<FileMp4InputConfigurationUpdate> | undefined): boolean {
+    return proto3.util.equals(FileMp4InputConfigurationUpdate, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.FileMp4InputMessage
  */
@@ -6128,6 +6171,12 @@ export class FileMp4InputMessage extends Message<FileMp4InputMessage> {
      */
     value: TimestampNudge;
     case: "nudge";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.FileMp4InputConfigurationUpdate update_config = 3;
+     */
+    value: FileMp4InputConfigurationUpdate;
+    case: "updateConfig";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<FileMp4InputMessage>) {
@@ -6140,6 +6189,7 @@ export class FileMp4InputMessage extends Message<FileMp4InputMessage> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "initial_config", kind: "message", T: FileMp4InputConfiguration, oneof: "message" },
     { no: 2, name: "nudge", kind: "message", T: TimestampNudge, oneof: "message" },
+    { no: 3, name: "update_config", kind: "message", T: FileMp4InputConfigurationUpdate, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputMessage {
@@ -7000,10 +7050,21 @@ export class BrowserInputEvent extends Message<BrowserInputEvent> {
  */
 export class WebRtcIceServerConfiguration extends Message<WebRtcIceServerConfiguration> {
   /**
+   * 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;
    */
   servers: 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;
+   */
+  reportedServers: WebRtcIceServer[] = [];
+
   constructor(data?: PartialMessage<WebRtcIceServerConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -7013,6 +7074,7 @@ export class WebRtcIceServerConfiguration extends Message<WebRtcIceServerConfigu
   static readonly typeName = "norsk.api.media.WebRtcIceServerConfiguration";
   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 },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRtcIceServerConfiguration {
@@ -9173,21 +9235,31 @@ export class AudioSplitMultichannelEvent extends Message<AudioSplitMultichannelE
  */
 export class Mp4Encryption extends Message<Mp4Encryption> {
   /**
+   * The 16-byte key ID used to identify the key, hexadecimal or GUID encoded.
+   *
    * @generated from field: string encryption_key_id = 1;
    */
   encryptionKeyId = "";
 
   /**
+   * The 16-byte key used to encrypt the data, hexadecimal encoded.
+   *
    * @generated from field: string encryption_key = 2;
    */
   encryptionKey = "";
 
   /**
+   * The PSSH box(es) to include in the MP4, base64 encoded.
+   * This is typically given by the DRM provider.
+   *
    * @generated from field: string encryption_pssh = 3;
    */
   encryptionPssh = "";
 
   /**
+   * The common encryption scheme used to encrypt data, as per ISO/IEC
+   * 23001-7:2016.
+   *
    * @generated from field: norsk.api.media.Mp4Encryption.Mp4EncryptionScheme encryption_scheme = 4;
    */
   encryptionScheme = Mp4Encryption_Mp4EncryptionScheme.CBCS;
@@ -9228,11 +9300,18 @@ export class Mp4Encryption extends Message<Mp4Encryption> {
  */
 export enum Mp4Encryption_Mp4EncryptionScheme {
   /**
+   * Default: CBCS encryption scheme (AES-CBC 10% pattern encryption).
+   * Full-sample encryption for audio tracks, subsample encryption for video
+   * tracks.
+   *
    * @generated from enum value: MP4_ENCRYPTION_SCHEME_CBCS = 0;
    */
   CBCS = 0,
 
   /**
+   * CENC encryption scheme (AES-CTR). Full-sample encryption for audio
+   * tracks, subsample encryption for video tracks.
+   *
    * @generated from enum value: MP4_ENCRYPTION_SCHEME_CENC = 1;
    */
   CENC = 1,
@@ -9463,6 +9542,20 @@ export class CmafVideoConfiguration extends Message<CmafVideoConfiguration> {
    */
   destinations: CMAFDestination[] = [];
 
+  /**
+   * Directives to add to the m3u media playlist
+   *
+   * @generated from field: string m3u_additions = 8;
+   */
+  m3uAdditions = "";
+
+  /**
+   * XML fragment to add to the mpd Representation element
+   *
+   * @generated from field: string mpd_additions = 9;
+   */
+  mpdAdditions = "";
+
   constructor(data?: PartialMessage<CmafVideoConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -9478,6 +9571,8 @@ export class CmafVideoConfiguration extends Message<CmafVideoConfiguration> {
     { no: 5, name: "encryption", kind: "message", T: Mp4Encryption },
     { no: 6, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
     { no: 7, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
+    { no: 8, name: "m3u_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 9, name: "mpd_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafVideoConfiguration {
@@ -9583,6 +9678,20 @@ export class HlsTsVideoConfiguration extends Message<HlsTsVideoConfiguration> {
    */
   destinations: CMAFDestination[] = [];
 
+  /**
+   * Directives to add to the m3u media playlist
+   *
+   * @generated from field: string m3u_additions = 6;
+   */
+  m3uAdditions = "";
+
+  /**
+   * XML fragment to add to the mpd Representation element
+   *
+   * @generated from field: string mpd_additions = 7;
+   */
+  mpdAdditions = "";
+
   constructor(data?: PartialMessage<HlsTsVideoConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -9596,6 +9705,8 @@ export class HlsTsVideoConfiguration extends Message<HlsTsVideoConfiguration> {
     { no: 3, name: "delay_output_ms", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 4, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
     { no: 5, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
+    { no: 6, name: "m3u_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 7, name: "mpd_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsVideoConfiguration {
@@ -9711,6 +9822,20 @@ export class CmafAudioConfiguration extends Message<CmafAudioConfiguration> {
    */
   destinations: CMAFDestination[] = [];
 
+  /**
+   * Directives to add to the m3u media playlist
+   *
+   * @generated from field: string m3u_additions = 9;
+   */
+  m3uAdditions = "";
+
+  /**
+   * XML fragment to add to the mpd Representation element
+   *
+   * @generated from field: string mpd_additions = 10;
+   */
+  mpdAdditions = "";
+
   constructor(data?: PartialMessage<CmafAudioConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -9726,6 +9851,8 @@ export class CmafAudioConfiguration extends Message<CmafAudioConfiguration> {
     { no: 6, name: "encryption", kind: "message", T: Mp4Encryption },
     { no: 7, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
     { no: 8, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
+    { no: 9, name: "m3u_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 10, name: "mpd_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafAudioConfiguration {
@@ -9831,6 +9958,20 @@ export class HlsTsAudioConfiguration extends Message<HlsTsAudioConfiguration> {
    */
   destinations: CMAFDestination[] = [];
 
+  /**
+   * Directives to add to the m3u media playlist
+   *
+   * @generated from field: string m3u_additions = 6;
+   */
+  m3uAdditions = "";
+
+  /**
+   * XML fragment to add to the mpd Representation element
+   *
+   * @generated from field: string mpd_additions = 7;
+   */
+  mpdAdditions = "";
+
   constructor(data?: PartialMessage<HlsTsAudioConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -9844,6 +9985,8 @@ export class HlsTsAudioConfiguration extends Message<HlsTsAudioConfiguration> {
     { no: 3, name: "delay_output_ms", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 4, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
     { no: 5, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
+    { no: 6, name: "m3u_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 7, name: "mpd_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsAudioConfiguration {
@@ -10237,6 +10380,20 @@ export class CmafMasterConfiguration extends Message<CmafMasterConfiguration> {
    */
   destinations: CMAFDestination[] = [];
 
+  /**
+   * Directives to add to the m3u master playlist
+   *
+   * @generated from field: string m3u_additions = 5;
+   */
+  m3uAdditions = "";
+
+  /**
+   * XML fragment to add to the (top-level) MPD element
+   *
+   * @generated from field: string mpd_additions = 6;
+   */
+  mpdAdditions = "";
+
   constructor(data?: PartialMessage<CmafMasterConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -10249,6 +10406,8 @@ export class CmafMasterConfiguration extends Message<CmafMasterConfiguration> {
     { no: 2, name: "playlist_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
     { no: 4, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
+    { no: 5, name: "m3u_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 6, name: "mpd_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafMasterConfiguration {
@@ -10359,6 +10518,20 @@ export class HlsTsCombinedPushConfiguration extends Message<HlsTsCombinedPushCon
    */
   statsSampling?: StreamStatisticsSampling;
 
+  /**
+   * Directives to add to the m3u media playlists
+   *
+   * @generated from field: string m3u_additions = 7;
+   */
+  m3uAdditions = "";
+
+  /**
+   * XML fragment to add to the mpd Representation elements
+   *
+   * @generated from field: string mpd_additions = 8;
+   */
+  mpdAdditions = "";
+
   constructor(data?: PartialMessage<HlsTsCombinedPushConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -10373,6 +10546,8 @@ export class HlsTsCombinedPushConfiguration extends Message<HlsTsCombinedPushCon
     { no: 4, name: "delay_output_ms", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 5, name: "playlist_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 6, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 7, name: "m3u_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 8, name: "mpd_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsCombinedPushConfiguration {
@@ -10602,6 +10777,11 @@ export class UdpTsOutputConfiguration extends Message<UdpTsOutputConfiguration>
    */
   statsSampling?: StreamStatisticsSampling;
 
+  /**
+   * @generated from field: uint32 buffer_delay_ms = 6;
+   */
+  bufferDelayMs = 0;
+
   constructor(data?: PartialMessage<UdpTsOutputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -10615,6 +10795,7 @@ export class UdpTsOutputConfiguration extends Message<UdpTsOutputConfiguration>
     { no: 3, name: "destination_ip", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 4, name: "destination_port", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
     { no: 5, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 6, name: "buffer_delay_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UdpTsOutputConfiguration {
@@ -10787,6 +10968,11 @@ export class SrtOutputConfiguration extends Message<SrtOutputConfiguration> {
    */
   statsSampling?: StreamStatisticsSampling;
 
+  /**
+   * @generated from field: uint32 buffer_delay_ms = 9;
+   */
+  bufferDelayMs = 0;
+
   constructor(data?: PartialMessage<SrtOutputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -10802,6 +10988,7 @@ export class SrtOutputConfiguration extends Message<SrtOutputConfiguration> {
     { no: 6, name: "passphrase", kind: "message", T: OptionalString },
     { no: 7, name: "stream_id", kind: "message", T: OptionalString },
     { no: 8, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 9, name: "buffer_delay_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SrtOutputConfiguration {
@@ -10966,6 +11153,11 @@ export class WhipOutputConfiguration extends Message<WhipOutputConfiguration> {
    */
   statsSampling?: StreamStatisticsSampling;
 
+  /**
+   * @generated from field: uint32 buffer_delay_ms = 5;
+   */
+  bufferDelayMs = 0;
+
   constructor(data?: PartialMessage<WhipOutputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -10978,6 +11170,7 @@ export class WhipOutputConfiguration extends Message<WhipOutputConfiguration> {
     { no: 2, name: "uri", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "auth_header", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 4, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 5, name: "buffer_delay_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhipOutputConfiguration {
@@ -11132,6 +11325,11 @@ export class WebRTCBrowserDuplexConfiguration extends Message<WebRTCBrowserDuple
    */
   iceServerConfiguration?: WebRtcIceServerConfiguration;
 
+  /**
+   * @generated from field: uint32 buffer_delay_ms = 4;
+   */
+  bufferDelayMs = 0;
+
   constructor(data?: PartialMessage<WebRTCBrowserDuplexConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -11143,6 +11341,7 @@ export class WebRTCBrowserDuplexConfiguration extends Message<WebRTCBrowserDuple
     { 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: 4, name: "buffer_delay_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRTCBrowserDuplexConfiguration {
@@ -11304,6 +11503,11 @@ export class WhepOutputConfiguration extends Message<WhepOutputConfiguration> {
    */
   iceServerConfiguration?: WebRtcIceServerConfiguration;
 
+  /**
+   * @generated from field: uint32 buffer_delay_ms = 4;
+   */
+  bufferDelayMs = 0;
+
   constructor(data?: PartialMessage<WhepOutputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -11315,6 +11519,7 @@ export class WhepOutputConfiguration extends Message<WhepOutputConfiguration> {
     { 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: 4, name: "buffer_delay_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhepOutputConfiguration {
@@ -11467,6 +11672,11 @@ export class RtmpOutputConfiguration extends Message<RtmpOutputConfiguration> {
    */
   statsSampling?: StreamStatisticsSampling;
 
+  /**
+   * @generated from field: uint32 buffer_delay_ms = 4;
+   */
+  bufferDelayMs = 0;
+
   constructor(data?: PartialMessage<RtmpOutputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -11478,6 +11688,7 @@ export class RtmpOutputConfiguration extends Message<RtmpOutputConfiguration> {
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 4, name: "buffer_delay_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpOutputConfiguration {
@@ -12122,6 +12333,43 @@ export class OptionalInt extends Message<OptionalInt> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.OptionalInt64
+ */
+export class OptionalInt64 extends Message<OptionalInt64> {
+  /**
+   * @generated from field: uint64 value = 1;
+   */
+  value = protoInt64.zero;
+
+  constructor(data?: PartialMessage<OptionalInt64>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.OptionalInt64";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "value", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OptionalInt64 {
+    return new OptionalInt64().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OptionalInt64 {
+    return new OptionalInt64().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OptionalInt64 {
+    return new OptionalInt64().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: OptionalInt64 | PlainMessage<OptionalInt64> | undefined, b: OptionalInt64 | PlainMessage<OptionalInt64> | undefined): boolean {
+    return proto3.util.equals(OptionalInt64, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.OptionalBool
  */
@@ -14511,6 +14759,11 @@ export class StreamChaosMonkeyConfiguration extends Message<StreamChaosMonkeyCon
     case: "everyOther";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
+  /**
+   * @generated from field: uint32 jitter_ms = 4;
+   */
+  jitterMs = 0;
+
   constructor(data?: PartialMessage<StreamChaosMonkeyConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -14522,6 +14775,7 @@ export class StreamChaosMonkeyConfiguration extends Message<StreamChaosMonkeyCon
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "random", kind: "scalar", T: 2 /* ScalarType.FLOAT */, oneof: "dropFramesMode" },
     { no: 3, name: "everyOther", kind: "scalar", T: 13 /* ScalarType.UINT32 */, oneof: "dropFramesMode" },
+    { no: 4, name: "jitter_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamChaosMonkeyConfiguration {
@@ -15206,39 +15460,189 @@ export class StreamMetadataOverrideEvent extends Message<StreamMetadataOverrideE
 }
 
 /**
- * @generated from message norsk.api.media.StreamSyncConfiguration
+ * @generated from message norsk.api.media.JitterBufferConfiguration
  */
-export class StreamSyncConfiguration extends Message<StreamSyncConfiguration> {
+export class JitterBufferConfiguration extends Message<JitterBufferConfiguration> {
   /**
    * @generated from field: norsk.api.media.MediaNodeId id = 1;
    */
   id?: MediaNodeId;
 
-  constructor(data?: PartialMessage<StreamSyncConfiguration>) {
+  /**
+   * @generated from field: uint32 delay_ms = 2;
+   */
+  delayMs = 0;
+
+  constructor(data?: PartialMessage<JitterBufferConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.StreamSyncConfiguration";
+  static readonly typeName = "norsk.api.media.JitterBufferConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "delay_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSyncConfiguration {
-    return new StreamSyncConfiguration().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JitterBufferConfiguration {
+    return new JitterBufferConfiguration().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSyncConfiguration {
-    return new StreamSyncConfiguration().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JitterBufferConfiguration {
+    return new JitterBufferConfiguration().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSyncConfiguration {
-    return new StreamSyncConfiguration().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JitterBufferConfiguration {
+    return new JitterBufferConfiguration().fromJsonString(jsonString, options);
   }
 
-  static equals(a: StreamSyncConfiguration | PlainMessage<StreamSyncConfiguration> | undefined, b: StreamSyncConfiguration | PlainMessage<StreamSyncConfiguration> | undefined): boolean {
-    return proto3.util.equals(StreamSyncConfiguration, a, b);
+  static equals(a: JitterBufferConfiguration | PlainMessage<JitterBufferConfiguration> | undefined, b: JitterBufferConfiguration | PlainMessage<JitterBufferConfiguration> | undefined): boolean {
+    return proto3.util.equals(JitterBufferConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.JitterBufferMessage
+ */
+export class JitterBufferMessage extends Message<JitterBufferMessage> {
+  /**
+   * @generated from oneof norsk.api.media.JitterBufferMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.JitterBufferConfiguration initial_config = 1;
+     */
+    value: JitterBufferConfiguration;
+    case: "initialConfig";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Subscription subscription = 2;
+     */
+    value: Subscription;
+    case: "subscription";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<JitterBufferMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.JitterBufferMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "initial_config", kind: "message", T: JitterBufferConfiguration, oneof: "message" },
+    { no: 2, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JitterBufferMessage {
+    return new JitterBufferMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JitterBufferMessage {
+    return new JitterBufferMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JitterBufferMessage {
+    return new JitterBufferMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: JitterBufferMessage | PlainMessage<JitterBufferMessage> | undefined, b: JitterBufferMessage | PlainMessage<JitterBufferMessage> | undefined): boolean {
+    return proto3.util.equals(JitterBufferMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.JitterBufferEvent
+ */
+export class JitterBufferEvent extends Message<JitterBufferEvent> {
+  /**
+   * @generated from oneof norsk.api.media.JitterBufferEvent.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.MediaNodeId node_id = 1;
+     */
+    value: MediaNodeId;
+    case: "nodeId";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context outbound_context = 2;
+     */
+    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<JitterBufferEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.JitterBufferEvent";
+  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>): JitterBufferEvent {
+    return new JitterBufferEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JitterBufferEvent {
+    return new JitterBufferEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JitterBufferEvent {
+    return new JitterBufferEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: JitterBufferEvent | PlainMessage<JitterBufferEvent> | undefined, b: JitterBufferEvent | PlainMessage<JitterBufferEvent> | undefined): boolean {
+    return proto3.util.equals(JitterBufferEvent, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.StreamSyncConfiguration
+ */
+export class StreamSyncConfiguration extends Message<StreamSyncConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  constructor(data?: PartialMessage<StreamSyncConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamSyncConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSyncConfiguration {
+    return new StreamSyncConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSyncConfiguration {
+    return new StreamSyncConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSyncConfiguration {
+    return new StreamSyncConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamSyncConfiguration | PlainMessage<StreamSyncConfiguration> | undefined, b: StreamSyncConfiguration | PlainMessage<StreamSyncConfiguration> | undefined): boolean {
+    return proto3.util.equals(StreamSyncConfiguration, a, b);
   }
 }
 
@@ -15914,8 +16318,9 @@ export class StreamSwitchSmoothEvent extends Message<StreamSwitchSmoothEvent> {
     case: "switchError";
   } | {
     /**
-     * Message sent when inbound context changes on some input; presence of an input in this message means that
-     * media has arrived and is ready to switch immediately
+     * Message sent when inbound context changes on some input; presence of an
+     * input in this message means that media has arrived and is ready to switch
+     * immediately
      *
      * @generated from field: norsk.api.media.MultipleContext inbound_context = 5;
      */
@@ -17423,6 +17828,1633 @@ export class AudioTranscribeAwsEvent extends Message<AudioTranscribeAwsEvent> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.AncillaryConfiguration
+ */
+export class AncillaryConfiguration extends Message<AncillaryConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  constructor(data?: PartialMessage<AncillaryConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AncillaryConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AncillaryConfiguration {
+    return new AncillaryConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AncillaryConfiguration {
+    return new AncillaryConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AncillaryConfiguration {
+    return new AncillaryConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AncillaryConfiguration | PlainMessage<AncillaryConfiguration> | undefined, b: AncillaryConfiguration | PlainMessage<AncillaryConfiguration> | undefined): boolean {
+    return proto3.util.equals(AncillaryConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.AncillaryMessage
+ */
+export class AncillaryMessage extends Message<AncillaryMessage> {
+  /**
+   * @generated from oneof norsk.api.media.AncillaryMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.AncillaryConfiguration initial_config = 1;
+     */
+    value: AncillaryConfiguration;
+    case: "initialConfig";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Subscription subscription = 2;
+     */
+    value: Subscription;
+    case: "subscription";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35Event scte35_event = 3;
+     */
+    value: Scte35Event;
+    case: "scte35Event";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<AncillaryMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AncillaryMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "initial_config", kind: "message", T: AncillaryConfiguration, oneof: "message" },
+    { no: 2, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+    { no: 3, name: "scte35_event", kind: "message", T: Scte35Event, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AncillaryMessage {
+    return new AncillaryMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AncillaryMessage {
+    return new AncillaryMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AncillaryMessage {
+    return new AncillaryMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AncillaryMessage | PlainMessage<AncillaryMessage> | undefined, b: AncillaryMessage | PlainMessage<AncillaryMessage> | undefined): boolean {
+    return proto3.util.equals(AncillaryMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.AncillaryEvent
+ */
+export class AncillaryEvent extends Message<AncillaryEvent> {
+  /**
+   * @generated from oneof norsk.api.media.AncillaryEvent.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.MediaNodeId node_id = 1;
+     */
+    value: MediaNodeId;
+    case: "nodeId";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context outbound_context = 2;
+     */
+    value: Context;
+    case: "outboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 3;
+     */
+    value: SubscriptionResponse;
+    case: "subscriptionResponse";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35Event scte35_event = 4;
+     */
+    value: Scte35Event;
+    case: "scte35Event";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<AncillaryEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AncillaryEvent";
+  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" },
+    { no: 4, name: "scte35_event", kind: "message", T: Scte35Event, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AncillaryEvent {
+    return new AncillaryEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AncillaryEvent {
+    return new AncillaryEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AncillaryEvent {
+    return new AncillaryEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AncillaryEvent | PlainMessage<AncillaryEvent> | undefined, b: AncillaryEvent | PlainMessage<AncillaryEvent> | undefined): boolean {
+    return proto3.util.equals(AncillaryEvent, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35Event
+ */
+export class Scte35Event extends Message<Scte35Event> {
+  /**
+   * @generated from field: norsk.api.media.StreamKey stream = 1;
+   */
+  stream?: StreamKey;
+
+  /**
+   * @generated from field: norsk.api.media.Scte35SpliceInfoSection info = 2;
+   */
+  info?: Scte35SpliceInfoSection;
+
+  constructor(data?: PartialMessage<Scte35Event>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35Event";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "stream", kind: "message", T: StreamKey },
+    { no: 2, name: "info", kind: "message", T: Scte35SpliceInfoSection },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35Event {
+    return new Scte35Event().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35Event {
+    return new Scte35Event().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35Event {
+    return new Scte35Event().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35Event | PlainMessage<Scte35Event> | undefined, b: Scte35Event | PlainMessage<Scte35Event> | undefined): boolean {
+    return proto3.util.equals(Scte35Event, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35SpliceInfoSection
+ */
+export class Scte35SpliceInfoSection extends Message<Scte35SpliceInfoSection> {
+  /**
+   * @generated from field: uint32 sap_type = 1;
+   */
+  sapType = 0;
+
+  /**
+   * @generated from field: uint32 protocol_version = 2;
+   */
+  protocolVersion = 0;
+
+  /**
+   * @generated from field: bool encrypted_packet = 3;
+   */
+  encryptedPacket = false;
+
+  /**
+   * @generated from field: uint32 encryption_algorithm = 4;
+   */
+  encryptionAlgorithm = 0;
+
+  /**
+   * @generated from field: uint64 pts_adjustment = 5;
+   */
+  ptsAdjustment = protoInt64.zero;
+
+  /**
+   * @generated from field: uint32 cw_index = 6;
+   */
+  cwIndex = 0;
+
+  /**
+   * @generated from field: uint32 tier = 7;
+   */
+  tier = 0;
+
+  /**
+   * @generated from field: norsk.api.media.Scte35SpliceCommand splice_command = 8;
+   */
+  spliceCommand?: Scte35SpliceCommand;
+
+  /**
+   * @generated from field: repeated norsk.api.media.Scte35SpliceDescriptor descriptors = 9;
+   */
+  descriptors: Scte35SpliceDescriptor[] = [];
+
+  constructor(data?: PartialMessage<Scte35SpliceInfoSection>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35SpliceInfoSection";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "sap_type", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "protocol_version", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 3, name: "encrypted_packet", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 4, name: "encryption_algorithm", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 5, name: "pts_adjustment", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+    { no: 6, name: "cw_index", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 7, name: "tier", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 8, name: "splice_command", kind: "message", T: Scte35SpliceCommand },
+    { no: 9, name: "descriptors", kind: "message", T: Scte35SpliceDescriptor, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35SpliceInfoSection {
+    return new Scte35SpliceInfoSection().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35SpliceInfoSection {
+    return new Scte35SpliceInfoSection().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35SpliceInfoSection {
+    return new Scte35SpliceInfoSection().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35SpliceInfoSection | PlainMessage<Scte35SpliceInfoSection> | undefined, b: Scte35SpliceInfoSection | PlainMessage<Scte35SpliceInfoSection> | undefined): boolean {
+    return proto3.util.equals(Scte35SpliceInfoSection, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35SpliceCommand
+ */
+export class Scte35SpliceCommand extends Message<Scte35SpliceCommand> {
+  /**
+   * @generated from oneof norsk.api.media.Scte35SpliceCommand.message
+   */
+  message: {
+    /**
+     * @generated from field: google.protobuf.Empty null = 1;
+     */
+    value: Empty;
+    case: "null";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35ScheduleCommand schedule = 2;
+     */
+    value: Scte35ScheduleCommand;
+    case: "schedule";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35InsertCommand insert = 3;
+     */
+    value: Scte35InsertCommand;
+    case: "insert";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35TimeSignalCommand time_signal = 4;
+     */
+    value: Scte35TimeSignalCommand;
+    case: "timeSignal";
+  } | {
+    /**
+     * @generated from field: google.protobuf.Empty bandwidth_reservation = 5;
+     */
+    value: Empty;
+    case: "bandwidthReservation";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35PrivateCommand private_command = 6;
+     */
+    value: Scte35PrivateCommand;
+    case: "privateCommand";
+  } | {
+    /**
+     * @generated from field: uint32 reserved = 7;
+     */
+    value: number;
+    case: "reserved";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<Scte35SpliceCommand>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35SpliceCommand";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "null", kind: "message", T: Empty, oneof: "message" },
+    { no: 2, name: "schedule", kind: "message", T: Scte35ScheduleCommand, oneof: "message" },
+    { no: 3, name: "insert", kind: "message", T: Scte35InsertCommand, oneof: "message" },
+    { no: 4, name: "time_signal", kind: "message", T: Scte35TimeSignalCommand, oneof: "message" },
+    { no: 5, name: "bandwidth_reservation", kind: "message", T: Empty, oneof: "message" },
+    { no: 6, name: "private_command", kind: "message", T: Scte35PrivateCommand, oneof: "message" },
+    { no: 7, name: "reserved", kind: "scalar", T: 13 /* ScalarType.UINT32 */, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35SpliceCommand {
+    return new Scte35SpliceCommand().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35SpliceCommand {
+    return new Scte35SpliceCommand().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35SpliceCommand {
+    return new Scte35SpliceCommand().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35SpliceCommand | PlainMessage<Scte35SpliceCommand> | undefined, b: Scte35SpliceCommand | PlainMessage<Scte35SpliceCommand> | undefined): boolean {
+    return proto3.util.equals(Scte35SpliceCommand, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35TimeSignalCommand
+ */
+export class Scte35TimeSignalCommand extends Message<Scte35TimeSignalCommand> {
+  /**
+   * @generated from field: norsk.api.media.Scte35SpliceTime splice_time = 1;
+   */
+  spliceTime?: Scte35SpliceTime;
+
+  constructor(data?: PartialMessage<Scte35TimeSignalCommand>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35TimeSignalCommand";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "splice_time", kind: "message", T: Scte35SpliceTime },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35TimeSignalCommand {
+    return new Scte35TimeSignalCommand().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35TimeSignalCommand {
+    return new Scte35TimeSignalCommand().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35TimeSignalCommand {
+    return new Scte35TimeSignalCommand().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35TimeSignalCommand | PlainMessage<Scte35TimeSignalCommand> | undefined, b: Scte35TimeSignalCommand | PlainMessage<Scte35TimeSignalCommand> | undefined): boolean {
+    return proto3.util.equals(Scte35TimeSignalCommand, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35InsertCommand
+ */
+export class Scte35InsertCommand extends Message<Scte35InsertCommand> {
+  /**
+   * @generated from field: uint32 splice_event_id = 1;
+   */
+  spliceEventId = 0;
+
+  /**
+   * @generated from field: bool splice_event_cancel_indicator = 2;
+   */
+  spliceEventCancelIndicator = false;
+
+  /**
+   * @generated from field: bool out_of_network_indicator = 3;
+   */
+  outOfNetworkIndicator = false;
+
+  /**
+   * @generated from field: bool splice_immediate_flag = 4;
+   */
+  spliceImmediateFlag = false;
+
+  /**
+   * @generated from field: norsk.api.media.Scte35InsertCommandMode mode = 5;
+   */
+  mode?: Scte35InsertCommandMode;
+
+  /**
+   * @generated from field: norsk.api.media.Scte35BreakDuration break_duration = 6;
+   */
+  breakDuration?: Scte35BreakDuration;
+
+  /**
+   * @generated from field: uint32 unique_program_id = 7;
+   */
+  uniqueProgramId = 0;
+
+  /**
+   * @generated from field: uint32 avail_num = 8;
+   */
+  availNum = 0;
+
+  /**
+   * @generated from field: uint32 avails_expected = 9;
+   */
+  availsExpected = 0;
+
+  constructor(data?: PartialMessage<Scte35InsertCommand>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35InsertCommand";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "splice_event_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "splice_event_cancel_indicator", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 3, name: "out_of_network_indicator", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 4, name: "splice_immediate_flag", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 5, name: "mode", kind: "message", T: Scte35InsertCommandMode },
+    { no: 6, name: "break_duration", kind: "message", T: Scte35BreakDuration },
+    { no: 7, name: "unique_program_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 8, name: "avail_num", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 9, name: "avails_expected", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35InsertCommand {
+    return new Scte35InsertCommand().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35InsertCommand {
+    return new Scte35InsertCommand().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35InsertCommand {
+    return new Scte35InsertCommand().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35InsertCommand | PlainMessage<Scte35InsertCommand> | undefined, b: Scte35InsertCommand | PlainMessage<Scte35InsertCommand> | undefined): boolean {
+    return proto3.util.equals(Scte35InsertCommand, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35InsertCommandMode
+ */
+export class Scte35InsertCommandMode extends Message<Scte35InsertCommandMode> {
+  /**
+   * @generated from oneof norsk.api.media.Scte35InsertCommandMode.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Scte35InsertCommandMode.InsertProgram insert_program = 1;
+     */
+    value: Scte35InsertCommandMode_InsertProgram;
+    case: "insertProgram";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35InsertCommandMode.InsertComponent insert_component = 2;
+     */
+    value: Scte35InsertCommandMode_InsertComponent;
+    case: "insertComponent";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<Scte35InsertCommandMode>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35InsertCommandMode";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "insert_program", kind: "message", T: Scte35InsertCommandMode_InsertProgram, oneof: "message" },
+    { no: 2, name: "insert_component", kind: "message", T: Scte35InsertCommandMode_InsertComponent, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35InsertCommandMode {
+    return new Scte35InsertCommandMode().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35InsertCommandMode {
+    return new Scte35InsertCommandMode().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35InsertCommandMode {
+    return new Scte35InsertCommandMode().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35InsertCommandMode | PlainMessage<Scte35InsertCommandMode> | undefined, b: Scte35InsertCommandMode | PlainMessage<Scte35InsertCommandMode> | undefined): boolean {
+    return proto3.util.equals(Scte35InsertCommandMode, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35InsertCommandMode.InsertProgram
+ */
+export class Scte35InsertCommandMode_InsertProgram extends Message<Scte35InsertCommandMode_InsertProgram> {
+  /**
+   * @generated from field: norsk.api.media.Scte35SpliceTime splice_time = 1;
+   */
+  spliceTime?: Scte35SpliceTime;
+
+  constructor(data?: PartialMessage<Scte35InsertCommandMode_InsertProgram>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35InsertCommandMode.InsertProgram";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "splice_time", kind: "message", T: Scte35SpliceTime },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35InsertCommandMode_InsertProgram {
+    return new Scte35InsertCommandMode_InsertProgram().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35InsertCommandMode_InsertProgram {
+    return new Scte35InsertCommandMode_InsertProgram().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35InsertCommandMode_InsertProgram {
+    return new Scte35InsertCommandMode_InsertProgram().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35InsertCommandMode_InsertProgram | PlainMessage<Scte35InsertCommandMode_InsertProgram> | undefined, b: Scte35InsertCommandMode_InsertProgram | PlainMessage<Scte35InsertCommandMode_InsertProgram> | undefined): boolean {
+    return proto3.util.equals(Scte35InsertCommandMode_InsertProgram, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35InsertCommandMode.InsertComponent
+ */
+export class Scte35InsertCommandMode_InsertComponent extends Message<Scte35InsertCommandMode_InsertComponent> {
+  /**
+   * @generated from field: repeated norsk.api.media.Scte35InsertCommandComponent components = 1;
+   */
+  components: Scte35InsertCommandComponent[] = [];
+
+  constructor(data?: PartialMessage<Scte35InsertCommandMode_InsertComponent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35InsertCommandMode.InsertComponent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "components", kind: "message", T: Scte35InsertCommandComponent, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35InsertCommandMode_InsertComponent {
+    return new Scte35InsertCommandMode_InsertComponent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35InsertCommandMode_InsertComponent {
+    return new Scte35InsertCommandMode_InsertComponent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35InsertCommandMode_InsertComponent {
+    return new Scte35InsertCommandMode_InsertComponent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35InsertCommandMode_InsertComponent | PlainMessage<Scte35InsertCommandMode_InsertComponent> | undefined, b: Scte35InsertCommandMode_InsertComponent | PlainMessage<Scte35InsertCommandMode_InsertComponent> | undefined): boolean {
+    return proto3.util.equals(Scte35InsertCommandMode_InsertComponent, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35InsertCommandComponent
+ */
+export class Scte35InsertCommandComponent extends Message<Scte35InsertCommandComponent> {
+  /**
+   * @generated from field: uint32 component_tag = 1;
+   */
+  componentTag = 0;
+
+  /**
+   * @generated from field: norsk.api.media.Scte35SpliceTime splice_time = 2;
+   */
+  spliceTime?: Scte35SpliceTime;
+
+  constructor(data?: PartialMessage<Scte35InsertCommandComponent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35InsertCommandComponent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "component_tag", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "splice_time", kind: "message", T: Scte35SpliceTime },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35InsertCommandComponent {
+    return new Scte35InsertCommandComponent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35InsertCommandComponent {
+    return new Scte35InsertCommandComponent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35InsertCommandComponent {
+    return new Scte35InsertCommandComponent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35InsertCommandComponent | PlainMessage<Scte35InsertCommandComponent> | undefined, b: Scte35InsertCommandComponent | PlainMessage<Scte35InsertCommandComponent> | undefined): boolean {
+    return proto3.util.equals(Scte35InsertCommandComponent, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35SpliceTime
+ */
+export class Scte35SpliceTime extends Message<Scte35SpliceTime> {
+  /**
+   * @generated from field: norsk.api.media.OptionalInt pts_time = 1;
+   */
+  ptsTime?: OptionalInt;
+
+  constructor(data?: PartialMessage<Scte35SpliceTime>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35SpliceTime";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "pts_time", kind: "message", T: OptionalInt },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35SpliceTime {
+    return new Scte35SpliceTime().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35SpliceTime {
+    return new Scte35SpliceTime().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35SpliceTime {
+    return new Scte35SpliceTime().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35SpliceTime | PlainMessage<Scte35SpliceTime> | undefined, b: Scte35SpliceTime | PlainMessage<Scte35SpliceTime> | undefined): boolean {
+    return proto3.util.equals(Scte35SpliceTime, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35BreakDuration
+ */
+export class Scte35BreakDuration extends Message<Scte35BreakDuration> {
+  /**
+   * @generated from field: bool auto_return = 1;
+   */
+  autoReturn = false;
+
+  /**
+   * @generated from field: uint64 duration = 2;
+   */
+  duration = protoInt64.zero;
+
+  constructor(data?: PartialMessage<Scte35BreakDuration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35BreakDuration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "auto_return", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 2, name: "duration", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35BreakDuration {
+    return new Scte35BreakDuration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35BreakDuration {
+    return new Scte35BreakDuration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35BreakDuration {
+    return new Scte35BreakDuration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35BreakDuration | PlainMessage<Scte35BreakDuration> | undefined, b: Scte35BreakDuration | PlainMessage<Scte35BreakDuration> | undefined): boolean {
+    return proto3.util.equals(Scte35BreakDuration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35PrivateCommand
+ */
+export class Scte35PrivateCommand extends Message<Scte35PrivateCommand> {
+  /**
+   * @generated from field: uint32 identifier = 1;
+   */
+  identifier = 0;
+
+  /**
+   * @generated from field: bytes private_bytes = 2;
+   */
+  privateBytes = new Uint8Array(0);
+
+  constructor(data?: PartialMessage<Scte35PrivateCommand>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35PrivateCommand";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "identifier", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "private_bytes", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35PrivateCommand {
+    return new Scte35PrivateCommand().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35PrivateCommand {
+    return new Scte35PrivateCommand().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35PrivateCommand {
+    return new Scte35PrivateCommand().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35PrivateCommand | PlainMessage<Scte35PrivateCommand> | undefined, b: Scte35PrivateCommand | PlainMessage<Scte35PrivateCommand> | undefined): boolean {
+    return proto3.util.equals(Scte35PrivateCommand, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35ScheduleCommand
+ */
+export class Scte35ScheduleCommand extends Message<Scte35ScheduleCommand> {
+  /**
+   * @generated from field: repeated norsk.api.media.Scte35ScheduleItem items = 1;
+   */
+  items: Scte35ScheduleItem[] = [];
+
+  constructor(data?: PartialMessage<Scte35ScheduleCommand>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35ScheduleCommand";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "items", kind: "message", T: Scte35ScheduleItem, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35ScheduleCommand {
+    return new Scte35ScheduleCommand().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35ScheduleCommand {
+    return new Scte35ScheduleCommand().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35ScheduleCommand {
+    return new Scte35ScheduleCommand().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35ScheduleCommand | PlainMessage<Scte35ScheduleCommand> | undefined, b: Scte35ScheduleCommand | PlainMessage<Scte35ScheduleCommand> | undefined): boolean {
+    return proto3.util.equals(Scte35ScheduleCommand, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35ScheduleItem
+ */
+export class Scte35ScheduleItem extends Message<Scte35ScheduleItem> {
+  /**
+   * @generated from field: uint32 splice_event_id = 1;
+   */
+  spliceEventId = 0;
+
+  /**
+   * @generated from field: bool splice_event_cancel_indicator = 2;
+   */
+  spliceEventCancelIndicator = false;
+
+  /**
+   * @generated from field: bool out_of_network_indicator = 3;
+   */
+  outOfNetworkIndicator = false;
+
+  /**
+   * @generated from field: norsk.api.media.Scte35ScheduleCommandMode mode = 4;
+   */
+  mode?: Scte35ScheduleCommandMode;
+
+  /**
+   * @generated from field: norsk.api.media.Scte35BreakDuration break_duration = 5;
+   */
+  breakDuration?: Scte35BreakDuration;
+
+  /**
+   * @generated from field: uint32 unique_program_id = 6;
+   */
+  uniqueProgramId = 0;
+
+  /**
+   * @generated from field: uint32 avail_num = 7;
+   */
+  availNum = 0;
+
+  /**
+   * @generated from field: uint32 avails_expected = 8;
+   */
+  availsExpected = 0;
+
+  constructor(data?: PartialMessage<Scte35ScheduleItem>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35ScheduleItem";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "splice_event_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "splice_event_cancel_indicator", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 3, name: "out_of_network_indicator", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 4, name: "mode", kind: "message", T: Scte35ScheduleCommandMode },
+    { no: 5, name: "break_duration", kind: "message", T: Scte35BreakDuration },
+    { no: 6, name: "unique_program_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 7, name: "avail_num", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 8, name: "avails_expected", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35ScheduleItem {
+    return new Scte35ScheduleItem().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35ScheduleItem {
+    return new Scte35ScheduleItem().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35ScheduleItem {
+    return new Scte35ScheduleItem().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35ScheduleItem | PlainMessage<Scte35ScheduleItem> | undefined, b: Scte35ScheduleItem | PlainMessage<Scte35ScheduleItem> | undefined): boolean {
+    return proto3.util.equals(Scte35ScheduleItem, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35ScheduleCommandMode
+ */
+export class Scte35ScheduleCommandMode extends Message<Scte35ScheduleCommandMode> {
+  /**
+   * @generated from oneof norsk.api.media.Scte35ScheduleCommandMode.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Scte35ScheduleCommandMode.ScheduleProgram schedule_program = 1;
+     */
+    value: Scte35ScheduleCommandMode_ScheduleProgram;
+    case: "scheduleProgram";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35ScheduleCommandMode.ScheduleComponent schedule_component = 2;
+     */
+    value: Scte35ScheduleCommandMode_ScheduleComponent;
+    case: "scheduleComponent";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<Scte35ScheduleCommandMode>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35ScheduleCommandMode";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "schedule_program", kind: "message", T: Scte35ScheduleCommandMode_ScheduleProgram, oneof: "message" },
+    { no: 2, name: "schedule_component", kind: "message", T: Scte35ScheduleCommandMode_ScheduleComponent, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35ScheduleCommandMode {
+    return new Scte35ScheduleCommandMode().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35ScheduleCommandMode {
+    return new Scte35ScheduleCommandMode().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35ScheduleCommandMode {
+    return new Scte35ScheduleCommandMode().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35ScheduleCommandMode | PlainMessage<Scte35ScheduleCommandMode> | undefined, b: Scte35ScheduleCommandMode | PlainMessage<Scte35ScheduleCommandMode> | undefined): boolean {
+    return proto3.util.equals(Scte35ScheduleCommandMode, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35ScheduleCommandMode.ScheduleProgram
+ */
+export class Scte35ScheduleCommandMode_ScheduleProgram extends Message<Scte35ScheduleCommandMode_ScheduleProgram> {
+  /**
+   * @generated from field: uint32 utc_splice_time = 1;
+   */
+  utcSpliceTime = 0;
+
+  constructor(data?: PartialMessage<Scte35ScheduleCommandMode_ScheduleProgram>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35ScheduleCommandMode.ScheduleProgram";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "utc_splice_time", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35ScheduleCommandMode_ScheduleProgram {
+    return new Scte35ScheduleCommandMode_ScheduleProgram().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35ScheduleCommandMode_ScheduleProgram {
+    return new Scte35ScheduleCommandMode_ScheduleProgram().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35ScheduleCommandMode_ScheduleProgram {
+    return new Scte35ScheduleCommandMode_ScheduleProgram().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35ScheduleCommandMode_ScheduleProgram | PlainMessage<Scte35ScheduleCommandMode_ScheduleProgram> | undefined, b: Scte35ScheduleCommandMode_ScheduleProgram | PlainMessage<Scte35ScheduleCommandMode_ScheduleProgram> | undefined): boolean {
+    return proto3.util.equals(Scte35ScheduleCommandMode_ScheduleProgram, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35ScheduleCommandMode.ScheduleComponent
+ */
+export class Scte35ScheduleCommandMode_ScheduleComponent extends Message<Scte35ScheduleCommandMode_ScheduleComponent> {
+  /**
+   * @generated from field: repeated norsk.api.media.Scte35ScheduleCommandComponent components = 1;
+   */
+  components: Scte35ScheduleCommandComponent[] = [];
+
+  constructor(data?: PartialMessage<Scte35ScheduleCommandMode_ScheduleComponent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35ScheduleCommandMode.ScheduleComponent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "components", kind: "message", T: Scte35ScheduleCommandComponent, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35ScheduleCommandMode_ScheduleComponent {
+    return new Scte35ScheduleCommandMode_ScheduleComponent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35ScheduleCommandMode_ScheduleComponent {
+    return new Scte35ScheduleCommandMode_ScheduleComponent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35ScheduleCommandMode_ScheduleComponent {
+    return new Scte35ScheduleCommandMode_ScheduleComponent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35ScheduleCommandMode_ScheduleComponent | PlainMessage<Scte35ScheduleCommandMode_ScheduleComponent> | undefined, b: Scte35ScheduleCommandMode_ScheduleComponent | PlainMessage<Scte35ScheduleCommandMode_ScheduleComponent> | undefined): boolean {
+    return proto3.util.equals(Scte35ScheduleCommandMode_ScheduleComponent, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35ScheduleCommandComponent
+ */
+export class Scte35ScheduleCommandComponent extends Message<Scte35ScheduleCommandComponent> {
+  /**
+   * @generated from field: uint32 component_tag = 1;
+   */
+  componentTag = 0;
+
+  /**
+   * @generated from field: uint32 utc_splice_time = 2;
+   */
+  utcSpliceTime = 0;
+
+  constructor(data?: PartialMessage<Scte35ScheduleCommandComponent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35ScheduleCommandComponent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "component_tag", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "utc_splice_time", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35ScheduleCommandComponent {
+    return new Scte35ScheduleCommandComponent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35ScheduleCommandComponent {
+    return new Scte35ScheduleCommandComponent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35ScheduleCommandComponent {
+    return new Scte35ScheduleCommandComponent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35ScheduleCommandComponent | PlainMessage<Scte35ScheduleCommandComponent> | undefined, b: Scte35ScheduleCommandComponent | PlainMessage<Scte35ScheduleCommandComponent> | undefined): boolean {
+    return proto3.util.equals(Scte35ScheduleCommandComponent, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35SpliceDescriptor
+ */
+export class Scte35SpliceDescriptor extends Message<Scte35SpliceDescriptor> {
+  /**
+   * @generated from oneof norsk.api.media.Scte35SpliceDescriptor.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Scte35AvailDescriptor avail = 1;
+     */
+    value: Scte35AvailDescriptor;
+    case: "avail";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35DtmfDescriptor dtmf = 2;
+     */
+    value: Scte35DtmfDescriptor;
+    case: "dtmf";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35SegmentationDescriptor segmentation = 3;
+     */
+    value: Scte35SegmentationDescriptor;
+    case: "segmentation";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35TimeDescriptor time = 4;
+     */
+    value: Scte35TimeDescriptor;
+    case: "time";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35AudioDescriptor audio = 5;
+     */
+    value: Scte35AudioDescriptor;
+    case: "audio";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Scte35GenericDescriptor reserved_other = 6;
+     */
+    value: Scte35GenericDescriptor;
+    case: "reservedOther";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<Scte35SpliceDescriptor>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35SpliceDescriptor";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "avail", kind: "message", T: Scte35AvailDescriptor, oneof: "message" },
+    { no: 2, name: "dtmf", kind: "message", T: Scte35DtmfDescriptor, oneof: "message" },
+    { no: 3, name: "segmentation", kind: "message", T: Scte35SegmentationDescriptor, oneof: "message" },
+    { no: 4, name: "time", kind: "message", T: Scte35TimeDescriptor, oneof: "message" },
+    { no: 5, name: "audio", kind: "message", T: Scte35AudioDescriptor, oneof: "message" },
+    { no: 6, name: "reserved_other", kind: "message", T: Scte35GenericDescriptor, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35SpliceDescriptor {
+    return new Scte35SpliceDescriptor().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35SpliceDescriptor {
+    return new Scte35SpliceDescriptor().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35SpliceDescriptor {
+    return new Scte35SpliceDescriptor().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35SpliceDescriptor | PlainMessage<Scte35SpliceDescriptor> | undefined, b: Scte35SpliceDescriptor | PlainMessage<Scte35SpliceDescriptor> | undefined): boolean {
+    return proto3.util.equals(Scte35SpliceDescriptor, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35GenericDescriptor
+ */
+export class Scte35GenericDescriptor extends Message<Scte35GenericDescriptor> {
+  /**
+   * @generated from field: uint32 identifier = 1;
+   */
+  identifier = 0;
+
+  /**
+   * @generated from field: uint32 splice_descriptor_tag = 2;
+   */
+  spliceDescriptorTag = 0;
+
+  /**
+   * @generated from field: bytes private_bytes = 3;
+   */
+  privateBytes = new Uint8Array(0);
+
+  constructor(data?: PartialMessage<Scte35GenericDescriptor>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35GenericDescriptor";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "identifier", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "splice_descriptor_tag", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 3, name: "private_bytes", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35GenericDescriptor {
+    return new Scte35GenericDescriptor().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35GenericDescriptor {
+    return new Scte35GenericDescriptor().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35GenericDescriptor {
+    return new Scte35GenericDescriptor().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35GenericDescriptor | PlainMessage<Scte35GenericDescriptor> | undefined, b: Scte35GenericDescriptor | PlainMessage<Scte35GenericDescriptor> | undefined): boolean {
+    return proto3.util.equals(Scte35GenericDescriptor, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35AvailDescriptor
+ */
+export class Scte35AvailDescriptor extends Message<Scte35AvailDescriptor> {
+  /**
+   * @generated from field: uint32 provider_avail_id = 1;
+   */
+  providerAvailId = 0;
+
+  constructor(data?: PartialMessage<Scte35AvailDescriptor>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35AvailDescriptor";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "provider_avail_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35AvailDescriptor {
+    return new Scte35AvailDescriptor().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35AvailDescriptor {
+    return new Scte35AvailDescriptor().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35AvailDescriptor {
+    return new Scte35AvailDescriptor().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35AvailDescriptor | PlainMessage<Scte35AvailDescriptor> | undefined, b: Scte35AvailDescriptor | PlainMessage<Scte35AvailDescriptor> | undefined): boolean {
+    return proto3.util.equals(Scte35AvailDescriptor, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35DtmfDescriptor
+ */
+export class Scte35DtmfDescriptor extends Message<Scte35DtmfDescriptor> {
+  /**
+   * @generated from field: uint32 preroll = 1;
+   */
+  preroll = 0;
+
+  /**
+   * @generated from field: bytes dtmf_chars = 2;
+   */
+  dtmfChars = new Uint8Array(0);
+
+  constructor(data?: PartialMessage<Scte35DtmfDescriptor>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35DtmfDescriptor";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "preroll", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "dtmf_chars", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35DtmfDescriptor {
+    return new Scte35DtmfDescriptor().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35DtmfDescriptor {
+    return new Scte35DtmfDescriptor().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35DtmfDescriptor {
+    return new Scte35DtmfDescriptor().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35DtmfDescriptor | PlainMessage<Scte35DtmfDescriptor> | undefined, b: Scte35DtmfDescriptor | PlainMessage<Scte35DtmfDescriptor> | undefined): boolean {
+    return proto3.util.equals(Scte35DtmfDescriptor, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35TimeDescriptor
+ */
+export class Scte35TimeDescriptor extends Message<Scte35TimeDescriptor> {
+  /**
+   * @generated from field: uint64 tai_seconds = 1;
+   */
+  taiSeconds = protoInt64.zero;
+
+  /**
+   * @generated from field: uint32 tai_ns = 2;
+   */
+  taiNs = 0;
+
+  /**
+   * @generated from field: uint32 utc_offset = 3;
+   */
+  utcOffset = 0;
+
+  constructor(data?: PartialMessage<Scte35TimeDescriptor>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35TimeDescriptor";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "tai_seconds", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+    { no: 2, name: "tai_ns", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 3, name: "utc_offset", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35TimeDescriptor {
+    return new Scte35TimeDescriptor().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35TimeDescriptor {
+    return new Scte35TimeDescriptor().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35TimeDescriptor {
+    return new Scte35TimeDescriptor().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35TimeDescriptor | PlainMessage<Scte35TimeDescriptor> | undefined, b: Scte35TimeDescriptor | PlainMessage<Scte35TimeDescriptor> | undefined): boolean {
+    return proto3.util.equals(Scte35TimeDescriptor, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35AudioDescriptor
+ */
+export class Scte35AudioDescriptor extends Message<Scte35AudioDescriptor> {
+  /**
+   * @generated from field: repeated norsk.api.media.Scte35AudioComponent components = 1;
+   */
+  components: Scte35AudioComponent[] = [];
+
+  constructor(data?: PartialMessage<Scte35AudioDescriptor>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35AudioDescriptor";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "components", kind: "message", T: Scte35AudioComponent, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35AudioDescriptor {
+    return new Scte35AudioDescriptor().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35AudioDescriptor {
+    return new Scte35AudioDescriptor().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35AudioDescriptor {
+    return new Scte35AudioDescriptor().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35AudioDescriptor | PlainMessage<Scte35AudioDescriptor> | undefined, b: Scte35AudioDescriptor | PlainMessage<Scte35AudioDescriptor> | undefined): boolean {
+    return proto3.util.equals(Scte35AudioDescriptor, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35AudioComponent
+ */
+export class Scte35AudioComponent extends Message<Scte35AudioComponent> {
+  /**
+   * @generated from field: uint32 component_tag = 1;
+   */
+  componentTag = 0;
+
+  /**
+   * @generated from field: uint32 iso_code = 2;
+   */
+  isoCode = 0;
+
+  /**
+   * @generated from field: uint32 bit_stream_mode = 3;
+   */
+  bitStreamMode = 0;
+
+  /**
+   * @generated from field: uint32 num_channels = 4;
+   */
+  numChannels = 0;
+
+  /**
+   * @generated from field: bool full_srvc_audio = 5;
+   */
+  fullSrvcAudio = false;
+
+  constructor(data?: PartialMessage<Scte35AudioComponent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35AudioComponent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "component_tag", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "iso_code", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 3, name: "bit_stream_mode", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 4, name: "num_channels", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 5, name: "full_srvc_audio", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35AudioComponent {
+    return new Scte35AudioComponent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35AudioComponent {
+    return new Scte35AudioComponent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35AudioComponent {
+    return new Scte35AudioComponent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35AudioComponent | PlainMessage<Scte35AudioComponent> | undefined, b: Scte35AudioComponent | PlainMessage<Scte35AudioComponent> | undefined): boolean {
+    return proto3.util.equals(Scte35AudioComponent, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35SegmentationDescriptor
+ */
+export class Scte35SegmentationDescriptor extends Message<Scte35SegmentationDescriptor> {
+  /**
+   * @generated from field: uint32 segmentation_event_id = 1;
+   */
+  segmentationEventId = 0;
+
+  /**
+   * @generated from field: bool segmentation_event_cancel_indicator = 2;
+   */
+  segmentationEventCancelIndicator = false;
+
+  /**
+   * @generated from field: bool program_segmentation_flag = 3;
+   */
+  programSegmentationFlag = false;
+
+  /**
+   * @generated from field: norsk.api.media.Scte35SegmentDeliveryRestrictions delivery_restrictions = 4;
+   */
+  deliveryRestrictions?: Scte35SegmentDeliveryRestrictions;
+
+  /**
+   * @generated from field: repeated norsk.api.media.Scte35SegmentationComponent components = 5;
+   */
+  components: Scte35SegmentationComponent[] = [];
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt64 segmentation_duration = 6;
+   */
+  segmentationDuration?: OptionalInt64;
+
+  /**
+   * @generated from field: uint32 segmentation_upid_type = 7;
+   */
+  segmentationUpidType = 0;
+
+  /**
+   * @generated from field: bytes segmentation_upid = 8;
+   */
+  segmentationUpid = new Uint8Array(0);
+
+  /**
+   * @generated from field: uint32 segmentation_type_id = 9;
+   */
+  segmentationTypeId = 0;
+
+  /**
+   * @generated from field: uint32 segment_num = 10;
+   */
+  segmentNum = 0;
+
+  /**
+   * @generated from field: uint32 segments_expected = 11;
+   */
+  segmentsExpected = 0;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt sub_segment_num = 12;
+   */
+  subSegmentNum?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.OptionalInt sub_segments_expected = 13;
+   */
+  subSegmentsExpected?: OptionalInt;
+
+  constructor(data?: PartialMessage<Scte35SegmentationDescriptor>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35SegmentationDescriptor";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "segmentation_event_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "segmentation_event_cancel_indicator", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 3, name: "program_segmentation_flag", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 4, name: "delivery_restrictions", kind: "message", T: Scte35SegmentDeliveryRestrictions },
+    { no: 5, name: "components", kind: "message", T: Scte35SegmentationComponent, repeated: true },
+    { no: 6, name: "segmentation_duration", kind: "message", T: OptionalInt64 },
+    { no: 7, name: "segmentation_upid_type", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 8, name: "segmentation_upid", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
+    { no: 9, name: "segmentation_type_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 10, name: "segment_num", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 11, name: "segments_expected", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 12, name: "sub_segment_num", kind: "message", T: OptionalInt },
+    { no: 13, name: "sub_segments_expected", kind: "message", T: OptionalInt },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35SegmentationDescriptor {
+    return new Scte35SegmentationDescriptor().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35SegmentationDescriptor {
+    return new Scte35SegmentationDescriptor().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35SegmentationDescriptor {
+    return new Scte35SegmentationDescriptor().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35SegmentationDescriptor | PlainMessage<Scte35SegmentationDescriptor> | undefined, b: Scte35SegmentationDescriptor | PlainMessage<Scte35SegmentationDescriptor> | undefined): boolean {
+    return proto3.util.equals(Scte35SegmentationDescriptor, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35SegmentDeliveryRestrictions
+ */
+export class Scte35SegmentDeliveryRestrictions extends Message<Scte35SegmentDeliveryRestrictions> {
+  /**
+   * @generated from field: bool web_delivery_allowed_flag = 1;
+   */
+  webDeliveryAllowedFlag = false;
+
+  /**
+   * @generated from field: bool no_regional_blackout_flag = 2;
+   */
+  noRegionalBlackoutFlag = false;
+
+  /**
+   * @generated from field: bool archive_allowed_flag = 3;
+   */
+  archiveAllowedFlag = false;
+
+  /**
+   * @generated from field: uint32 device_restrictions = 4;
+   */
+  deviceRestrictions = 0;
+
+  constructor(data?: PartialMessage<Scte35SegmentDeliveryRestrictions>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35SegmentDeliveryRestrictions";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "web_delivery_allowed_flag", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 2, name: "no_regional_blackout_flag", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 3, name: "archive_allowed_flag", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 4, name: "device_restrictions", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35SegmentDeliveryRestrictions {
+    return new Scte35SegmentDeliveryRestrictions().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35SegmentDeliveryRestrictions {
+    return new Scte35SegmentDeliveryRestrictions().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35SegmentDeliveryRestrictions {
+    return new Scte35SegmentDeliveryRestrictions().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35SegmentDeliveryRestrictions | PlainMessage<Scte35SegmentDeliveryRestrictions> | undefined, b: Scte35SegmentDeliveryRestrictions | PlainMessage<Scte35SegmentDeliveryRestrictions> | undefined): boolean {
+    return proto3.util.equals(Scte35SegmentDeliveryRestrictions, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Scte35SegmentationComponent
+ */
+export class Scte35SegmentationComponent extends Message<Scte35SegmentationComponent> {
+  /**
+   * @generated from field: uint32 component_tag = 1;
+   */
+  componentTag = 0;
+
+  /**
+   * @generated from field: uint64 pts_offset = 2;
+   */
+  ptsOffset = protoInt64.zero;
+
+  constructor(data?: PartialMessage<Scte35SegmentationComponent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Scte35SegmentationComponent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "component_tag", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "pts_offset", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scte35SegmentationComponent {
+    return new Scte35SegmentationComponent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scte35SegmentationComponent {
+    return new Scte35SegmentationComponent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scte35SegmentationComponent {
+    return new Scte35SegmentationComponent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Scte35SegmentationComponent | PlainMessage<Scte35SegmentationComponent> | undefined, b: Scte35SegmentationComponent | PlainMessage<Scte35SegmentationComponent> | undefined): boolean {
+    return proto3.util.equals(Scte35SegmentationComponent, a, b);
+  }
+}
+
 /**
  * ////////////////////////////////////////////////////////////////////////////
  * Hardware