@norskvideo/norsk-api 1.0.363 → 1.0.365

package/lib/media_pb.ts

@@ -5215,6 +5215,20 @@ export class FileWebVttInputConfiguration extends Message<FileWebVttInputConfigu
    */
   filename = "";
 
+  /**
+   * Language tag to associate with the stream (optional)
+   *
+   * @generated from field: string language = 4;
+   */
+  language = "";
+
+  /**
+   * Rendition name to use (optional, default "default")
+   *
+   * @generated from field: norsk.api.media.RenditionName rendition_name = 5;
+   */
+  renditionName?: RenditionName;
+
   constructor(data?: PartialMessage<FileWebVttInputConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -5226,6 +5240,8 @@ export class FileWebVttInputConfiguration extends Message<FileWebVttInputConfigu
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "filename", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "language", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 5, name: "rendition_name", kind: "message", T: RenditionName },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileWebVttInputConfiguration {
@@ -5295,6 +5311,216 @@ export class FileWebVttInputEvent extends Message<FileWebVttInputEvent> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.StreamWebVttInputMessage
+ */
+export class StreamWebVttInputMessage extends Message<StreamWebVttInputMessage> {
+  /**
+   * @generated from oneof norsk.api.media.StreamWebVttInputMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.StreamWebVttInputConfiguration initial_config = 1;
+     */
+    value: StreamWebVttInputConfiguration;
+    case: "initialConfig";
+  } | {
+    /**
+     * @generated from field: string vtt_chunk = 2;
+     */
+    value: string;
+    case: "vttChunk";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.TimestampNudge nudge = 3;
+     */
+    value: TimestampNudge;
+    case: "nudge";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<StreamWebVttInputMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamWebVttInputMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "initial_config", kind: "message", T: StreamWebVttInputConfiguration, oneof: "message" },
+    { no: 2, name: "vtt_chunk", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "message" },
+    { no: 3, name: "nudge", kind: "message", T: TimestampNudge, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamWebVttInputMessage {
+    return new StreamWebVttInputMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamWebVttInputMessage {
+    return new StreamWebVttInputMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamWebVttInputMessage {
+    return new StreamWebVttInputMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamWebVttInputMessage | PlainMessage<StreamWebVttInputMessage> | undefined, b: StreamWebVttInputMessage | PlainMessage<StreamWebVttInputMessage> | undefined): boolean {
+    return proto3.util.equals(StreamWebVttInputMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.StreamWebVttInputConfiguration
+ */
+export class StreamWebVttInputConfiguration extends Message<StreamWebVttInputConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * @generated from field: string source_name = 2;
+   */
+  sourceName = "";
+
+  /**
+   * Language tag to associate with the stream (optional)
+   *
+   * @generated from field: string language = 3;
+   */
+  language = "";
+
+  /**
+   * Rendition name to use (optional, default "default")
+   *
+   * @generated from field: norsk.api.media.RenditionName rendition_name = 4;
+   */
+  renditionName?: RenditionName;
+
+  constructor(data?: PartialMessage<StreamWebVttInputConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamWebVttInputConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "language", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "rendition_name", kind: "message", T: RenditionName },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamWebVttInputConfiguration {
+    return new StreamWebVttInputConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamWebVttInputConfiguration {
+    return new StreamWebVttInputConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamWebVttInputConfiguration {
+    return new StreamWebVttInputConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamWebVttInputConfiguration | PlainMessage<StreamWebVttInputConfiguration> | undefined, b: StreamWebVttInputConfiguration | PlainMessage<StreamWebVttInputConfiguration> | undefined): boolean {
+    return proto3.util.equals(StreamWebVttInputConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.StreamWebVttError
+ */
+export class StreamWebVttError extends Message<StreamWebVttError> {
+  /**
+   * @generated from field: string text = 1;
+   */
+  text = "";
+
+  constructor(data?: PartialMessage<StreamWebVttError>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamWebVttError";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "text", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamWebVttError {
+    return new StreamWebVttError().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamWebVttError {
+    return new StreamWebVttError().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamWebVttError {
+    return new StreamWebVttError().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamWebVttError | PlainMessage<StreamWebVttError> | undefined, b: StreamWebVttError | PlainMessage<StreamWebVttError> | undefined): boolean {
+    return proto3.util.equals(StreamWebVttError, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.StreamWebVttInputEvent
+ */
+export class StreamWebVttInputEvent extends Message<StreamWebVttInputEvent> {
+  /**
+   * @generated from oneof norsk.api.media.StreamWebVttInputEvent.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.StreamWebVttError error = 3;
+     */
+    value: StreamWebVttError;
+    case: "error";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<StreamWebVttInputEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamWebVttInputEvent";
+  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: "error", kind: "message", T: StreamWebVttError, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamWebVttInputEvent {
+    return new StreamWebVttInputEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamWebVttInputEvent {
+    return new StreamWebVttInputEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamWebVttInputEvent {
+    return new StreamWebVttInputEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamWebVttInputEvent | PlainMessage<StreamWebVttInputEvent> | undefined, b: StreamWebVttInputEvent | PlainMessage<StreamWebVttInputEvent> | undefined): boolean {
+    return proto3.util.equals(StreamWebVttInputEvent, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.SrtInputConfiguration
  */
@@ -23726,6 +23952,80 @@ export class StreamConditionConfiguration extends Message<StreamConditionConfigu
   }
 }
 
+/**
+ * @generated from message norsk.api.media.StreamConditionSpliceOut
+ */
+export class StreamConditionSpliceOut extends Message<StreamConditionSpliceOut> {
+  /**
+   * @generated from field: norsk.api.media.Interval pts = 1;
+   */
+  pts?: Interval;
+
+  constructor(data?: PartialMessage<StreamConditionSpliceOut>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamConditionSpliceOut";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "pts", kind: "message", T: Interval },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamConditionSpliceOut {
+    return new StreamConditionSpliceOut().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamConditionSpliceOut {
+    return new StreamConditionSpliceOut().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamConditionSpliceOut {
+    return new StreamConditionSpliceOut().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamConditionSpliceOut | PlainMessage<StreamConditionSpliceOut> | undefined, b: StreamConditionSpliceOut | PlainMessage<StreamConditionSpliceOut> | undefined): boolean {
+    return proto3.util.equals(StreamConditionSpliceOut, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.StreamConditionSpliceIn
+ */
+export class StreamConditionSpliceIn extends Message<StreamConditionSpliceIn> {
+  /**
+   * @generated from field: norsk.api.media.Interval pts = 1;
+   */
+  pts?: Interval;
+
+  constructor(data?: PartialMessage<StreamConditionSpliceIn>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamConditionSpliceIn";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "pts", kind: "message", T: Interval },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamConditionSpliceIn {
+    return new StreamConditionSpliceIn().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamConditionSpliceIn {
+    return new StreamConditionSpliceIn().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamConditionSpliceIn {
+    return new StreamConditionSpliceIn().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: StreamConditionSpliceIn | PlainMessage<StreamConditionSpliceIn> | undefined, b: StreamConditionSpliceIn | PlainMessage<StreamConditionSpliceIn> | undefined): boolean {
+    return proto3.util.equals(StreamConditionSpliceIn, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.StreamConditionMessage
  */
@@ -23745,6 +24045,18 @@ export class StreamConditionMessage extends Message<StreamConditionMessage> {
      */
     value: Subscription;
     case: "subscription";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.StreamConditionSpliceOut splice_out = 3;
+     */
+    value: StreamConditionSpliceOut;
+    case: "spliceOut";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.StreamConditionSpliceOut splice_in = 4;
+     */
+    value: StreamConditionSpliceOut;
+    case: "spliceIn";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<StreamConditionMessage>) {
@@ -23757,6 +24069,8 @@ export class StreamConditionMessage extends Message<StreamConditionMessage> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "initial_config", kind: "message", T: StreamConditionConfiguration, oneof: "message" },
     { no: 2, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+    { no: 3, name: "splice_out", kind: "message", T: StreamConditionSpliceOut, oneof: "message" },
+    { no: 4, name: "splice_in", kind: "message", T: StreamConditionSpliceOut, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamConditionMessage {
@@ -25274,291 +25588,598 @@ export class Scte35SegmentationComponent extends Message<Scte35SegmentationCompo
 
 /**
  * ////////////////////////////////////////////////////////////////////////////
- * FrameStore
+ * MediaStore
  *
- * @generated from message norsk.api.media.FrameStoreExpiry
+ * @generated from message norsk.api.media.MediaStoreStreamVersion
  */
-export class FrameStoreExpiry extends Message<FrameStoreExpiry> {
+export class MediaStoreStreamVersion extends Message<MediaStoreStreamVersion> {
   /**
-   * @generated from oneof norsk.api.media.FrameStoreExpiry.message
+   * @generated from field: int32 version_num = 1;
    */
-  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 };
+  versionNum = 0;
+
+  /**
+   * @generated from field: norsk.api.media.StreamMetadata metadata = 2;
+   */
+  metadata?: StreamMetadata;
 
-  constructor(data?: PartialMessage<FrameStoreExpiry>) {
+  /**
+   * @generated from field: google.protobuf.Timestamp start_date_time = 3;
+   */
+  startDateTime?: Timestamp;
+
+  /**
+   * @generated from field: uint64 duration_ms = 4;
+   */
+  durationMs = protoInt64.zero;
+
+  /**
+   * @generated from field: bool active = 5;
+   */
+  active = false;
+
+  constructor(data?: PartialMessage<MediaStoreStreamVersion>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStoreExpiry";
+  static readonly typeName = "norsk.api.media.MediaStoreStreamVersion";
   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" },
+    { no: 1, name: "version_num", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 2, name: "metadata", kind: "message", T: StreamMetadata },
+    { no: 3, name: "start_date_time", kind: "message", T: Timestamp },
+    { no: 4, name: "duration_ms", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+    { no: 5, name: "active", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreExpiry {
-    return new FrameStoreExpiry().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreStreamVersion {
+    return new MediaStoreStreamVersion().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStoreExpiry {
-    return new FrameStoreExpiry().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreStreamVersion {
+    return new MediaStoreStreamVersion().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStoreExpiry {
-    return new FrameStoreExpiry().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreStreamVersion {
+    return new MediaStoreStreamVersion().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameStoreExpiry | PlainMessage<FrameStoreExpiry> | undefined, b: FrameStoreExpiry | PlainMessage<FrameStoreExpiry> | undefined): boolean {
-    return proto3.util.equals(FrameStoreExpiry, a, b);
+  static equals(a: MediaStoreStreamVersion | PlainMessage<MediaStoreStreamVersion> | undefined, b: MediaStoreStreamVersion | PlainMessage<MediaStoreStreamVersion> | undefined): boolean {
+    return proto3.util.equals(MediaStoreStreamVersion, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.FrameStoreRecorderConfiguration
+ * @generated from message norsk.api.media.MediaStoreStream
  */
-export class FrameStoreRecorderConfiguration extends Message<FrameStoreRecorderConfiguration> {
-  /**
-   * @generated from field: norsk.api.media.MediaNodeId id = 1;
-   */
-  id?: MediaNodeId;
-
-  /**
-   * @generated from field: string name = 2;
-   */
-  name = "";
-
-  /**
-   * @generated from field: string path = 3;
-   */
-  path = "";
-
+export class MediaStoreStream extends Message<MediaStoreStream> {
   /**
-   * @generated from field: uint32 chunk_file_duration_seconds = 4;
+   * @generated from field: norsk.api.media.StreamKey stream_key = 1;
    */
-  chunkFileDurationSeconds = 0;
+  streamKey?: StreamKey;
 
   /**
-   * @generated from field: norsk.api.media.FrameStoreExpiry expiry = 5;
+   * @generated from field: repeated norsk.api.media.MediaStoreStreamVersion versions = 2;
    */
-  expiry?: FrameStoreExpiry;
+  versions: MediaStoreStreamVersion[] = [];
 
-  constructor(data?: PartialMessage<FrameStoreRecorderConfiguration>) {
+  constructor(data?: PartialMessage<MediaStoreStream>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStoreRecorderConfiguration";
+  static readonly typeName = "norsk.api.media.MediaStoreStream";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 1, name: "stream_key", kind: "message", T: StreamKey },
+    { no: 2, name: "versions", kind: "message", T: MediaStoreStreamVersion, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreStream {
+    return new MediaStoreStream().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreStream {
+    return new MediaStoreStream().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreStream {
+    return new MediaStoreStream().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MediaStoreStream | PlainMessage<MediaStoreStream> | undefined, b: MediaStoreStream | PlainMessage<MediaStoreStream> | undefined): boolean {
+    return proto3.util.equals(MediaStoreStream, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.MediaStoreSession
+ */
+export class MediaStoreSession extends Message<MediaStoreSession> {
+  /**
+   * @generated from field: int32 session_num = 1;
+   */
+  sessionNum = 0;
+
+  /**
+   * @generated from field: repeated norsk.api.media.MediaStoreStream streams = 2;
+   */
+  streams: MediaStoreStream[] = [];
+
+  constructor(data?: PartialMessage<MediaStoreSession>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MediaStoreSession";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "session_num", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 2, name: "streams", kind: "message", T: MediaStoreStream, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreSession {
+    return new MediaStoreSession().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreSession {
+    return new MediaStoreSession().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreSession {
+    return new MediaStoreSession().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MediaStoreSession | PlainMessage<MediaStoreSession> | undefined, b: MediaStoreSession | PlainMessage<MediaStoreSession> | undefined): boolean {
+    return proto3.util.equals(MediaStoreSession, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.MediaStoreMetadataRequest
+ */
+export class MediaStoreMetadataRequest extends Message<MediaStoreMetadataRequest> {
+  /**
+   * @generated from field: string media_store_name = 1;
+   */
+  mediaStoreName = "";
+
+  constructor(data?: PartialMessage<MediaStoreMetadataRequest>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MediaStoreMetadataRequest";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "media_store_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreMetadataRequest {
+    return new MediaStoreMetadataRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreMetadataRequest {
+    return new MediaStoreMetadataRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreMetadataRequest {
+    return new MediaStoreMetadataRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MediaStoreMetadataRequest | PlainMessage<MediaStoreMetadataRequest> | undefined, b: MediaStoreMetadataRequest | PlainMessage<MediaStoreMetadataRequest> | undefined): boolean {
+    return proto3.util.equals(MediaStoreMetadataRequest, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.MediaStoreMetadataResponse
+ */
+export class MediaStoreMetadataResponse extends Message<MediaStoreMetadataResponse> {
+  /**
+   * @generated from field: repeated norsk.api.media.MediaStoreSession sessions = 1;
+   */
+  sessions: MediaStoreSession[] = [];
+
+  constructor(data?: PartialMessage<MediaStoreMetadataResponse>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MediaStoreMetadataResponse";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "sessions", kind: "message", T: MediaStoreSession, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreMetadataResponse {
+    return new MediaStoreMetadataResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreMetadataResponse {
+    return new MediaStoreMetadataResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreMetadataResponse {
+    return new MediaStoreMetadataResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MediaStoreMetadataResponse | PlainMessage<MediaStoreMetadataResponse> | undefined, b: MediaStoreMetadataResponse | PlainMessage<MediaStoreMetadataResponse> | undefined): boolean {
+    return proto3.util.equals(MediaStoreMetadataResponse, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.MediaStoreExpiry
+ */
+export class MediaStoreExpiry extends Message<MediaStoreExpiry> {
+  /**
+   * @generated from oneof norsk.api.media.MediaStoreExpiry.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<MediaStoreExpiry>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MediaStoreExpiry";
+  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>): MediaStoreExpiry {
+    return new MediaStoreExpiry().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreExpiry {
+    return new MediaStoreExpiry().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreExpiry {
+    return new MediaStoreExpiry().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MediaStoreExpiry | PlainMessage<MediaStoreExpiry> | undefined, b: MediaStoreExpiry | PlainMessage<MediaStoreExpiry> | undefined): boolean {
+    return proto3.util.equals(MediaStoreExpiry, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.MediaStoreRecorderConfiguration
+ */
+export class MediaStoreRecorderConfiguration extends Message<MediaStoreRecorderConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * @generated from field: string name = 2;
+   */
+  name = "";
+
+  /**
+   * @generated from field: string path = 3;
+   */
+  path = "";
+
+  /**
+   * @generated from field: uint32 chunk_file_duration_seconds = 4;
+   */
+  chunkFileDurationSeconds = 0;
+
+  /**
+   * @generated from field: norsk.api.media.MediaStoreExpiry expiry = 5;
+   */
+  expiry?: MediaStoreExpiry;
+
+  constructor(data?: PartialMessage<MediaStoreRecorderConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MediaStoreRecorderConfiguration";
+  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: "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 },
+    { no: 5, name: "expiry", kind: "message", T: MediaStoreExpiry },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreRecorderConfiguration {
-    return new FrameStoreRecorderConfiguration().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreRecorderConfiguration {
+    return new MediaStoreRecorderConfiguration().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStoreRecorderConfiguration {
-    return new FrameStoreRecorderConfiguration().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreRecorderConfiguration {
+    return new MediaStoreRecorderConfiguration().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStoreRecorderConfiguration {
-    return new FrameStoreRecorderConfiguration().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreRecorderConfiguration {
+    return new MediaStoreRecorderConfiguration().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameStoreRecorderConfiguration | PlainMessage<FrameStoreRecorderConfiguration> | undefined, b: FrameStoreRecorderConfiguration | PlainMessage<FrameStoreRecorderConfiguration> | undefined): boolean {
-    return proto3.util.equals(FrameStoreRecorderConfiguration, a, b);
+  static equals(a: MediaStoreRecorderConfiguration | PlainMessage<MediaStoreRecorderConfiguration> | undefined, b: MediaStoreRecorderConfiguration | PlainMessage<MediaStoreRecorderConfiguration> | undefined): boolean {
+    return proto3.util.equals(MediaStoreRecorderConfiguration, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.FrameStoreCutRequest
+ * @generated from message norsk.api.media.StreamSelection
  */
-export class FrameStoreCutRequest extends Message<FrameStoreCutRequest> {
+export class StreamSelection extends Message<StreamSelection> {
   /**
-   * @generated from field: string id = 1;
+   * @generated from field: norsk.api.media.StreamKey source_stream_key = 1;
    */
-  id = "";
+  sourceStreamKey?: StreamKey;
+
+  /**
+   * @generated from field: norsk.api.media.StreamKey output_stream_key = 2;
+   */
+  outputStreamKey?: StreamKey;
+
+  constructor(data?: PartialMessage<StreamSelection>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.StreamSelection";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "source_stream_key", kind: "message", T: StreamKey },
+    { no: 2, name: "output_stream_key", kind: "message", T: StreamKey },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSelection {
+    return new StreamSelection().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSelection {
+    return new StreamSelection().fromJson(jsonValue, options);
+  }
 
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSelection {
+    return new StreamSelection().fromJsonString(jsonString, options);
+  }
+
+  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.SingleCut
+ */
+export class SingleCut extends Message<SingleCut> {
   /**
-   * @generated from field: norsk.api.media.StreamSelection stream_selection = 2;
+   * @generated from field: string media_store_name = 1;
    */
-  streamSelection?: StreamSelection;
+  mediaStoreName = "";
 
   /**
-   * @generated from field: repeated norsk.api.media.SingleCut cuts = 3;
+   * @generated from field: repeated norsk.api.media.StreamSelection stream_selection = 2;
    */
-  cuts: SingleCut[] = [];
+  streamSelection: StreamSelection[] = [];
+
+  /**
+   * @generated from field: google.protobuf.Timestamp start_date_time = 3;
+   */
+  startDateTime?: Timestamp;
+
+  /**
+   * @generated from field: uint32 duration_ms = 4;
+   */
+  durationMs = 0;
+
+  /**
+   * @generated from field: bool trim_partial_gops = 5;
+   */
+  trimPartialGops = false;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt session_num = 6;
+   */
+  sessionNum?: OptionalInt;
+
+  constructor(data?: PartialMessage<SingleCut>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SingleCut";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "media_store_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "stream_selection", kind: "message", T: StreamSelection, repeated: true },
+    { no: 3, name: "start_date_time", kind: "message", T: Timestamp },
+    { no: 4, name: "duration_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 5, name: "trim_partial_gops", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 6, name: "session_num", kind: "message", T: OptionalInt },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SingleCut {
+    return new SingleCut().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SingleCut {
+    return new SingleCut().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SingleCut {
+    return new SingleCut().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SingleCut | PlainMessage<SingleCut> | undefined, b: SingleCut | PlainMessage<SingleCut> | undefined): boolean {
+    return proto3.util.equals(SingleCut, a, b);
+  }
+}
 
+/**
+ * @generated from message norsk.api.media.MediaStoreCutRequest
+ */
+export class MediaStoreCutRequest extends Message<MediaStoreCutRequest> {
   /**
-   * @generated from field: bool trim_partial_segments = 4;
+   * @generated from field: string id = 1;
    */
-  trimPartialSegments = false;
+  id = "";
 
   /**
-   * @generated from field: string file_name = 5;
+   * @generated from field: repeated norsk.api.media.SingleCut cuts = 2;
+   */
+  cuts: SingleCut[] = [];
+
+  /**
+   * @generated from field: string file_name = 3;
    */
   fileName = "";
 
   /**
-   * @generated from field: norsk.api.media.FrameStoreCutRequest.FileFormat file_format = 6;
+   * @generated from field: norsk.api.media.MediaStoreCutRequest.FileFormat file_format = 4;
    */
-  fileFormat = FrameStoreCutRequest_FileFormat.CUT_MP4;
+  fileFormat = MediaStoreCutRequest_FileFormat.CUT_MP4;
 
-  constructor(data?: PartialMessage<FrameStoreCutRequest>) {
+  constructor(data?: PartialMessage<MediaStoreCutRequest>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStoreCutRequest";
+  static readonly typeName = "norsk.api.media.MediaStoreCutRequest";
   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) },
+    { no: 2, name: "cuts", kind: "message", T: SingleCut, repeated: true },
+    { no: 3, name: "file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "file_format", kind: "enum", T: proto3.getEnumType(MediaStoreCutRequest_FileFormat) },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreCutRequest {
-    return new FrameStoreCutRequest().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreCutRequest {
+    return new MediaStoreCutRequest().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStoreCutRequest {
-    return new FrameStoreCutRequest().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreCutRequest {
+    return new MediaStoreCutRequest().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStoreCutRequest {
-    return new FrameStoreCutRequest().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreCutRequest {
+    return new MediaStoreCutRequest().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameStoreCutRequest | PlainMessage<FrameStoreCutRequest> | undefined, b: FrameStoreCutRequest | PlainMessage<FrameStoreCutRequest> | undefined): boolean {
-    return proto3.util.equals(FrameStoreCutRequest, a, b);
+  static equals(a: MediaStoreCutRequest | PlainMessage<MediaStoreCutRequest> | undefined, b: MediaStoreCutRequest | PlainMessage<MediaStoreCutRequest> | undefined): boolean {
+    return proto3.util.equals(MediaStoreCutRequest, a, b);
   }
 }
 
 /**
- * @generated from enum norsk.api.media.FrameStoreCutRequest.FileFormat
+ * @generated from enum norsk.api.media.MediaStoreCutRequest.FileFormat
  */
-export enum FrameStoreCutRequest_FileFormat {
+export enum MediaStoreCutRequest_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", [
+// Retrieve enum metadata with: proto3.getEnumType(MediaStoreCutRequest_FileFormat)
+proto3.util.setEnumType(MediaStoreCutRequest_FileFormat, "norsk.api.media.MediaStoreCutRequest.FileFormat", [
   { no: 0, name: "CUT_MP4" },
 ]);
 
 /**
- * @generated from message norsk.api.media.FrameStoreCutProgress
+ * @generated from message norsk.api.media.Progress
  */
-export class FrameStoreCutProgress extends Message<FrameStoreCutProgress> {
+export class Progress extends Message<Progress> {
   /**
-   * @generated from field: string id = 1;
-   */
-  id = "";
-
-  /**
-   * @generated from field: uint32 progress = 2;
+   * @generated from field: uint32 progress = 1;
    */
   progress = 0;
 
-  constructor(data?: PartialMessage<FrameStoreCutProgress>) {
+  constructor(data?: PartialMessage<Progress>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStoreCutProgress";
+  static readonly typeName = "norsk.api.media.Progress";
   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 */ },
+    { no: 1, name: "progress", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreCutProgress {
-    return new FrameStoreCutProgress().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Progress {
+    return new Progress().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStoreCutProgress {
-    return new FrameStoreCutProgress().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Progress {
+    return new Progress().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStoreCutProgress {
-    return new FrameStoreCutProgress().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Progress {
+    return new Progress().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameStoreCutProgress | PlainMessage<FrameStoreCutProgress> | undefined, b: FrameStoreCutProgress | PlainMessage<FrameStoreCutProgress> | undefined): boolean {
-    return proto3.util.equals(FrameStoreCutProgress, a, b);
+  static equals(a: Progress | PlainMessage<Progress> | undefined, b: Progress | PlainMessage<Progress> | undefined): boolean {
+    return proto3.util.equals(Progress, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.FrameStoreCutComplete
+ * @generated from message norsk.api.media.MediaStoreCutComplete
  */
-export class FrameStoreCutComplete extends Message<FrameStoreCutComplete> {
-  /**
-   * @generated from field: string id = 1;
-   */
-  id = "";
-
+export class MediaStoreCutComplete extends Message<MediaStoreCutComplete> {
   /**
-   * @generated from field: uint64 size = 2;
+   * @generated from field: uint64 size = 1;
    */
   size = protoInt64.zero;
 
-  constructor(data?: PartialMessage<FrameStoreCutComplete>) {
+  constructor(data?: PartialMessage<MediaStoreCutComplete>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStoreCutComplete";
+  static readonly typeName = "norsk.api.media.MediaStoreCutComplete";
   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 */ },
+    { no: 1, name: "size", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreCutComplete {
-    return new FrameStoreCutComplete().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreCutComplete {
+    return new MediaStoreCutComplete().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStoreCutComplete {
-    return new FrameStoreCutComplete().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreCutComplete {
+    return new MediaStoreCutComplete().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStoreCutComplete {
-    return new FrameStoreCutComplete().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreCutComplete {
+    return new MediaStoreCutComplete().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameStoreCutComplete | PlainMessage<FrameStoreCutComplete> | undefined, b: FrameStoreCutComplete | PlainMessage<FrameStoreCutComplete> | undefined): boolean {
-    return proto3.util.equals(FrameStoreCutComplete, a, b);
+  static equals(a: MediaStoreCutComplete | PlainMessage<MediaStoreCutComplete> | undefined, b: MediaStoreCutComplete | PlainMessage<MediaStoreCutComplete> | undefined): boolean {
+    return proto3.util.equals(MediaStoreCutComplete, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.FrameStoreRecorderMessage
+ * @generated from message norsk.api.media.MediaStoreRecorderMessage
  */
-export class FrameStoreRecorderMessage extends Message<FrameStoreRecorderMessage> {
+export class MediaStoreRecorderMessage extends Message<MediaStoreRecorderMessage> {
   /**
-   * @generated from oneof norsk.api.media.FrameStoreRecorderMessage.message
+   * @generated from oneof norsk.api.media.MediaStoreRecorderMessage.message
    */
   message: {
     /**
@@ -25568,54 +26189,47 @@ export class FrameStoreRecorderMessage extends Message<FrameStoreRecorderMessage
     case: "subscription";
   } | {
     /**
-     * @generated from field: norsk.api.media.FrameStoreRecorderConfiguration configuration = 2;
+     * @generated from field: norsk.api.media.MediaStoreRecorderConfiguration configuration = 2;
      */
-    value: FrameStoreRecorderConfiguration;
+    value: MediaStoreRecorderConfiguration;
     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>) {
+  constructor(data?: PartialMessage<MediaStoreRecorderMessage>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStoreRecorderMessage";
+  static readonly typeName = "norsk.api.media.MediaStoreRecorderMessage";
   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" },
+    { no: 2, name: "configuration", kind: "message", T: MediaStoreRecorderConfiguration, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStoreRecorderMessage {
-    return new FrameStoreRecorderMessage().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreRecorderMessage {
+    return new MediaStoreRecorderMessage().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStoreRecorderMessage {
-    return new FrameStoreRecorderMessage().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreRecorderMessage {
+    return new MediaStoreRecorderMessage().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStoreRecorderMessage {
-    return new FrameStoreRecorderMessage().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreRecorderMessage {
+    return new MediaStoreRecorderMessage().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameStoreRecorderMessage | PlainMessage<FrameStoreRecorderMessage> | undefined, b: FrameStoreRecorderMessage | PlainMessage<FrameStoreRecorderMessage> | undefined): boolean {
-    return proto3.util.equals(FrameStoreRecorderMessage, a, b);
+  static equals(a: MediaStoreRecorderMessage | PlainMessage<MediaStoreRecorderMessage> | undefined, b: MediaStoreRecorderMessage | PlainMessage<MediaStoreRecorderMessage> | undefined): boolean {
+    return proto3.util.equals(MediaStoreRecorderMessage, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.FrameStoreRecorderEvent
+ * @generated from message norsk.api.media.MediaStoreRecorderEvent
  */
-export class FrameStoreRecorderEvent extends Message<FrameStoreRecorderEvent> {
+export class MediaStoreRecorderEvent extends Message<MediaStoreRecorderEvent> {
   /**
-   * @generated from oneof norsk.api.media.FrameStoreRecorderEvent.message
+   * @generated from oneof norsk.api.media.MediaStoreRecorderEvent.message
    */
   message: {
     /**
@@ -25635,304 +26249,297 @@ 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>) {
+  constructor(data?: PartialMessage<MediaStoreRecorderEvent>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStoreRecorderEvent";
+  static readonly typeName = "norsk.api.media.MediaStoreRecorderEvent";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { 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 {
-    return new FrameStoreRecorderEvent().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreRecorderEvent {
+    return new MediaStoreRecorderEvent().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStoreRecorderEvent {
-    return new FrameStoreRecorderEvent().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreRecorderEvent {
+    return new MediaStoreRecorderEvent().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStoreRecorderEvent {
-    return new FrameStoreRecorderEvent().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreRecorderEvent {
+    return new MediaStoreRecorderEvent().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameStoreRecorderEvent | PlainMessage<FrameStoreRecorderEvent> | undefined, b: FrameStoreRecorderEvent | PlainMessage<FrameStoreRecorderEvent> | undefined): boolean {
-    return proto3.util.equals(FrameStoreRecorderEvent, a, b);
+  static equals(a: MediaStoreRecorderEvent | PlainMessage<MediaStoreRecorderEvent> | undefined, b: MediaStoreRecorderEvent | PlainMessage<MediaStoreRecorderEvent> | undefined): boolean {
+    return proto3.util.equals(MediaStoreRecorderEvent, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.SingleCut
+ * @generated from message norsk.api.media.MediaStoreAssetSettings
  */
-export class SingleCut extends Message<SingleCut> {
+export class MediaStoreAssetSettings extends Message<MediaStoreAssetSettings> {
   /**
-   * @generated from field: google.protobuf.Timestamp start_date_time = 1;
+   * @generated from field: string media_store_name = 1;
    */
-  startDateTime?: Timestamp;
+  mediaStoreName = "";
 
   /**
-   * @generated from field: uint32 duration_ms = 2;
+   * @generated from field: string file_name = 2;
    */
-  durationMs = 0;
+  fileName = "";
 
   /**
-   * @generated from field: norsk.api.common.OptionalInt session_num = 3;
+   * @generated from field: string path = 3;
    */
-  sessionNum?: OptionalInt;
+  path = "";
 
-  constructor(data?: PartialMessage<SingleCut>) {
+  constructor(data?: PartialMessage<MediaStoreAssetSettings>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.SingleCut";
+  static readonly typeName = "norsk.api.media.MediaStoreAssetSettings";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "start_date_time", kind: "message", T: Timestamp },
-    { no: 2, name: "duration_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-    { no: 3, name: "session_num", kind: "message", T: OptionalInt },
+    { no: 1, name: "media_store_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SingleCut {
-    return new SingleCut().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreAssetSettings {
+    return new MediaStoreAssetSettings().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SingleCut {
-    return new SingleCut().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreAssetSettings {
+    return new MediaStoreAssetSettings().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SingleCut {
-    return new SingleCut().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreAssetSettings {
+    return new MediaStoreAssetSettings().fromJsonString(jsonString, options);
   }
 
-  static equals(a: SingleCut | PlainMessage<SingleCut> | undefined, b: SingleCut | PlainMessage<SingleCut> | undefined): boolean {
-    return proto3.util.equals(SingleCut, a, b);
+  static equals(a: MediaStoreAssetSettings | PlainMessage<MediaStoreAssetSettings> | undefined, b: MediaStoreAssetSettings | PlainMessage<MediaStoreAssetSettings> | undefined): boolean {
+    return proto3.util.equals(MediaStoreAssetSettings, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.StreamSelection
+ * @generated from message norsk.api.media.MediaStoreAssetImportComplete
  */
-export class StreamSelection extends Message<StreamSelection> {
+export class MediaStoreAssetImportComplete extends Message<MediaStoreAssetImportComplete> {
   /**
-   * @generated from oneof norsk.api.media.StreamSelection.stream_selection
+   * @generated from field: uint64 duration_ms = 1;
    */
-  streamSelection: {
-    /**
-     * @generated from field: norsk.api.media.StreamSelection.All all = 1;
-     */
-    value: StreamSelection_All;
-    case: "all";
-  } | {
-    /**
-     * @generated from field: norsk.api.media.StreamSelection.Subset subset = 2;
-     */
-    value: StreamSelection_Subset;
-    case: "subset";
-  } | { case: undefined; value?: undefined } = { case: undefined };
+  durationMs = protoInt64.zero;
 
-  constructor(data?: PartialMessage<StreamSelection>) {
+  /**
+   * @generated from field: uint64 size = 2;
+   */
+  size = protoInt64.zero;
+
+  constructor(data?: PartialMessage<MediaStoreAssetImportComplete>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.StreamSelection";
+  static readonly typeName = "norsk.api.media.MediaStoreAssetImportComplete";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "all", kind: "message", T: StreamSelection_All, oneof: "stream_selection" },
-    { no: 2, name: "subset", kind: "message", T: StreamSelection_Subset, oneof: "stream_selection" },
+    { no: 1, name: "duration_ms", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+    { no: 2, name: "size", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSelection {
-    return new StreamSelection().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreAssetImportComplete {
+    return new MediaStoreAssetImportComplete().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSelection {
-    return new StreamSelection().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreAssetImportComplete {
+    return new MediaStoreAssetImportComplete().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSelection {
-    return new StreamSelection().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreAssetImportComplete {
+    return new MediaStoreAssetImportComplete().fromJsonString(jsonString, options);
   }
 
-  static equals(a: StreamSelection | PlainMessage<StreamSelection> | undefined, b: StreamSelection | PlainMessage<StreamSelection> | undefined): boolean {
-    return proto3.util.equals(StreamSelection, a, b);
+  static equals(a: MediaStoreAssetImportComplete | PlainMessage<MediaStoreAssetImportComplete> | undefined, b: MediaStoreAssetImportComplete | PlainMessage<MediaStoreAssetImportComplete> | undefined): boolean {
+    return proto3.util.equals(MediaStoreAssetImportComplete, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.StreamSelection.All
+ * @generated from message norsk.api.media.MediaStoreAssetEvent
  */
-export class StreamSelection_All extends Message<StreamSelection_All> {
-  constructor(data?: PartialMessage<StreamSelection_All>) {
+export class MediaStoreAssetEvent extends Message<MediaStoreAssetEvent> {
+  /**
+   * @generated from oneof norsk.api.media.MediaStoreAssetEvent.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Progress import_progress = 1;
+     */
+    value: Progress;
+    case: "importProgress";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.MediaStoreAssetImportComplete import_complete = 2;
+     */
+    value: MediaStoreAssetImportComplete;
+    case: "importComplete";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<MediaStoreAssetEvent>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.StreamSelection.All";
+  static readonly typeName = "norsk.api.media.MediaStoreAssetEvent";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "import_progress", kind: "message", T: Progress, oneof: "message" },
+    { no: 2, name: "import_complete", kind: "message", T: MediaStoreAssetImportComplete, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSelection_All {
-    return new StreamSelection_All().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreAssetEvent {
+    return new MediaStoreAssetEvent().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSelection_All {
-    return new StreamSelection_All().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreAssetEvent {
+    return new MediaStoreAssetEvent().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSelection_All {
-    return new StreamSelection_All().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreAssetEvent {
+    return new MediaStoreAssetEvent().fromJsonString(jsonString, options);
   }
 
-  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);
+  static equals(a: MediaStoreAssetEvent | PlainMessage<MediaStoreAssetEvent> | undefined, b: MediaStoreAssetEvent | PlainMessage<MediaStoreAssetEvent> | undefined): boolean {
+    return proto3.util.equals(MediaStoreAssetEvent, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.StreamSelection.Subset
+ * @generated from message norsk.api.media.MediaStoreCutEvent
  */
-export class StreamSelection_Subset extends Message<StreamSelection_Subset> {
+export class MediaStoreCutEvent extends Message<MediaStoreCutEvent> {
   /**
-   * @generated from field: repeated norsk.api.media.StreamKey stream_list = 1;
+   * @generated from oneof norsk.api.media.MediaStoreCutEvent.message
    */
-  streamList: StreamKey[] = [];
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Progress cut_progress = 1;
+     */
+    value: Progress;
+    case: "cutProgress";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.MediaStoreCutComplete cut_complete = 2;
+     */
+    value: MediaStoreCutComplete;
+    case: "cutComplete";
+  } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<StreamSelection_Subset>) {
+  constructor(data?: PartialMessage<MediaStoreCutEvent>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.StreamSelection.Subset";
+  static readonly typeName = "norsk.api.media.MediaStoreCutEvent";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "stream_list", kind: "message", T: StreamKey, repeated: true },
+    { no: 1, name: "cut_progress", kind: "message", T: Progress, oneof: "message" },
+    { no: 2, name: "cut_complete", kind: "message", T: MediaStoreCutComplete, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSelection_Subset {
-    return new StreamSelection_Subset().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreCutEvent {
+    return new MediaStoreCutEvent().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSelection_Subset {
-    return new StreamSelection_Subset().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreCutEvent {
+    return new MediaStoreCutEvent().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSelection_Subset {
-    return new StreamSelection_Subset().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreCutEvent {
+    return new MediaStoreCutEvent().fromJsonString(jsonString, options);
   }
 
-  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);
+  static equals(a: MediaStoreCutEvent | PlainMessage<MediaStoreCutEvent> | undefined, b: MediaStoreCutEvent | PlainMessage<MediaStoreCutEvent> | undefined): boolean {
+    return proto3.util.equals(MediaStoreCutEvent, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.FrameStorePlayerConfiguration
+ * @generated from message norsk.api.media.MediaStorePlayerConfiguration
  */
-export class FrameStorePlayerConfiguration extends Message<FrameStorePlayerConfiguration> {
+export class MediaStorePlayerConfiguration extends Message<MediaStorePlayerConfiguration> {
   /**
    * @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;
+   * @generated from field: string source_name = 2;
    */
   sourceName = "";
 
   /**
-   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
+   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 3;
    */
   statsSampling?: StreamStatisticsSampling;
 
   /**
-   * @generated from field: norsk.api.media.StreamSelection stream_selection = 5;
-   */
-  streamSelection?: StreamSelection;
-
-  /**
-   * @generated from field: repeated norsk.api.media.SingleCut cuts = 6;
+   * @generated from field: repeated norsk.api.media.SingleCut cuts = 4;
    */
   cuts: SingleCut[] = [];
 
-  /**
-   * @generated from field: bool trim_partial_segments = 7;
-   */
-  trimPartialSegments = false;
-
-  constructor(data?: PartialMessage<FrameStorePlayerConfiguration>) {
+  constructor(data?: PartialMessage<MediaStorePlayerConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStorePlayerConfiguration";
+  static readonly typeName = "norsk.api.media.MediaStorePlayerConfiguration";
   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 */ },
+    { no: 2, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 4, name: "cuts", kind: "message", T: SingleCut, repeated: true },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStorePlayerConfiguration {
-    return new FrameStorePlayerConfiguration().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStorePlayerConfiguration {
+    return new MediaStorePlayerConfiguration().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStorePlayerConfiguration {
-    return new FrameStorePlayerConfiguration().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStorePlayerConfiguration {
+    return new MediaStorePlayerConfiguration().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStorePlayerConfiguration {
-    return new FrameStorePlayerConfiguration().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStorePlayerConfiguration {
+    return new MediaStorePlayerConfiguration().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: MediaStorePlayerConfiguration | PlainMessage<MediaStorePlayerConfiguration> | undefined, b: MediaStorePlayerConfiguration | PlainMessage<MediaStorePlayerConfiguration> | undefined): boolean {
+    return proto3.util.equals(MediaStorePlayerConfiguration, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.FrameStorePlayerMessage
+ * @generated from message norsk.api.media.MediaStorePlayerMessage
  */
-export class FrameStorePlayerMessage extends Message<FrameStorePlayerMessage> {
+export class MediaStorePlayerMessage extends Message<MediaStorePlayerMessage> {
   /**
-   * @generated from oneof norsk.api.media.FrameStorePlayerMessage.message
+   * @generated from oneof norsk.api.media.MediaStorePlayerMessage.message
    */
   message: {
     /**
-     * @generated from field: norsk.api.media.FrameStorePlayerConfiguration initial_config = 1;
+     * @generated from field: norsk.api.media.MediaStorePlayerConfiguration initial_config = 1;
      */
-    value: FrameStorePlayerConfiguration;
+    value: MediaStorePlayerConfiguration;
     case: "initialConfig";
   } | {
     /**
@@ -25942,41 +26549,41 @@ export class FrameStorePlayerMessage extends Message<FrameStorePlayerMessage> {
     case: "nudge";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<FrameStorePlayerMessage>) {
+  constructor(data?: PartialMessage<MediaStorePlayerMessage>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStorePlayerMessage";
+  static readonly typeName = "norsk.api.media.MediaStorePlayerMessage";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "initial_config", kind: "message", T: FrameStorePlayerConfiguration, oneof: "message" },
+    { no: 1, name: "initial_config", kind: "message", T: MediaStorePlayerConfiguration, oneof: "message" },
     { no: 2, name: "nudge", kind: "message", T: TimestampNudge, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStorePlayerMessage {
-    return new FrameStorePlayerMessage().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStorePlayerMessage {
+    return new MediaStorePlayerMessage().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStorePlayerMessage {
-    return new FrameStorePlayerMessage().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStorePlayerMessage {
+    return new MediaStorePlayerMessage().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStorePlayerMessage {
-    return new FrameStorePlayerMessage().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStorePlayerMessage {
+    return new MediaStorePlayerMessage().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameStorePlayerMessage | PlainMessage<FrameStorePlayerMessage> | undefined, b: FrameStorePlayerMessage | PlainMessage<FrameStorePlayerMessage> | undefined): boolean {
-    return proto3.util.equals(FrameStorePlayerMessage, a, b);
+  static equals(a: MediaStorePlayerMessage | PlainMessage<MediaStorePlayerMessage> | undefined, b: MediaStorePlayerMessage | PlainMessage<MediaStorePlayerMessage> | undefined): boolean {
+    return proto3.util.equals(MediaStorePlayerMessage, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.FrameStorePlayerEvent
+ * @generated from message norsk.api.media.MediaStorePlayerEvent
  */
-export class FrameStorePlayerEvent extends Message<FrameStorePlayerEvent> {
+export class MediaStorePlayerEvent extends Message<MediaStorePlayerEvent> {
   /**
-   * @generated from oneof norsk.api.media.FrameStorePlayerEvent.message
+   * @generated from oneof norsk.api.media.MediaStorePlayerEvent.message
    */
   message: {
     /**
@@ -25998,33 +26605,33 @@ export class FrameStorePlayerEvent extends Message<FrameStorePlayerEvent> {
     case: "streamStatistics";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<FrameStorePlayerEvent>) {
+  constructor(data?: PartialMessage<MediaStorePlayerEvent>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.FrameStorePlayerEvent";
+  static readonly typeName = "norsk.api.media.MediaStorePlayerEvent";
   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: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameStorePlayerEvent {
-    return new FrameStorePlayerEvent().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStorePlayerEvent {
+    return new MediaStorePlayerEvent().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameStorePlayerEvent {
-    return new FrameStorePlayerEvent().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStorePlayerEvent {
+    return new MediaStorePlayerEvent().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameStorePlayerEvent {
-    return new FrameStorePlayerEvent().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStorePlayerEvent {
+    return new MediaStorePlayerEvent().fromJsonString(jsonString, options);
   }
 
-  static equals(a: FrameStorePlayerEvent | PlainMessage<FrameStorePlayerEvent> | undefined, b: FrameStorePlayerEvent | PlainMessage<FrameStorePlayerEvent> | undefined): boolean {
-    return proto3.util.equals(FrameStorePlayerEvent, a, b);
+  static equals(a: MediaStorePlayerEvent | PlainMessage<MediaStorePlayerEvent> | undefined, b: MediaStorePlayerEvent | PlainMessage<MediaStorePlayerEvent> | undefined): boolean {
+    return proto3.util.equals(MediaStorePlayerEvent, a, b);
   }
 }