@norskvideo/norsk-api 1.0.364 → 1.0.367

package/lib/media_pb.ts

@@ -5,7 +5,7 @@
 
 import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
 import { Empty, Message, proto3, protoInt64, Timestamp } from "@bufbuild/protobuf";
-import { CurrentLoad, Log, OptionalBool, OptionalInt, OptionalInt64, OptionalString, Version } from "./shared/common_pb.js";
+import { CurrentLoad, Log, OptionalBool, OptionalInt, OptionalInt64, OptionalString, UInt32OrInfinity, Version } from "./shared/common_pb.js";
 
 /**
  * Enumeration of possible channel positions.
@@ -6421,9 +6421,9 @@ export class TestCardVideoConfiguration extends Message<TestCardVideoConfigurati
   sourceName = "";
 
   /**
-   * @generated from field: int32 number_of_frames = 4;
+   * @generated from field: norsk.api.common.UInt32OrInfinity number_of_frames = 4;
    */
-  numberOfFrames = 0;
+  numberOfFrames?: UInt32OrInfinity;
 
   /**
    * @generated from field: bool realtime = 5;
@@ -6446,7 +6446,7 @@ export class TestCardVideoConfiguration extends Message<TestCardVideoConfigurati
     { no: 1, name: "resolution", kind: "message", T: Resolution },
     { no: 2, name: "frame_rate", kind: "message", T: FrameRate },
     { no: 3, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 4, name: "number_of_frames", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 4, name: "number_of_frames", kind: "message", T: UInt32OrInfinity },
     { no: 5, name: "realtime", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
     { no: 6, name: "pattern", kind: "enum", T: proto3.getEnumType(TestCardPattern) },
   ]);
@@ -6811,17 +6811,22 @@ export class DeltacastInputConfiguration extends Message<DeltacastInputConfigura
   deviceId = 0;
 
   /**
-   * @generated from field: uint32 channel_index = 4;
+   * @generated from field: bool capture_video = 4;
+   */
+  captureVideo = false;
+
+  /**
+   * @generated from field: uint32 channel_index = 5;
    */
   channelIndex = 0;
 
   /**
-   * @generated from field: uint32 audio_channel_mask = 5;
+   * @generated from field: uint32 audio_channel_mask = 6;
    */
   audioChannelMask = 0;
 
   /**
-   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 6;
+   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 7;
    */
   statsSampling?: StreamStatisticsSampling;
 
@@ -6836,9 +6841,10 @@ export class DeltacastInputConfiguration extends Message<DeltacastInputConfigura
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 3, name: "device_id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-    { no: 4, name: "channel_index", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-    { no: 5, name: "audio_channel_mask", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
-    { no: 6, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 4, name: "capture_video", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 5, name: "channel_index", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 6, name: "audio_channel_mask", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 7, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeltacastInputConfiguration {
@@ -7370,6 +7376,18 @@ export class FileMp4InputMessage extends Message<FileMp4InputMessage> {
      */
     value: Empty;
     case: "pause";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.FileMp4InputSeek seek = 6;
+     */
+    value: FileMp4InputSeek;
+    case: "seek";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.FileMp4InputPlayUntil playUntil = 7;
+     */
+    value: FileMp4InputPlayUntil;
+    case: "playUntil";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<FileMp4InputMessage>) {
@@ -7385,6 +7403,8 @@ export class FileMp4InputMessage extends Message<FileMp4InputMessage> {
     { no: 3, name: "update_config", kind: "message", T: FileMp4InputConfigurationUpdate, oneof: "message" },
     { no: 4, name: "play", kind: "message", T: Empty, oneof: "message" },
     { no: 5, name: "pause", kind: "message", T: Empty, oneof: "message" },
+    { no: 6, name: "seek", kind: "message", T: FileMp4InputSeek, oneof: "message" },
+    { no: 7, name: "playUntil", kind: "message", T: FileMp4InputPlayUntil, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputMessage {
@@ -7404,6 +7424,80 @@ export class FileMp4InputMessage extends Message<FileMp4InputMessage> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.FileMp4InputSeek
+ */
+export class FileMp4InputSeek extends Message<FileMp4InputSeek> {
+  /**
+   * @generated from field: uint32 offset_ms = 1;
+   */
+  offsetMs = 0;
+
+  constructor(data?: PartialMessage<FileMp4InputSeek>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FileMp4InputSeek";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "offset_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputSeek {
+    return new FileMp4InputSeek().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputSeek {
+    return new FileMp4InputSeek().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputSeek {
+    return new FileMp4InputSeek().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FileMp4InputSeek | PlainMessage<FileMp4InputSeek> | undefined, b: FileMp4InputSeek | PlainMessage<FileMp4InputSeek> | undefined): boolean {
+    return proto3.util.equals(FileMp4InputSeek, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.FileMp4InputPlayUntil
+ */
+export class FileMp4InputPlayUntil extends Message<FileMp4InputPlayUntil> {
+  /**
+   * @generated from field: uint32 offset_ms = 1;
+   */
+  offsetMs = 0;
+
+  constructor(data?: PartialMessage<FileMp4InputPlayUntil>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.FileMp4InputPlayUntil";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "offset_ms", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputPlayUntil {
+    return new FileMp4InputPlayUntil().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputPlayUntil {
+    return new FileMp4InputPlayUntil().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputPlayUntil {
+    return new FileMp4InputPlayUntil().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: FileMp4InputPlayUntil | PlainMessage<FileMp4InputPlayUntil> | undefined, b: FileMp4InputPlayUntil | PlainMessage<FileMp4InputPlayUntil> | undefined): boolean {
+    return proto3.util.equals(FileMp4InputPlayUntil, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.FileMp4InputStatus
  */
@@ -7454,11 +7548,23 @@ export enum FileMp4InputStatus_State {
    * @generated from enum value: INPUT_STATUS_EOF = 1;
    */
   INPUT_STATUS_EOF = 1,
+
+  /**
+   * @generated from enum value: INPUT_STATUS_EOF_LOOPING = 2;
+   */
+  INPUT_STATUS_EOF_LOOPING = 2,
+
+  /**
+   * @generated from enum value: INPUT_STATUS_STOP_POSITION = 3;
+   */
+  INPUT_STATUS_STOP_POSITION = 3,
 }
 // Retrieve enum metadata with: proto3.getEnumType(FileMp4InputStatus_State)
 proto3.util.setEnumType(FileMp4InputStatus_State, "norsk.api.media.FileMp4InputStatus.State", [
   { no: 0, name: "INPUT_STATUS_UNKNOWN" },
   { no: 1, name: "INPUT_STATUS_EOF" },
+  { no: 2, name: "INPUT_STATUS_EOF_LOOPING" },
+  { no: 3, name: "INPUT_STATUS_STOP_POSITION" },
 ]);
 
 /**
@@ -12837,6 +12943,20 @@ export class HlsPushDestination extends Message<HlsPushDestination> {
    */
   partHoldBackSeconds = 0;
 
+  /**
+   * whether the server supports gzip compression on PUT/POST requests
+   *
+   * @generated from field: bool supports_gzip = 10;
+   */
+  supportsGzip = false;
+
+  /**
+   * Whether to use TLS or plain TCP transport, by default TLS used if port is 443
+   *
+   * @generated from field: norsk.api.common.OptionalBool tls_transport = 11;
+   */
+  tlsTransport?: OptionalBool;
+
   constructor(data?: PartialMessage<HlsPushDestination>) {
     super();
     proto3.util.initPartial(data, this);
@@ -12854,6 +12974,8 @@ export class HlsPushDestination extends Message<HlsPushDestination> {
     { no: 7, name: "default_segment_count", kind: "message", T: OptionalInt },
     { no: 8, name: "hold_back_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 9, name: "part_hold_back_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
+    { no: 10, name: "supports_gzip", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 11, name: "tls_transport", kind: "message", T: OptionalBool },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsPushDestination {
@@ -23952,6 +24074,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
  */
@@ -23971,6 +24167,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>) {
@@ -23983,6 +24191,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 {
@@ -25833,6 +26043,49 @@ export class MediaStoreRecorderConfiguration extends Message<MediaStoreRecorderC
   }
 }
 
+/**
+ * @generated from message norsk.api.media.MediaStoreSnapshotConfiguration
+ */
+export class MediaStoreSnapshotConfiguration extends Message<MediaStoreSnapshotConfiguration> {
+  /**
+   * @generated from field: string name = 1;
+   */
+  name = "";
+
+  /**
+   * @generated from field: string path = 2;
+   */
+  path = "";
+
+  constructor(data?: PartialMessage<MediaStoreSnapshotConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MediaStoreSnapshotConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreSnapshotConfiguration {
+    return new MediaStoreSnapshotConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreSnapshotConfiguration {
+    return new MediaStoreSnapshotConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreSnapshotConfiguration {
+    return new MediaStoreSnapshotConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MediaStoreSnapshotConfiguration | PlainMessage<MediaStoreSnapshotConfiguration> | undefined, b: MediaStoreSnapshotConfiguration | PlainMessage<MediaStoreSnapshotConfiguration> | undefined): boolean {
+    return proto3.util.equals(MediaStoreSnapshotConfiguration, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.StreamSelection
  */
@@ -25901,15 +26154,20 @@ export class SingleCut extends Message<SingleCut> {
   durationMs = 0;
 
   /**
-   * @generated from field: bool trim_partial_segments = 5;
+   * @generated from field: bool trim_partial_gops = 5;
    */
-  trimPartialSegments = false;
+  trimPartialGops = false;
 
   /**
    * @generated from field: norsk.api.common.OptionalInt session_num = 6;
    */
   sessionNum?: OptionalInt;
 
+  /**
+   * @generated from field: norsk.api.common.UInt32OrInfinity repeat_count = 7;
+   */
+  repeatCount?: UInt32OrInfinity;
+
   constructor(data?: PartialMessage<SingleCut>) {
     super();
     proto3.util.initPartial(data, this);
@@ -25922,8 +26180,9 @@ export class SingleCut extends Message<SingleCut> {
     { 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_segments", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 5, name: "trim_partial_gops", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
     { no: 6, name: "session_num", kind: "message", T: OptionalInt },
+    { no: 7, name: "repeat_count", kind: "message", T: UInt32OrInfinity },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SingleCut {
@@ -25944,9 +26203,9 @@ export class SingleCut extends Message<SingleCut> {
 }
 
 /**
- * @generated from message norsk.api.media.MediaStoreCutRequest
+ * @generated from message norsk.api.media.StartMediaStoreCut
  */
-export class MediaStoreCutRequest extends Message<MediaStoreCutRequest> {
+export class StartMediaStoreCut extends Message<StartMediaStoreCut> {
   /**
    * @generated from field: string id = 1;
    */
@@ -25963,55 +26222,136 @@ export class MediaStoreCutRequest extends Message<MediaStoreCutRequest> {
   fileName = "";
 
   /**
-   * @generated from field: norsk.api.media.MediaStoreCutRequest.FileFormat file_format = 4;
+   * @generated from field: norsk.api.media.StartMediaStoreCut.FileFormat file_format = 4;
    */
-  fileFormat = MediaStoreCutRequest_FileFormat.CUT_MP4;
+  fileFormat = StartMediaStoreCut_FileFormat.CUT_MP4;
 
-  constructor(data?: PartialMessage<MediaStoreCutRequest>) {
+  constructor(data?: PartialMessage<StartMediaStoreCut>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.MediaStoreCutRequest";
+  static readonly typeName = "norsk.api.media.StartMediaStoreCut";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { 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) },
+    { no: 4, name: "file_format", kind: "enum", T: proto3.getEnumType(StartMediaStoreCut_FileFormat) },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreCutRequest {
-    return new MediaStoreCutRequest().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StartMediaStoreCut {
+    return new StartMediaStoreCut().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreCutRequest {
-    return new MediaStoreCutRequest().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StartMediaStoreCut {
+    return new StartMediaStoreCut().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreCutRequest {
-    return new MediaStoreCutRequest().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StartMediaStoreCut {
+    return new StartMediaStoreCut().fromJsonString(jsonString, options);
   }
 
-  static equals(a: MediaStoreCutRequest | PlainMessage<MediaStoreCutRequest> | undefined, b: MediaStoreCutRequest | PlainMessage<MediaStoreCutRequest> | undefined): boolean {
-    return proto3.util.equals(MediaStoreCutRequest, a, b);
+  static equals(a: StartMediaStoreCut | PlainMessage<StartMediaStoreCut> | undefined, b: StartMediaStoreCut | PlainMessage<StartMediaStoreCut> | undefined): boolean {
+    return proto3.util.equals(StartMediaStoreCut, a, b);
   }
 }
 
 /**
- * @generated from enum norsk.api.media.MediaStoreCutRequest.FileFormat
+ * @generated from enum norsk.api.media.StartMediaStoreCut.FileFormat
  */
-export enum MediaStoreCutRequest_FileFormat {
+export enum StartMediaStoreCut_FileFormat {
   /**
    * @generated from enum value: CUT_MP4 = 0;
    */
   CUT_MP4 = 0,
 }
-// Retrieve enum metadata with: proto3.getEnumType(MediaStoreCutRequest_FileFormat)
-proto3.util.setEnumType(MediaStoreCutRequest_FileFormat, "norsk.api.media.MediaStoreCutRequest.FileFormat", [
+// Retrieve enum metadata with: proto3.getEnumType(StartMediaStoreCut_FileFormat)
+proto3.util.setEnumType(StartMediaStoreCut_FileFormat, "norsk.api.media.StartMediaStoreCut.FileFormat", [
   { no: 0, name: "CUT_MP4" },
 ]);
 
+/**
+ * @generated from message norsk.api.media.CancelMediaStoreCut
+ */
+export class CancelMediaStoreCut extends Message<CancelMediaStoreCut> {
+  constructor(data?: PartialMessage<CancelMediaStoreCut>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.CancelMediaStoreCut";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CancelMediaStoreCut {
+    return new CancelMediaStoreCut().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CancelMediaStoreCut {
+    return new CancelMediaStoreCut().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CancelMediaStoreCut {
+    return new CancelMediaStoreCut().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: CancelMediaStoreCut | PlainMessage<CancelMediaStoreCut> | undefined, b: CancelMediaStoreCut | PlainMessage<CancelMediaStoreCut> | undefined): boolean {
+    return proto3.util.equals(CancelMediaStoreCut, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.MediaStoreCutRequest
+ */
+export class MediaStoreCutRequest extends Message<MediaStoreCutRequest> {
+  /**
+   * @generated from oneof norsk.api.media.MediaStoreCutRequest.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.StartMediaStoreCut start_cut = 1;
+     */
+    value: StartMediaStoreCut;
+    case: "startCut";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.CancelMediaStoreCut cancel_cut = 2;
+     */
+    value: CancelMediaStoreCut;
+    case: "cancelCut";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<MediaStoreCutRequest>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MediaStoreCutRequest";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "start_cut", kind: "message", T: StartMediaStoreCut, oneof: "message" },
+    { no: 2, name: "cancel_cut", kind: "message", T: CancelMediaStoreCut, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreCutRequest {
+    return new MediaStoreCutRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreCutRequest {
+    return new MediaStoreCutRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreCutRequest {
+    return new MediaStoreCutRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MediaStoreCutRequest | PlainMessage<MediaStoreCutRequest> | undefined, b: MediaStoreCutRequest | PlainMessage<MediaStoreCutRequest> | undefined): boolean {
+    return proto3.util.equals(MediaStoreCutRequest, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.Progress
  */
@@ -26193,6 +26533,269 @@ export class MediaStoreRecorderEvent extends Message<MediaStoreRecorderEvent> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.MediaStoreSnapshotMessage
+ */
+export class MediaStoreSnapshotMessage extends Message<MediaStoreSnapshotMessage> {
+  /**
+   * @generated from oneof norsk.api.media.MediaStoreSnapshotMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.MediaStoreSnapshotConfiguration configuration = 1;
+     */
+    value: MediaStoreSnapshotConfiguration;
+    case: "configuration";
+  } | {
+    /**
+     * @generated from field: google.protobuf.Empty update = 2;
+     */
+    value: Empty;
+    case: "update";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<MediaStoreSnapshotMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MediaStoreSnapshotMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "configuration", kind: "message", T: MediaStoreSnapshotConfiguration, oneof: "message" },
+    { no: 2, name: "update", kind: "message", T: Empty, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreSnapshotMessage {
+    return new MediaStoreSnapshotMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreSnapshotMessage {
+    return new MediaStoreSnapshotMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreSnapshotMessage {
+    return new MediaStoreSnapshotMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MediaStoreSnapshotMessage | PlainMessage<MediaStoreSnapshotMessage> | undefined, b: MediaStoreSnapshotMessage | PlainMessage<MediaStoreSnapshotMessage> | undefined): boolean {
+    return proto3.util.equals(MediaStoreSnapshotMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.MediaStoreSnapshotEvent
+ */
+export class MediaStoreSnapshotEvent extends Message<MediaStoreSnapshotEvent> {
+  /**
+   * @generated from oneof norsk.api.media.MediaStoreSnapshotEvent.message
+   */
+  message: {
+    /**
+     * @generated from field: google.protobuf.Empty snapshot_loaded = 1;
+     */
+    value: Empty;
+    case: "snapshotLoaded";
+  } | {
+    /**
+     * @generated from field: google.protobuf.Empty snapshot_updated = 2;
+     */
+    value: Empty;
+    case: "snapshotUpdated";
+  } | {
+    /**
+     * @generated from field: google.protobuf.Empty snapshot_update_failed = 3;
+     */
+    value: Empty;
+    case: "snapshotUpdateFailed";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<MediaStoreSnapshotEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MediaStoreSnapshotEvent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "snapshot_loaded", kind: "message", T: Empty, oneof: "message" },
+    { no: 2, name: "snapshot_updated", kind: "message", T: Empty, oneof: "message" },
+    { no: 3, name: "snapshot_update_failed", kind: "message", T: Empty, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreSnapshotEvent {
+    return new MediaStoreSnapshotEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreSnapshotEvent {
+    return new MediaStoreSnapshotEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreSnapshotEvent {
+    return new MediaStoreSnapshotEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MediaStoreSnapshotEvent | PlainMessage<MediaStoreSnapshotEvent> | undefined, b: MediaStoreSnapshotEvent | PlainMessage<MediaStoreSnapshotEvent> | undefined): boolean {
+    return proto3.util.equals(MediaStoreSnapshotEvent, a, b);
+  }
+}
+
+/**
+ * If the store pre-exists and the hash matches, use it
+ * If the hash doesn't match, then either import or error
+ *
+ * @generated from message norsk.api.media.MediaStoreAssetFileWithHash
+ */
+export class MediaStoreAssetFileWithHash extends Message<MediaStoreAssetFileWithHash> {
+  /**
+   * @generated from field: string file = 1;
+   */
+  file = "";
+
+  /**
+   * @generated from field: string hash = 2;
+   */
+  hash = "";
+
+  /**
+   * @generated from field: bool error_on_hash_mismatch = 3;
+   */
+  errorOnHashMismatch = false;
+
+  constructor(data?: PartialMessage<MediaStoreAssetFileWithHash>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MediaStoreAssetFileWithHash";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "file", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "hash", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "error_on_hash_mismatch", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreAssetFileWithHash {
+    return new MediaStoreAssetFileWithHash().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreAssetFileWithHash {
+    return new MediaStoreAssetFileWithHash().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreAssetFileWithHash {
+    return new MediaStoreAssetFileWithHash().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MediaStoreAssetFileWithHash | PlainMessage<MediaStoreAssetFileWithHash> | undefined, b: MediaStoreAssetFileWithHash | PlainMessage<MediaStoreAssetFileWithHash> | undefined): boolean {
+    return proto3.util.equals(MediaStoreAssetFileWithHash, a, b);
+  }
+}
+
+/**
+ * As above, but calculate the hash (sha256sum)
+ *
+ * @generated from message norsk.api.media.MediaStoreAssetFile
+ */
+export class MediaStoreAssetFile extends Message<MediaStoreAssetFile> {
+  /**
+   * @generated from field: string file = 1;
+   */
+  file = "";
+
+  /**
+   * @generated from field: bool error_on_hash_mismatch = 2;
+   */
+  errorOnHashMismatch = false;
+
+  constructor(data?: PartialMessage<MediaStoreAssetFile>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MediaStoreAssetFile";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "file", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "error_on_hash_mismatch", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreAssetFile {
+    return new MediaStoreAssetFile().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreAssetFile {
+    return new MediaStoreAssetFile().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreAssetFile {
+    return new MediaStoreAssetFile().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MediaStoreAssetFile | PlainMessage<MediaStoreAssetFile> | undefined, b: MediaStoreAssetFile | PlainMessage<MediaStoreAssetFile> | undefined): boolean {
+    return proto3.util.equals(MediaStoreAssetFile, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.MediaStoreAssetSource
+ */
+export class MediaStoreAssetSource extends Message<MediaStoreAssetSource> {
+  /**
+   * @generated from oneof norsk.api.media.MediaStoreAssetSource.message
+   */
+  message: {
+    /**
+     * Load a pre-existing asset - check there's a hash but that's all
+     *
+     * @generated from field: google.protobuf.Empty no_load = 1;
+     */
+    value: Empty;
+    case: "noLoad";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.MediaStoreAssetFileWithHash file_with_hash = 2;
+     */
+    value: MediaStoreAssetFileWithHash;
+    case: "fileWithHash";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.MediaStoreAssetFile file = 3;
+     */
+    value: MediaStoreAssetFile;
+    case: "file";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<MediaStoreAssetSource>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.MediaStoreAssetSource";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "no_load", kind: "message", T: Empty, oneof: "message" },
+    { no: 2, name: "file_with_hash", kind: "message", T: MediaStoreAssetFileWithHash, oneof: "message" },
+    { no: 3, name: "file", kind: "message", T: MediaStoreAssetFile, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreAssetSource {
+    return new MediaStoreAssetSource().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MediaStoreAssetSource {
+    return new MediaStoreAssetSource().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MediaStoreAssetSource {
+    return new MediaStoreAssetSource().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MediaStoreAssetSource | PlainMessage<MediaStoreAssetSource> | undefined, b: MediaStoreAssetSource | PlainMessage<MediaStoreAssetSource> | undefined): boolean {
+    return proto3.util.equals(MediaStoreAssetSource, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.MediaStoreAssetSettings
  */
@@ -26203,9 +26806,9 @@ export class MediaStoreAssetSettings extends Message<MediaStoreAssetSettings> {
   mediaStoreName = "";
 
   /**
-   * @generated from field: string file_name = 2;
+   * @generated from field: norsk.api.media.MediaStoreAssetSource asset_source = 2;
    */
-  fileName = "";
+  assetSource?: MediaStoreAssetSource;
 
   /**
    * @generated from field: string path = 3;
@@ -26221,7 +26824,7 @@ export class MediaStoreAssetSettings extends Message<MediaStoreAssetSettings> {
   static readonly typeName = "norsk.api.media.MediaStoreAssetSettings";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "media_store_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 2, name: "file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "asset_source", kind: "message", T: MediaStoreAssetSource },
     { no: 3, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
@@ -26354,6 +26957,12 @@ export class MediaStoreCutEvent extends Message<MediaStoreCutEvent> {
      */
     value: MediaStoreCutComplete;
     case: "cutComplete";
+  } | {
+    /**
+     * @generated from field: google.protobuf.Empty cut_cancelled = 3;
+     */
+    value: Empty;
+    case: "cutCancelled";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<MediaStoreCutEvent>) {
@@ -26366,6 +26975,7 @@ export class MediaStoreCutEvent extends Message<MediaStoreCutEvent> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "cut_progress", kind: "message", T: Progress, oneof: "message" },
     { no: 2, name: "cut_complete", kind: "message", T: MediaStoreCutComplete, oneof: "message" },
+    { no: 3, name: "cut_cancelled", kind: "message", T: Empty, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreCutEvent {