@norskvideo/norsk-api 1.0.350 → 1.0.352

package/lib/media_pb.ts

@@ -2847,12 +2847,18 @@ export enum ValidationResponse_ContextValidationResponse {
    * @generated from enum value: CONTEXT_VALIDATION_ALLOW_AND_TERMINATE = 2;
    */
   CONTEXT_VALIDATION_ALLOW_AND_TERMINATE = 2,
+
+  /**
+   * @generated from enum value: CONTEXT_VALIDATION_DENY_AND_QUEUE = 3;
+   */
+  CONTEXT_VALIDATION_DENY_AND_QUEUE = 3,
 }
 // Retrieve enum metadata with: proto3.getEnumType(ValidationResponse_ContextValidationResponse)
 proto3.util.setEnumType(ValidationResponse_ContextValidationResponse, "norsk.api.media.ValidationResponse.ContextValidationResponse", [
   { no: 0, name: "CONTEXT_VALIDATION_DENY" },
   { no: 1, name: "CONTEXT_VALIDATION_ALLOW" },
   { no: 2, name: "CONTEXT_VALIDATION_ALLOW_AND_TERMINATE" },
+  { no: 3, name: "CONTEXT_VALIDATION_DENY_AND_QUEUE" },
 ]);
 
 /**
@@ -4599,6 +4605,11 @@ export enum TsProgram_TsStreamType {
    * @generated from enum value: SCTE35 = 11;
    */
   SCTE35 = 11,
+
+  /**
+   * @generated from enum value: PES_METADATA = 12;
+   */
+  PES_METADATA = 12,
 }
 // Retrieve enum metadata with: proto3.getEnumType(TsProgram_TsStreamType)
 proto3.util.setEnumType(TsProgram_TsStreamType, "norsk.api.media.TsProgram.TsStreamType", [
@@ -4614,6 +4625,7 @@ proto3.util.setEnumType(TsProgram_TsStreamType, "norsk.api.media.TsProgram.TsStr
   { no: 9, name: "UNKNOWN" },
   { no: 10, name: "HEVC" },
   { no: 11, name: "SCTE35" },
+  { no: 12, name: "PES_METADATA" },
 ]);
 
 /**
@@ -8303,7 +8315,7 @@ export class VideoComposeConfiguration extends Message<VideoComposeConfiguration
   /**
    * @generated from field: norsk.api.media.VideoComposeConfiguration.ComposeHardwareAcceleration hardware_acceleration = 8;
    */
-  hardwareAcceleration = VideoComposeConfiguration_ComposeHardwareAcceleration.NONE;
+  hardwareAcceleration = VideoComposeConfiguration_ComposeHardwareAcceleration.COMPOSE_NONE;
 
   constructor(data?: PartialMessage<VideoComposeConfiguration>) {
     super();
@@ -8345,25 +8357,25 @@ export class VideoComposeConfiguration extends Message<VideoComposeConfiguration
  */
 export enum VideoComposeConfiguration_ComposeHardwareAcceleration {
   /**
-   * @generated from enum value: NONE = 0;
+   * @generated from enum value: COMPOSE_NONE = 0;
    */
-  NONE = 0,
+  COMPOSE_NONE = 0,
 
   /**
-   * @generated from enum value: QUADRA = 1;
+   * @generated from enum value: COMPOSE_QUADRA = 1;
    */
-  QUADRA = 1,
+  COMPOSE_QUADRA = 1,
 
   /**
-   * @generated from enum value: NVIDIA = 2;
+   * @generated from enum value: COMPOSE_NVIDIA = 2;
    */
-  NVIDIA = 2,
+  COMPOSE_NVIDIA = 2,
 }
 // Retrieve enum metadata with: proto3.getEnumType(VideoComposeConfiguration_ComposeHardwareAcceleration)
 proto3.util.setEnumType(VideoComposeConfiguration_ComposeHardwareAcceleration, "norsk.api.media.VideoComposeConfiguration.ComposeHardwareAcceleration", [
-  { no: 0, name: "NONE" },
-  { no: 1, name: "QUADRA" },
-  { no: 2, name: "NVIDIA" },
+  { no: 0, name: "COMPOSE_NONE" },
+  { no: 1, name: "COMPOSE_QUADRA" },
+  { no: 2, name: "COMPOSE_NVIDIA" },
 ]);
 
 /**
@@ -8605,6 +8617,175 @@ export class TransitionComplete extends Message<TransitionComplete> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.MetadataCombineMessage
+ */
+export class MetadataCombineMessage extends Message<MetadataCombineMessage> {
+  /**
+   * @generated from oneof norsk.api.media.MetadataCombineMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Subscription subscription = 1;
+     */
+    value: Subscription;
+    case: "subscription";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.MetadataCombineConfiguration initial_config = 2;
+     */
+    value: MetadataCombineConfiguration;
+    case: "initialConfig";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<MetadataCombineMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MetadataCombineMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+    { no: 2, name: "initial_config", kind: "message", T: MetadataCombineConfiguration, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MetadataCombineMessage {
+    return new MetadataCombineMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MetadataCombineMessage {
+    return new MetadataCombineMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MetadataCombineMessage {
+    return new MetadataCombineMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MetadataCombineMessage | PlainMessage<MetadataCombineMessage> | undefined, b: MetadataCombineMessage | PlainMessage<MetadataCombineMessage> | undefined): boolean {
+    return proto3.util.equals(MetadataCombineMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.MetadataCombineConfiguration
+ */
+export class MetadataCombineConfiguration extends Message<MetadataCombineConfiguration> {
+  /**
+   * The Media Node Id
+   *
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * The stream key for the merged output metadata stream
+   *
+   * @generated from field: norsk.api.media.StreamKey stream_key = 2;
+   */
+  streamKey?: StreamKey;
+
+  /**
+   * Max delta to allow for sync purposes, may vary according to source offsets and message frequency
+   *
+   * @generated from field: norsk.api.common.OptionalInt max_sync_delta = 3;
+   */
+  maxSyncDelta?: OptionalInt;
+
+  constructor(data?: PartialMessage<MetadataCombineConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MetadataCombineConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "stream_key", kind: "message", T: StreamKey },
+    { no: 3, name: "max_sync_delta", kind: "message", T: OptionalInt },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MetadataCombineConfiguration {
+    return new MetadataCombineConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MetadataCombineConfiguration {
+    return new MetadataCombineConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MetadataCombineConfiguration {
+    return new MetadataCombineConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MetadataCombineConfiguration | PlainMessage<MetadataCombineConfiguration> | undefined, b: MetadataCombineConfiguration | PlainMessage<MetadataCombineConfiguration> | undefined): boolean {
+    return proto3.util.equals(MetadataCombineConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.MetadataCombineEvent
+ */
+export class MetadataCombineEvent extends Message<MetadataCombineEvent> {
+  /**
+   * @generated from oneof norsk.api.media.MetadataCombineEvent.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.MediaNodeId node_id = 1;
+     */
+    value: MediaNodeId;
+    case: "nodeId";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context inbound_context = 2;
+     */
+    value: Context;
+    case: "inboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context outbound_context = 3;
+     */
+    value: Context;
+    case: "outboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 4;
+     */
+    value: SubscriptionResponse;
+    case: "subscriptionResponse";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<MetadataCombineEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MetadataCombineEvent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
+    { no: 2, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
+    { no: 3, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
+    { no: 4, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MetadataCombineEvent {
+    return new MetadataCombineEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MetadataCombineEvent {
+    return new MetadataCombineEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MetadataCombineEvent {
+    return new MetadataCombineEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MetadataCombineEvent | PlainMessage<MetadataCombineEvent> | undefined, b: MetadataCombineEvent | PlainMessage<MetadataCombineEvent> | undefined): boolean {
+    return proto3.util.equals(MetadataCombineEvent, a, b);
+  }
+}
+
 /**
  * *
  * Describe an audio source with the output gain mapping for a mixer.
@@ -9563,6 +9744,11 @@ export class AudioBuildMultichannelConfiguration extends Message<AudioBuildMulti
    */
   channelList: StreamKey[] = [];
 
+  /**
+   * @generated from field: norsk.api.media.SampleRate sample_rate = 8;
+   */
+  sampleRate = SampleRate.RATE_8000;
+
   constructor(data?: PartialMessage<AudioBuildMultichannelConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -9578,6 +9764,7 @@ export class AudioBuildMultichannelConfiguration extends Message<AudioBuildMulti
     { no: 5, name: "output_rendition_name", kind: "message", T: RenditionName },
     { no: 6, name: "channel_layout", kind: "message", T: ChannelLayout },
     { no: 7, name: "channel_list", kind: "message", T: StreamKey, repeated: true },
+    { no: 8, name: "sample_rate", kind: "enum", T: proto3.getEnumType(SampleRate) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioBuildMultichannelConfiguration {
@@ -11021,7 +11208,8 @@ export class UpdateCredentials extends Message<UpdateCredentials> {
  */
 export class UpdateDestinationPlaylist extends Message<UpdateDestinationPlaylist> {
   /**
-   * TODO this doesn't have to be a list anymore, as we're only getting at most one update from the sdk
+   * TODO this doesn't have to be a list anymore, as we're only getting at most
+   * one update from the sdk
    *
    * @generated from field: repeated norsk.api.media.UpdatePlaylist playlists = 1;
    */
@@ -12151,6 +12339,11 @@ export class UdpTsOutputConfiguration extends Message<UdpTsOutputConfiguration>
    */
   rtpEncapsulate = false;
 
+  /**
+   * @generated from field: norsk.api.common.OptionalInt av_delay_ms = 8;
+   */
+  avDelayMs?: OptionalInt;
+
   constructor(data?: PartialMessage<UdpTsOutputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -12166,6 +12359,7 @@ export class UdpTsOutputConfiguration extends Message<UdpTsOutputConfiguration>
     { no: 5, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
     { no: 6, name: "buffer_delay_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
     { no: 7, name: "rtp_encapsulate", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 8, name: "av_delay_ms", kind: "message", T: OptionalInt },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UdpTsOutputConfiguration {
@@ -12343,6 +12537,11 @@ export class SrtOutputConfiguration extends Message<SrtOutputConfiguration> {
    */
   bufferDelayMs = 0;
 
+  /**
+   * @generated from field: norsk.api.common.OptionalInt av_delay_ms = 10;
+   */
+  avDelayMs?: OptionalInt;
+
   constructor(data?: PartialMessage<SrtOutputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -12359,6 +12558,7 @@ export class SrtOutputConfiguration extends Message<SrtOutputConfiguration> {
     { 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 */ },
+    { no: 10, name: "av_delay_ms", kind: "message", T: OptionalInt },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SrtOutputConfiguration {
@@ -13057,6 +13257,11 @@ export class RtmpOutputConfiguration extends Message<RtmpOutputConfiguration> {
    */
   retryConnectionTimeout = 0;
 
+  /**
+   * @generated from field: norsk.api.common.OptionalInt av_delay_ms = 7;
+   */
+  avDelayMs?: OptionalInt;
+
   constructor(data?: PartialMessage<RtmpOutputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -13071,6 +13276,7 @@ export class RtmpOutputConfiguration extends Message<RtmpOutputConfiguration> {
     { no: 4, name: "buffer_delay_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
     { no: 5, name: "ssl_options", kind: "message", T: SslClientOptions },
     { no: 6, name: "retry_connection_timeout", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 7, name: "av_delay_ms", kind: "message", T: OptionalInt },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpOutputConfiguration {
@@ -13293,6 +13499,11 @@ export class FileTsOutputConfiguration extends Message<FileTsOutputConfiguration
    */
   statsSampling?: StreamStatisticsSampling;
 
+  /**
+   * @generated from field: norsk.api.common.OptionalInt av_delay_ms = 4;
+   */
+  avDelayMs?: OptionalInt;
+
   constructor(data?: PartialMessage<FileTsOutputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -13304,6 +13515,7 @@ export class FileTsOutputConfiguration extends Message<FileTsOutputConfiguration
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 4, name: "av_delay_ms", kind: "message", T: OptionalInt },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileTsOutputConfiguration {
@@ -16066,6 +16278,65 @@ export class XilinxH264 extends Message<XilinxH264> {
    */
   level?: OptionalInt;
 
+  /**
+   * @generated from oneof norsk.api.media.XilinxH264.rateControl
+   */
+  rateControl: {
+    /**
+     * @generated from field: uint32 const_qp = 3;
+     */
+    value: number;
+    case: "constQp";
+  } | {
+    /**
+     * @generated from field: uint32 cbr = 4;
+     */
+    value: number;
+    case: "cbr";
+  } | {
+    /**
+     * @generated from field: uint32 vbr = 5;
+     */
+    value: number;
+    case: "vbr";
+  } | {
+    /**
+     * @generated from field: uint32 low_latency = 6;
+     */
+    value: number;
+    case: "lowLatency";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt lookahead_depth = 7;
+   */
+  lookaheadDepth?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt idr_period = 8;
+   */
+  idrPeriod?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt bframes = 9;
+   */
+  bframes?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt gop_size = 10;
+   */
+  gopSize?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt min_qp = 11;
+   */
+  minQp?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt max_qp = 12;
+   */
+  maxQp?: OptionalInt;
+
   constructor(data?: PartialMessage<XilinxH264>) {
     super();
     proto3.util.initPartial(data, this);
@@ -16076,6 +16347,16 @@ export class XilinxH264 extends Message<XilinxH264> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "profile", kind: "enum", T: proto3.getEnumType(XilinxH264_XilinxH264Profile) },
     { no: 2, name: "level", kind: "message", T: OptionalInt },
+    { no: 3, name: "const_qp", kind: "scalar", T: 13 /* ScalarType.UINT32 */, oneof: "rateControl" },
+    { no: 4, name: "cbr", kind: "scalar", T: 13 /* ScalarType.UINT32 */, oneof: "rateControl" },
+    { no: 5, name: "vbr", kind: "scalar", T: 13 /* ScalarType.UINT32 */, oneof: "rateControl" },
+    { no: 6, name: "low_latency", kind: "scalar", T: 13 /* ScalarType.UINT32 */, oneof: "rateControl" },
+    { no: 7, name: "lookahead_depth", kind: "message", T: OptionalInt },
+    { no: 8, name: "idr_period", kind: "message", T: OptionalInt },
+    { no: 9, name: "bframes", kind: "message", T: OptionalInt },
+    { no: 10, name: "gop_size", kind: "message", T: OptionalInt },
+    { no: 11, name: "min_qp", kind: "message", T: OptionalInt },
+    { no: 12, name: "max_qp", kind: "message", T: OptionalInt },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): XilinxH264 {
@@ -16760,7 +17041,7 @@ export class StreamKeyOverrideConfiguration extends Message<StreamKeyOverrideCon
   id?: MediaNodeId;
 
   /**
-   * @generated from field: norsk.api.media.StreamKey streamKey = 2;
+   * @generated from field: norsk.api.media.StreamKey stream_key = 2;
    */
   streamKey?: StreamKey;
 
@@ -16773,7 +17054,7 @@ export class StreamKeyOverrideConfiguration extends Message<StreamKeyOverrideCon
   static readonly typeName = "norsk.api.media.StreamKeyOverrideConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
-    { no: 2, name: "streamKey", kind: "message", T: StreamKey },
+    { no: 2, name: "stream_key", kind: "message", T: StreamKey },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamKeyOverrideConfiguration {
@@ -16933,14 +17214,16 @@ export class StreamMetadataOverrideConfiguration extends Message<StreamMetadataO
   audioBitrate?: OptionalInt;
 
   /**
-   * * Override the language metadata of an audio stream, or `""` to clear. RFC 5646 language tag. 
+   * * Override the language metadata of an audio stream, or `""` to clear. RFC
+   * 5646 language tag. 
    *
    * @generated from field: norsk.api.common.OptionalString audio_language = 4;
    */
   audioLanguage?: OptionalString;
 
   /**
-   * * Override the language metadata of a subtitles stream, or `""` to clear RFC 5646 language tag. 
+   * * Override the language metadata of a subtitles stream, or `""` to clear RFC
+   * 5646 language tag. 
    *
    * @generated from field: norsk.api.common.OptionalString subtitles_language = 5;
    */
@@ -16999,14 +17282,16 @@ export class StreamMetadataOverrideUpdateConfiguration extends Message<StreamMet
   audioBitrate?: OptionalInt;
 
   /**
-   * * Override the language metadata of an audio stream, or `""` to clear. RFC 5646 language tag.
+   * * Override the language metadata of an audio stream, or `""` to clear. RFC
+   * 5646 language tag.
    *
    * @generated from field: norsk.api.common.OptionalString audio_language = 4;
    */
   audioLanguage?: OptionalString;
 
   /**
-   * * Override the language metadata of a subtitles stream, or `""` to clear. RFC 5646 language tag. 
+   * * Override the language metadata of a subtitles stream, or `""` to clear.
+   * RFC 5646 language tag. 
    *
    * @generated from field: norsk.api.common.OptionalString subtitles_language = 5;
    */
@@ -18029,6 +18314,14 @@ export class StreamSwitchSmoothConfiguration extends Message<StreamSwitchSmoothC
    */
   alignment = StreamSwitchSmoothConfiguration_Alignment.ALIGNED;
 
+  /**
+   * Whether to do the video compose operation in memory or on the specified
+   * hardware
+   *
+   * @generated from field: norsk.api.media.StreamSwitchSmoothConfiguration.StreamSwitchSmoothHardwareAcceleration hardware_acceleration = 10;
+   */
+  hardwareAcceleration = StreamSwitchSmoothConfiguration_StreamSwitchSmoothHardwareAcceleration.SS_NONE;
+
   constructor(data?: PartialMessage<StreamSwitchSmoothConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -18046,6 +18339,7 @@ export class StreamSwitchSmoothConfiguration extends Message<StreamSwitchSmoothC
     { no: 7, name: "frame_rate", kind: "message", T: FrameRate },
     { no: 8, name: "channel_layout", kind: "message", T: ChannelLayout },
     { no: 9, name: "alignment", kind: "enum", T: proto3.getEnumType(StreamSwitchSmoothConfiguration_Alignment) },
+    { no: 10, name: "hardware_acceleration", kind: "enum", T: proto3.getEnumType(StreamSwitchSmoothConfiguration_StreamSwitchSmoothHardwareAcceleration) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchSmoothConfiguration {
@@ -18065,6 +18359,32 @@ export class StreamSwitchSmoothConfiguration extends Message<StreamSwitchSmoothC
   }
 }
 
+/**
+ * @generated from enum norsk.api.media.StreamSwitchSmoothConfiguration.StreamSwitchSmoothHardwareAcceleration
+ */
+export enum StreamSwitchSmoothConfiguration_StreamSwitchSmoothHardwareAcceleration {
+  /**
+   * @generated from enum value: SS_NONE = 0;
+   */
+  SS_NONE = 0,
+
+  /**
+   * @generated from enum value: SS_QUADRA = 1;
+   */
+  SS_QUADRA = 1,
+
+  /**
+   * @generated from enum value: SS_NVIDIA = 2;
+   */
+  SS_NVIDIA = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(StreamSwitchSmoothConfiguration_StreamSwitchSmoothHardwareAcceleration)
+proto3.util.setEnumType(StreamSwitchSmoothConfiguration_StreamSwitchSmoothHardwareAcceleration, "norsk.api.media.StreamSwitchSmoothConfiguration.StreamSwitchSmoothHardwareAcceleration", [
+  { no: 0, name: "SS_NONE" },
+  { no: 1, name: "SS_QUADRA" },
+  { no: 2, name: "SS_NVIDIA" },
+]);
+
 /**
  * Whether to align all the incoming timestamps
  *
@@ -20021,8 +20341,8 @@ export class AudioTranscribeAzureConfiguration extends Message<AudioTranscribeAz
   outputStreamId = 0;
 
   /**
-   * The source language to recognise - an RFC 5646/ IETF BCP 47 language tag, eg en-US,
-   * en-GB, de-DE. Supported languages are found at
+   * The source language to recognise - an RFC 5646/ IETF BCP 47 language tag,
+   * eg en-US, en-GB, de-DE. Supported languages are found at
    * https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=stt
    *
    * @generated from field: string source_language = 3;
@@ -20030,7 +20350,8 @@ export class AudioTranscribeAzureConfiguration extends Message<AudioTranscribeAz
   sourceLanguage = "";
 
   /**
-   * The target output languages for translation - technically a RFC 5646 language
+   * The target output languages for translation - technically a RFC 5646
+   * language
    * tag but but in most cases omitting region, e.g. en, de, zh-Hant.
    *
    * Leave this field absent/empty to use the transcription service without
@@ -20273,6 +20594,43 @@ export class AudioTranscribeWhisperConfiguration extends Message<AudioTranscribe
    */
   model = "";
 
+  /**
+   * Translate (to English)
+   *
+   * @generated from field: bool translate = 13;
+   */
+  translate = false;
+
+  /**
+   * @generated from field: bool tiny_diarize = 14;
+   */
+  tinyDiarize = false;
+
+  /**
+   * @generated from field: string initial_prompt = 15;
+   */
+  initialPrompt = "";
+
+  /**
+   * @generated from field: norsk.api.common.OptionalBool suppress_non_speech_tokens = 16;
+   */
+  suppressNonSpeechTokens?: OptionalBool;
+
+  /**
+   * @generated from field: norsk.api.media.AudioTranscribeWhisperConfiguration.SamplingStrategy sampling_strategy = 17;
+   */
+  samplingStrategy = AudioTranscribeWhisperConfiguration_SamplingStrategy.WHISPER_SAMPLING_GREEDY;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt best_of = 18;
+   */
+  bestOf?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt beam_size = 19;
+   */
+  beamSize?: OptionalInt;
+
   constructor(data?: PartialMessage<AudioTranscribeWhisperConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -20293,6 +20651,13 @@ export class AudioTranscribeWhisperConfiguration extends Message<AudioTranscribe
     { no: 10, name: "use_gpu", kind: "message", T: OptionalBool },
     { no: 11, name: "language", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 12, name: "model", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 13, name: "translate", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 14, name: "tiny_diarize", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 15, name: "initial_prompt", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 16, name: "suppress_non_speech_tokens", kind: "message", T: OptionalBool },
+    { no: 17, name: "sampling_strategy", kind: "enum", T: proto3.getEnumType(AudioTranscribeWhisperConfiguration_SamplingStrategy) },
+    { no: 18, name: "best_of", kind: "message", T: OptionalInt },
+    { no: 19, name: "beam_size", kind: "message", T: OptionalInt },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioTranscribeWhisperConfiguration {
@@ -20312,6 +20677,26 @@ export class AudioTranscribeWhisperConfiguration extends Message<AudioTranscribe
   }
 }
 
+/**
+ * @generated from enum norsk.api.media.AudioTranscribeWhisperConfiguration.SamplingStrategy
+ */
+export enum AudioTranscribeWhisperConfiguration_SamplingStrategy {
+  /**
+   * @generated from enum value: WHISPER_SAMPLING_GREEDY = 0;
+   */
+  WHISPER_SAMPLING_GREEDY = 0,
+
+  /**
+   * @generated from enum value: WHISPER_SAMPLING_BEAM_SEARCH = 1;
+   */
+  WHISPER_SAMPLING_BEAM_SEARCH = 1,
+}
+// Retrieve enum metadata with: proto3.getEnumType(AudioTranscribeWhisperConfiguration_SamplingStrategy)
+proto3.util.setEnumType(AudioTranscribeWhisperConfiguration_SamplingStrategy, "norsk.api.media.AudioTranscribeWhisperConfiguration.SamplingStrategy", [
+  { no: 0, name: "WHISPER_SAMPLING_GREEDY" },
+  { no: 1, name: "WHISPER_SAMPLING_BEAM_SEARCH" },
+]);
+
 /**
  * @generated from message norsk.api.media.AudioTranscribeWhisperMessage
  */
@@ -22191,6 +22576,56 @@ export class Scte35SegmentationComponent extends Message<Scte35SegmentationCompo
  * ////////////////////////////////////////////////////////////////////////////
  * FrameStore
  *
+ * @generated from message norsk.api.media.FrameStoreExpiry
+ */
+export class FrameStoreExpiry extends Message<FrameStoreExpiry> {
+  /**
+   * @generated from oneof norsk.api.media.FrameStoreExpiry.message
+   */
+  message: {
+    /**
+     * @generated from field: uint32 by_size = 1;
+     */
+    value: number;
+    case: "bySize";
+  } | {
+    /**
+     * @generated from field: uint32 by_duration = 2;
+     */
+    value: number;
+    case: "byDuration";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<FrameStoreExpiry>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FrameStoreExpiry";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "by_size", kind: "scalar", T: 13 /* ScalarType.UINT32 */, oneof: "message" },
+    { no: 2, name: "by_duration", kind: "scalar", T: 13 /* ScalarType.UINT32 */, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreExpiry {
+    return new FrameStoreExpiry().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStoreExpiry {
+    return new FrameStoreExpiry().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStoreExpiry {
+    return new FrameStoreExpiry().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FrameStoreExpiry | PlainMessage<FrameStoreExpiry> | undefined, b: FrameStoreExpiry | PlainMessage<FrameStoreExpiry> | undefined): boolean {
+    return proto3.util.equals(FrameStoreExpiry, a, b);
+  }
+}
+
+/**
  * @generated from message norsk.api.media.FrameStoreRecorderConfiguration
  */
 export class FrameStoreRecorderConfiguration extends Message<FrameStoreRecorderConfiguration> {
@@ -22214,6 +22649,11 @@ export class FrameStoreRecorderConfiguration extends Message<FrameStoreRecorderC
    */
   chunkFileDurationSeconds = 0;
 
+  /**
+   * @generated from field: norsk.api.media.FrameStoreExpiry expiry = 5;
+   */
+  expiry?: FrameStoreExpiry;
+
   constructor(data?: PartialMessage<FrameStoreRecorderConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -22226,6 +22666,7 @@ export class FrameStoreRecorderConfiguration extends Message<FrameStoreRecorderC
     { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 4, name: "chunk_file_duration_seconds", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 5, name: "expiry", kind: "message", T: FrameStoreExpiry },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreRecorderConfiguration {
@@ -22245,6 +22686,173 @@ export class FrameStoreRecorderConfiguration extends Message<FrameStoreRecorderC
   }
 }
 
+/**
+ * @generated from message norsk.api.media.FrameStoreCutRequest
+ */
+export class FrameStoreCutRequest extends Message<FrameStoreCutRequest> {
+  /**
+   * @generated from field: string id = 1;
+   */
+  id = "";
+
+  /**
+   * @generated from field: norsk.api.media.StreamSelection stream_selection = 2;
+   */
+  streamSelection?: StreamSelection;
+
+  /**
+   * @generated from field: repeated norsk.api.media.SingleCut cuts = 3;
+   */
+  cuts: SingleCut[] = [];
+
+  /**
+   * @generated from field: bool trim_partial_segments = 4;
+   */
+  trimPartialSegments = false;
+
+  /**
+   * @generated from field: string file_name = 5;
+   */
+  fileName = "";
+
+  /**
+   * @generated from field: norsk.api.media.FrameStoreCutRequest.FileFormat file_format = 6;
+   */
+  fileFormat = FrameStoreCutRequest_FileFormat.CUT_MP4;
+
+  constructor(data?: PartialMessage<FrameStoreCutRequest>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FrameStoreCutRequest";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "stream_selection", kind: "message", T: StreamSelection },
+    { no: 3, name: "cuts", kind: "message", T: SingleCut, repeated: true },
+    { no: 4, name: "trim_partial_segments", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 5, name: "file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 6, name: "file_format", kind: "enum", T: proto3.getEnumType(FrameStoreCutRequest_FileFormat) },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreCutRequest {
+    return new FrameStoreCutRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStoreCutRequest {
+    return new FrameStoreCutRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStoreCutRequest {
+    return new FrameStoreCutRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FrameStoreCutRequest | PlainMessage<FrameStoreCutRequest> | undefined, b: FrameStoreCutRequest | PlainMessage<FrameStoreCutRequest> | undefined): boolean {
+    return proto3.util.equals(FrameStoreCutRequest, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.FrameStoreCutRequest.FileFormat
+ */
+export enum FrameStoreCutRequest_FileFormat {
+  /**
+   * @generated from enum value: CUT_MP4 = 0;
+   */
+  CUT_MP4 = 0,
+}
+// Retrieve enum metadata with: proto3.getEnumType(FrameStoreCutRequest_FileFormat)
+proto3.util.setEnumType(FrameStoreCutRequest_FileFormat, "norsk.api.media.FrameStoreCutRequest.FileFormat", [
+  { no: 0, name: "CUT_MP4" },
+]);
+
+/**
+ * @generated from message norsk.api.media.FrameStoreCutProgress
+ */
+export class FrameStoreCutProgress extends Message<FrameStoreCutProgress> {
+  /**
+   * @generated from field: string id = 1;
+   */
+  id = "";
+
+  /**
+   * @generated from field: uint32 progress = 2;
+   */
+  progress = 0;
+
+  constructor(data?: PartialMessage<FrameStoreCutProgress>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FrameStoreCutProgress";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "progress", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreCutProgress {
+    return new FrameStoreCutProgress().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStoreCutProgress {
+    return new FrameStoreCutProgress().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStoreCutProgress {
+    return new FrameStoreCutProgress().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FrameStoreCutProgress | PlainMessage<FrameStoreCutProgress> | undefined, b: FrameStoreCutProgress | PlainMessage<FrameStoreCutProgress> | undefined): boolean {
+    return proto3.util.equals(FrameStoreCutProgress, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.FrameStoreCutComplete
+ */
+export class FrameStoreCutComplete extends Message<FrameStoreCutComplete> {
+  /**
+   * @generated from field: string id = 1;
+   */
+  id = "";
+
+  /**
+   * @generated from field: uint64 size = 2;
+   */
+  size = protoInt64.zero;
+
+  constructor(data?: PartialMessage<FrameStoreCutComplete>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FrameStoreCutComplete";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "size", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreCutComplete {
+    return new FrameStoreCutComplete().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStoreCutComplete {
+    return new FrameStoreCutComplete().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStoreCutComplete {
+    return new FrameStoreCutComplete().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FrameStoreCutComplete | PlainMessage<FrameStoreCutComplete> | undefined, b: FrameStoreCutComplete | PlainMessage<FrameStoreCutComplete> | undefined): boolean {
+    return proto3.util.equals(FrameStoreCutComplete, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.FrameStoreRecorderMessage
  */
@@ -22264,6 +22872,12 @@ export class FrameStoreRecorderMessage extends Message<FrameStoreRecorderMessage
      */
     value: FrameStoreRecorderConfiguration;
     case: "configuration";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.FrameStoreCutRequest cut_request = 3;
+     */
+    value: FrameStoreCutRequest;
+    case: "cutRequest";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<FrameStoreRecorderMessage>) {
@@ -22276,6 +22890,7 @@ export class FrameStoreRecorderMessage extends Message<FrameStoreRecorderMessage
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
     { no: 2, name: "configuration", kind: "message", T: FrameStoreRecorderConfiguration, oneof: "message" },
+    { no: 3, name: "cut_request", kind: "message", T: FrameStoreCutRequest, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreRecorderMessage {
@@ -22320,6 +22935,18 @@ export class FrameStoreRecorderEvent extends Message<FrameStoreRecorderEvent> {
      */
     value: Context;
     case: "inboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.FrameStoreCutProgress cut_progress = 4;
+     */
+    value: FrameStoreCutProgress;
+    case: "cutProgress";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.FrameStoreCutComplete cut_complete = 5;
+     */
+    value: FrameStoreCutComplete;
+    case: "cutComplete";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<FrameStoreRecorderEvent>) {
@@ -22333,6 +22960,8 @@ export class FrameStoreRecorderEvent extends Message<FrameStoreRecorderEvent> {
     { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
     { no: 2, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
     { no: 3, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
+    { no: 4, name: "cut_progress", kind: "message", T: FrameStoreCutProgress, oneof: "message" },
+    { no: 5, name: "cut_complete", kind: "message", T: FrameStoreCutComplete, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreRecorderEvent {
@@ -22402,156 +23031,193 @@ export class SingleCut extends Message<SingleCut> {
 }
 
 /**
- * @generated from message norsk.api.media.FrameStorePlayerConfiguration
+ * @generated from message norsk.api.media.StreamSelection
  */
-export class FrameStorePlayerConfiguration extends Message<FrameStorePlayerConfiguration> {
-  /**
-   * @generated from field: norsk.api.media.MediaNodeId id = 1;
-   */
-  id?: MediaNodeId;
-
-  /**
-   * @generated from field: string name = 2;
-   */
-  name = "";
-
-  /**
-   * @generated from field: string source_name = 3;
-   */
-  sourceName = "";
-
-  /**
-   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
-   */
-  statsSampling?: StreamStatisticsSampling;
-
+export class StreamSelection extends Message<StreamSelection> {
   /**
-   * @generated from oneof norsk.api.media.FrameStorePlayerConfiguration.stream_selection
+   * @generated from oneof norsk.api.media.StreamSelection.stream_selection
    */
   streamSelection: {
     /**
-     * @generated from field: norsk.api.media.FrameStorePlayerConfiguration.All all = 5;
+     * @generated from field: norsk.api.media.StreamSelection.All all = 1;
      */
-    value: FrameStorePlayerConfiguration_All;
+    value: StreamSelection_All;
     case: "all";
   } | {
     /**
-     * @generated from field: norsk.api.media.FrameStorePlayerConfiguration.Subset subset = 6;
+     * @generated from field: norsk.api.media.StreamSelection.Subset subset = 2;
      */
-    value: FrameStorePlayerConfiguration_Subset;
+    value: StreamSelection_Subset;
     case: "subset";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  /**
-   * @generated from field: repeated norsk.api.media.SingleCut cuts = 7;
-   */
-  cuts: SingleCut[] = [];
-
-  /**
-   * @generated from field: bool trim_partial_segments = 8;
-   */
-  trimPartialSegments = false;
-
-  constructor(data?: PartialMessage<FrameStorePlayerConfiguration>) {
+  constructor(data?: PartialMessage<StreamSelection>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStorePlayerConfiguration";
+  static readonly typeName = "norsk.api.media.StreamSelection";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "id", kind: "message", T: MediaNodeId },
-    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 4, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
-    { no: 5, name: "all", kind: "message", T: FrameStorePlayerConfiguration_All, oneof: "stream_selection" },
-    { no: 6, name: "subset", kind: "message", T: FrameStorePlayerConfiguration_Subset, oneof: "stream_selection" },
-    { no: 7, name: "cuts", kind: "message", T: SingleCut, repeated: true },
-    { no: 8, name: "trim_partial_segments", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 1, name: "all", kind: "message", T: StreamSelection_All, oneof: "stream_selection" },
+    { no: 2, name: "subset", kind: "message", T: StreamSelection_Subset, oneof: "stream_selection" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStorePlayerConfiguration {
-    return new FrameStorePlayerConfiguration().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSelection {
+    return new StreamSelection().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStorePlayerConfiguration {
-    return new FrameStorePlayerConfiguration().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSelection {
+    return new StreamSelection().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStorePlayerConfiguration {
-    return new FrameStorePlayerConfiguration().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSelection {
+    return new StreamSelection().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameStorePlayerConfiguration | PlainMessage<FrameStorePlayerConfiguration> | undefined, b: FrameStorePlayerConfiguration | PlainMessage<FrameStorePlayerConfiguration> | undefined): boolean {
-    return proto3.util.equals(FrameStorePlayerConfiguration, a, b);
+  static equals(a: StreamSelection | PlainMessage<StreamSelection> | undefined, b: StreamSelection | PlainMessage<StreamSelection> | undefined): boolean {
+    return proto3.util.equals(StreamSelection, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.FrameStorePlayerConfiguration.All
+ * @generated from message norsk.api.media.StreamSelection.All
  */
-export class FrameStorePlayerConfiguration_All extends Message<FrameStorePlayerConfiguration_All> {
-  constructor(data?: PartialMessage<FrameStorePlayerConfiguration_All>) {
+export class StreamSelection_All extends Message<StreamSelection_All> {
+  constructor(data?: PartialMessage<StreamSelection_All>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStorePlayerConfiguration.All";
+  static readonly typeName = "norsk.api.media.StreamSelection.All";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStorePlayerConfiguration_All {
-    return new FrameStorePlayerConfiguration_All().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSelection_All {
+    return new StreamSelection_All().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStorePlayerConfiguration_All {
-    return new FrameStorePlayerConfiguration_All().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSelection_All {
+    return new StreamSelection_All().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStorePlayerConfiguration_All {
-    return new FrameStorePlayerConfiguration_All().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSelection_All {
+    return new StreamSelection_All().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameStorePlayerConfiguration_All | PlainMessage<FrameStorePlayerConfiguration_All> | undefined, b: FrameStorePlayerConfiguration_All | PlainMessage<FrameStorePlayerConfiguration_All> | undefined): boolean {
-    return proto3.util.equals(FrameStorePlayerConfiguration_All, a, b);
+  static equals(a: StreamSelection_All | PlainMessage<StreamSelection_All> | undefined, b: StreamSelection_All | PlainMessage<StreamSelection_All> | undefined): boolean {
+    return proto3.util.equals(StreamSelection_All, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.FrameStorePlayerConfiguration.Subset
+ * @generated from message norsk.api.media.StreamSelection.Subset
  */
-export class FrameStorePlayerConfiguration_Subset extends Message<FrameStorePlayerConfiguration_Subset> {
+export class StreamSelection_Subset extends Message<StreamSelection_Subset> {
   /**
    * @generated from field: repeated norsk.api.media.StreamKey stream_list = 1;
    */
   streamList: StreamKey[] = [];
 
-  constructor(data?: PartialMessage<FrameStorePlayerConfiguration_Subset>) {
+  constructor(data?: PartialMessage<StreamSelection_Subset>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStorePlayerConfiguration.Subset";
+  static readonly typeName = "norsk.api.media.StreamSelection.Subset";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "stream_list", kind: "message", T: StreamKey, repeated: true },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStorePlayerConfiguration_Subset {
-    return new FrameStorePlayerConfiguration_Subset().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSelection_Subset {
+    return new StreamSelection_Subset().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStorePlayerConfiguration_Subset {
-    return new FrameStorePlayerConfiguration_Subset().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSelection_Subset {
+    return new StreamSelection_Subset().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStorePlayerConfiguration_Subset {
-    return new FrameStorePlayerConfiguration_Subset().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSelection_Subset {
+    return new StreamSelection_Subset().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameStorePlayerConfiguration_Subset | PlainMessage<FrameStorePlayerConfiguration_Subset> | undefined, b: FrameStorePlayerConfiguration_Subset | PlainMessage<FrameStorePlayerConfiguration_Subset> | undefined): boolean {
-    return proto3.util.equals(FrameStorePlayerConfiguration_Subset, a, b);
+  static equals(a: StreamSelection_Subset | PlainMessage<StreamSelection_Subset> | undefined, b: StreamSelection_Subset | PlainMessage<StreamSelection_Subset> | undefined): boolean {
+    return proto3.util.equals(StreamSelection_Subset, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.FrameStorePlayerConfiguration
+ */
+export class FrameStorePlayerConfiguration extends Message<FrameStorePlayerConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * @generated from field: string name = 2;
+   */
+  name = "";
+
+  /**
+   * @generated from field: string source_name = 3;
+   */
+  sourceName = "";
+
+  /**
+   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
+   */
+  statsSampling?: StreamStatisticsSampling;
+
+  /**
+   * @generated from field: norsk.api.media.StreamSelection stream_selection = 5;
+   */
+  streamSelection?: StreamSelection;
+
+  /**
+   * @generated from field: repeated norsk.api.media.SingleCut cuts = 6;
+   */
+  cuts: SingleCut[] = [];
+
+  /**
+   * @generated from field: bool trim_partial_segments = 7;
+   */
+  trimPartialSegments = false;
+
+  constructor(data?: PartialMessage<FrameStorePlayerConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FrameStorePlayerConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 5, name: "stream_selection", kind: "message", T: StreamSelection },
+    { no: 6, name: "cuts", kind: "message", T: SingleCut, repeated: true },
+    { no: 7, name: "trim_partial_segments", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStorePlayerConfiguration {
+    return new FrameStorePlayerConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStorePlayerConfiguration {
+    return new FrameStorePlayerConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStorePlayerConfiguration {
+    return new FrameStorePlayerConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FrameStorePlayerConfiguration | PlainMessage<FrameStorePlayerConfiguration> | undefined, b: FrameStorePlayerConfiguration | PlainMessage<FrameStorePlayerConfiguration> | undefined): boolean {
+    return proto3.util.equals(FrameStorePlayerConfiguration, a, b);
   }
 }