@norskvideo/norsk-api 0.0.328 → 0.0.330

package/lib/media_pb.ts

@@ -510,21 +510,29 @@ proto3.util.setEnumType(SampleRate, "norsk.api.media.SampleRate", [
  */
 export enum SampleFormat {
   /**
+   * Signed 16 bits, non-planar
+   *
    * @generated from enum value: S16 = 0;
    */
   S16 = 0,
 
   /**
+   * Signed 16 bits, planar
+   *
    * @generated from enum value: S16P = 1;
    */
   S16P = 1,
 
   /**
+   * 32bit floating point, non-planar
+   *
    * @generated from enum value: FLT = 2;
    */
   FLT = 2,
 
   /**
+   * 32bit floating point, planar
+   *
    * @generated from enum value: FLTP = 3;
    */
   FLTP = 3,
@@ -1504,6 +1512,44 @@ proto3.util.setEnumType(VideoIOSupport, "norsk.api.media.VideoIOSupport", [
   { no: 1, name: "PLAYBACK" },
 ]);
 
+/**
+ * @generated from enum norsk.api.media.ContextType
+ */
+export enum ContextType {
+  /**
+   * @generated from enum value: CONTEXT_TYPE_FULL = 0;
+   */
+  FULL = 0,
+
+  /**
+   * @generated from enum value: CONTEXT_TYPE_SINGLE_SOURCE = 1;
+   */
+  SINGLE_SOURCE = 1,
+
+  /**
+   * @generated from enum value: CONTEXT_TYPE_SINGLE_PROGRAM = 2;
+   */
+  SINGLE_PROGRAM = 2,
+
+  /**
+   * @generated from enum value: CONTEXT_TYPE_SINGLE_STREAM = 3;
+   */
+  SINGLE_STREAM = 3,
+
+  /**
+   * @generated from enum value: CONTEXT_TYPE_SINGLE_RENDITION = 4;
+   */
+  SINGLE_RENDITION = 4,
+}
+// Retrieve enum metadata with: proto3.getEnumType(ContextType)
+proto3.util.setEnumType(ContextType, "norsk.api.media.ContextType", [
+  { no: 0, name: "CONTEXT_TYPE_FULL" },
+  { no: 1, name: "CONTEXT_TYPE_SINGLE_SOURCE" },
+  { no: 2, name: "CONTEXT_TYPE_SINGLE_PROGRAM" },
+  { no: 3, name: "CONTEXT_TYPE_SINGLE_STREAM" },
+  { no: 4, name: "CONTEXT_TYPE_SINGLE_RENDITION" },
+]);
+
 /**
  * The canonical error codes for gRPC APIs.
  *
@@ -2557,11 +2603,11 @@ export class StreamMetadata_SubtitleMetadata extends Message<StreamMetadata_Subt
 
 /**
  * *
- * The Context message is sent from Norsk™ in response to a
+ * The Context message is sent from Norsk in response to a
  * change to either the Media Node's inbound or output set of streams.
- * Once received, your code <b>must</b> acknowledge the context change
- * with a call to <ref>Media.UnblockCall</ref>,
- * passing in the <code>blockingCallRef</code>; note that if using the
+ * Once received, your code **must** acknowledge the context change
+ * with a call to `Media.UnblockCall`,
+ * passing in the `blockingCallRef`; note that if using the
  * JavaScript SDK then this is automatically handled.
  *
  * @generated from message norsk.api.media.Context
@@ -2862,8 +2908,8 @@ export class TimestampSourceProgramNudge extends Message<TimestampSourceProgramN
  * and number of keyframes, measured over configurable sampling windows and
  * sent to the client.
  *
- * These are reported on every input media node and also for the dedicated
- * StreamStats node.
+ * These are reported on most input and output media nodes and also for the
+ * dedicated StreamStats node.
  *
  * @generated from message norsk.api.media.MultiStreamStats
  */
@@ -3380,8 +3426,8 @@ export class RtmpInputMessage extends Message<RtmpInputMessage> {
 /**
  * *
  * Sent to your code when an inbound remote connection is received. Your code
- * must reply with either an <ref>RtmpConnectionAccept</ref> or an
- * <ref>RtmpConnectionReject</ref>.
+ * must reply with either an `RtmpConnectionAccept` or an
+ * `RtmpConnectionReject`.
  *
  * @generated from message norsk.api.media.RtmpConnection
  */
@@ -3501,8 +3547,8 @@ proto3.util.setEnumType(RtmpInputStatus_State, "norsk.api.media.RtmpInputStatus.
 /**
  * *
  * Sent to your code when an inbound remote stream is received on an
- * active connection. You must reply with either an <ref>RtmpStreamAccept</ref>
- * or an <ref>RtmpStreamReject</ref>.
+ * active connection. You must reply with either an `RtmpStreamAccept`
+ * or an `RtmpStreamReject`.
  *
  * @generated from message norsk.api.media.RtmpOnStream
  */
@@ -4426,7 +4472,7 @@ export class SrtTsContext extends Message<SrtTsContext> {
  */
 export class SrtConnectMessage extends Message<SrtConnectMessage> {
   /**
-   * The SRT stream id, as set by the sender as a socket option
+   * The stream_id sent on the SRT socket (or empty if none was set)
    *
    * @generated from field: string srt_stream_id = 1;
    */
@@ -4929,8 +4975,6 @@ export class M3u8MediaInputConfiguration extends Message<M3u8MediaInputConfigura
   url = "";
 
   /**
-   * Stuff here about modes/etc
-   *
    * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 4;
    */
   statsSampling?: StreamStatsSampling;
@@ -5972,7 +6016,7 @@ export class Mp4FileInputEvent extends Message<Mp4FileInputEvent> {
  */
 export class SineWave extends Message<SineWave> {
   /**
-   * @generated from field: uint32 freq = 1;
+   * @generated from field: float freq = 1;
    */
   freq = 0;
 
@@ -5984,7 +6028,7 @@ export class SineWave extends Message<SineWave> {
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.media.SineWave";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "freq", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 1, name: "freq", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SineWave {
@@ -6879,14 +6923,15 @@ export class ComposePart extends Message<ComposePart> {
 
   /**
    * Z-index to determine ordering by which the sources are overlaid
+   * (higher layers appear on top)
    *
    * @generated from field: uint32 z_index = 4;
    */
   zIndex = 0;
 
   /**
-   * Opacity of this overlay (where 0.0 is fully transparent and 1.0 is fully
-   * opaque)
+   * Opacity multiplier of this overlay (where 0.0 is fully transparent and 1.0
+   * is fully opaque)
    *
    * @generated from field: float opacity = 5;
    */
@@ -7187,7 +7232,7 @@ export class ComposeVideoMessage extends Message<ComposeVideoMessage> {
 
 /**
  * *
- * Configure an Compose Media Node.
+ * Configure a Compose Media Node.
  *
  * @generated from message norsk.api.media.ComposeVideoConfiguration
  */
@@ -7224,7 +7269,7 @@ export class ComposeVideoConfiguration extends Message<ComposeVideoConfiguration
    * in percentage terms, or a notional resolution can be used that is
    * independant of the source resolutions that may be provided.
    *
-   * if set here, this reference resolution will be applied to 
+   * if set here, this reference resolution will be applied to
    * any parts that do not have their own reference resolution specified
    *
    * If not provided the source and destination rectangles are in terms of the
@@ -7393,7 +7438,7 @@ proto3.util.setEnumType(ComposeVideoConfiguration_MissingStreamBehaviour, "norsk
  */
 export class ComposeVideoUpdateConfiguration extends Message<ComposeVideoUpdateConfiguration> {
   /**
-   * The parts (images/overlays) to include in the composition
+   * Update the parts (images/overlays) to include in the composition
    *
    * @generated from field: repeated norsk.api.media.ComposePart parts = 1;
    */
@@ -8139,7 +8184,7 @@ export class AudioGainConfiguration extends Message<AudioGainConfiguration> {
   id?: MediaNodeId;
 
   /**
-   * The gains, per subchannel, in order
+   * The gains for this source, one for each channel
    *
    * @generated from field: repeated norsk.api.media.Db channel_gains = 2;
    */
@@ -8179,7 +8224,7 @@ export class AudioGainConfiguration extends Message<AudioGainConfiguration> {
  */
 export class AudioGainUpdateConfiguration extends Message<AudioGainUpdateConfiguration> {
   /**
-   * The channels to include in the mix
+   * The gains for this source, one for each channel
    *
    * @generated from field: repeated norsk.api.media.Db channel_gains = 1;
    */
@@ -8395,6 +8440,11 @@ export class AudioBuildMultichannelConfiguration extends Message<AudioBuildMulti
   channelLayout?: ChannelLayout;
 
   /**
+   * *
+   * Stream keys specifying the source for each channel, where the order is
+   * significant. The streams must all have the same sample format and sample
+   * rate.
+   *
    * @generated from field: repeated norsk.api.media.StreamKey channel_list = 7;
    */
   channelList: StreamKey[] = [];
@@ -8925,9 +8975,9 @@ export class CMAFDestination extends Message<CMAFDestination> {
 }
 
 /**
- * @generated from message norsk.api.media.HlsVideoConfiguration
+ * @generated from message norsk.api.media.CmafVideoConfiguration
  */
-export class HlsVideoConfiguration extends Message<HlsVideoConfiguration> {
+export class CmafVideoConfiguration extends Message<CmafVideoConfiguration> {
   /**
    * @generated from field: norsk.api.media.MediaNodeId id = 1;
    */
@@ -8963,13 +9013,13 @@ export class HlsVideoConfiguration extends Message<HlsVideoConfiguration> {
    */
   destinations: CMAFDestination[] = [];
 
-  constructor(data?: PartialMessage<HlsVideoConfiguration>) {
+  constructor(data?: PartialMessage<CmafVideoConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsVideoConfiguration";
+  static readonly typeName = "norsk.api.media.CmafVideoConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "segment_duration_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
@@ -8980,29 +9030,29 @@ export class HlsVideoConfiguration extends Message<HlsVideoConfiguration> {
     { no: 7, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsVideoConfiguration {
-    return new HlsVideoConfiguration().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafVideoConfiguration {
+    return new CmafVideoConfiguration().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsVideoConfiguration {
-    return new HlsVideoConfiguration().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafVideoConfiguration {
+    return new CmafVideoConfiguration().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsVideoConfiguration {
-    return new HlsVideoConfiguration().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafVideoConfiguration {
+    return new CmafVideoConfiguration().fromJsonString(jsonString, options);
   }
 
-  static equals(a: HlsVideoConfiguration | PlainMessage<HlsVideoConfiguration> | undefined, b: HlsVideoConfiguration | PlainMessage<HlsVideoConfiguration> | undefined): boolean {
-    return proto3.util.equals(HlsVideoConfiguration, a, b);
+  static equals(a: CmafVideoConfiguration | PlainMessage<CmafVideoConfiguration> | undefined, b: CmafVideoConfiguration | PlainMessage<CmafVideoConfiguration> | undefined): boolean {
+    return proto3.util.equals(CmafVideoConfiguration, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.HlsVideoMessage
+ * @generated from message norsk.api.media.CmafVideoMessage
  */
-export class HlsVideoMessage extends Message<HlsVideoMessage> {
+export class CmafVideoMessage extends Message<CmafVideoMessage> {
   /**
-   * @generated from oneof norsk.api.media.HlsVideoMessage.message
+   * @generated from oneof norsk.api.media.CmafVideoMessage.message
    */
   message: {
     /**
@@ -9012,9 +9062,9 @@ export class HlsVideoMessage extends Message<HlsVideoMessage> {
     case: "subscription";
   } | {
     /**
-     * @generated from field: norsk.api.media.HlsVideoConfiguration configuration = 2;
+     * @generated from field: norsk.api.media.CmafVideoConfiguration configuration = 2;
      */
-    value: HlsVideoConfiguration;
+    value: CmafVideoConfiguration;
     case: "configuration";
   } | {
     /**
@@ -9024,33 +9074,33 @@ export class HlsVideoMessage extends Message<HlsVideoMessage> {
     case: "updateCredentials";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<HlsVideoMessage>) {
+  constructor(data?: PartialMessage<CmafVideoMessage>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsVideoMessage";
+  static readonly typeName = "norsk.api.media.CmafVideoMessage";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
-    { no: 2, name: "configuration", kind: "message", T: HlsVideoConfiguration, oneof: "message" },
+    { no: 2, name: "configuration", kind: "message", T: CmafVideoConfiguration, oneof: "message" },
     { no: 3, name: "update_credentials", kind: "message", T: UpdateCredentials, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsVideoMessage {
-    return new HlsVideoMessage().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafVideoMessage {
+    return new CmafVideoMessage().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsVideoMessage {
-    return new HlsVideoMessage().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafVideoMessage {
+    return new CmafVideoMessage().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsVideoMessage {
-    return new HlsVideoMessage().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafVideoMessage {
+    return new CmafVideoMessage().fromJsonString(jsonString, options);
   }
 
-  static equals(a: HlsVideoMessage | PlainMessage<HlsVideoMessage> | undefined, b: HlsVideoMessage | PlainMessage<HlsVideoMessage> | undefined): boolean {
-    return proto3.util.equals(HlsVideoMessage, a, b);
+  static equals(a: CmafVideoMessage | PlainMessage<CmafVideoMessage> | undefined, b: CmafVideoMessage | PlainMessage<CmafVideoMessage> | undefined): boolean {
+    return proto3.util.equals(CmafVideoMessage, a, b);
   }
 }
 
@@ -9160,9 +9210,9 @@ export class HlsTsVideoMessage extends Message<HlsTsVideoMessage> {
 }
 
 /**
- * @generated from message norsk.api.media.HlsAudioConfiguration
+ * @generated from message norsk.api.media.CmafAudioConfiguration
  */
-export class HlsAudioConfiguration extends Message<HlsAudioConfiguration> {
+export class CmafAudioConfiguration extends Message<CmafAudioConfiguration> {
   /**
    * @generated from field: norsk.api.media.MediaNodeId id = 1;
    */
@@ -9198,13 +9248,13 @@ export class HlsAudioConfiguration extends Message<HlsAudioConfiguration> {
    */
   destinations: CMAFDestination[] = [];
 
-  constructor(data?: PartialMessage<HlsAudioConfiguration>) {
+  constructor(data?: PartialMessage<CmafAudioConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsAudioConfiguration";
+  static readonly typeName = "norsk.api.media.CmafAudioConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "segment_duration_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
@@ -9215,29 +9265,29 @@ export class HlsAudioConfiguration extends Message<HlsAudioConfiguration> {
     { no: 8, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsAudioConfiguration {
-    return new HlsAudioConfiguration().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafAudioConfiguration {
+    return new CmafAudioConfiguration().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsAudioConfiguration {
-    return new HlsAudioConfiguration().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafAudioConfiguration {
+    return new CmafAudioConfiguration().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsAudioConfiguration {
-    return new HlsAudioConfiguration().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafAudioConfiguration {
+    return new CmafAudioConfiguration().fromJsonString(jsonString, options);
   }
 
-  static equals(a: HlsAudioConfiguration | PlainMessage<HlsAudioConfiguration> | undefined, b: HlsAudioConfiguration | PlainMessage<HlsAudioConfiguration> | undefined): boolean {
-    return proto3.util.equals(HlsAudioConfiguration, a, b);
+  static equals(a: CmafAudioConfiguration | PlainMessage<CmafAudioConfiguration> | undefined, b: CmafAudioConfiguration | PlainMessage<CmafAudioConfiguration> | undefined): boolean {
+    return proto3.util.equals(CmafAudioConfiguration, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.HlsAudioMessage
+ * @generated from message norsk.api.media.CmafAudioMessage
  */
-export class HlsAudioMessage extends Message<HlsAudioMessage> {
+export class CmafAudioMessage extends Message<CmafAudioMessage> {
   /**
-   * @generated from oneof norsk.api.media.HlsAudioMessage.message
+   * @generated from oneof norsk.api.media.CmafAudioMessage.message
    */
   message: {
     /**
@@ -9247,9 +9297,9 @@ export class HlsAudioMessage extends Message<HlsAudioMessage> {
     case: "subscription";
   } | {
     /**
-     * @generated from field: norsk.api.media.HlsAudioConfiguration configuration = 2;
+     * @generated from field: norsk.api.media.CmafAudioConfiguration configuration = 2;
      */
-    value: HlsAudioConfiguration;
+    value: CmafAudioConfiguration;
     case: "configuration";
   } | {
     /**
@@ -9259,33 +9309,33 @@ export class HlsAudioMessage extends Message<HlsAudioMessage> {
     case: "updateCredentials";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<HlsAudioMessage>) {
+  constructor(data?: PartialMessage<CmafAudioMessage>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsAudioMessage";
+  static readonly typeName = "norsk.api.media.CmafAudioMessage";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
-    { no: 2, name: "configuration", kind: "message", T: HlsAudioConfiguration, oneof: "message" },
+    { no: 2, name: "configuration", kind: "message", T: CmafAudioConfiguration, oneof: "message" },
     { no: 3, name: "update_credentials", kind: "message", T: UpdateCredentials, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsAudioMessage {
-    return new HlsAudioMessage().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafAudioMessage {
+    return new CmafAudioMessage().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsAudioMessage {
-    return new HlsAudioMessage().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafAudioMessage {
+    return new CmafAudioMessage().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsAudioMessage {
-    return new HlsAudioMessage().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafAudioMessage {
+    return new CmafAudioMessage().fromJsonString(jsonString, options);
   }
 
-  static equals(a: HlsAudioMessage | PlainMessage<HlsAudioMessage> | undefined, b: HlsAudioMessage | PlainMessage<HlsAudioMessage> | undefined): boolean {
-    return proto3.util.equals(HlsAudioMessage, a, b);
+  static equals(a: CmafAudioMessage | PlainMessage<CmafAudioMessage> | undefined, b: CmafAudioMessage | PlainMessage<CmafAudioMessage> | undefined): boolean {
+    return proto3.util.equals(CmafAudioMessage, a, b);
   }
 }
 
@@ -9395,9 +9445,9 @@ export class HlsTsAudioMessage extends Message<HlsTsAudioMessage> {
 }
 
 /**
- * @generated from message norsk.api.media.HlsWebVttConfiguration
+ * @generated from message norsk.api.media.CmafWebVttConfiguration
  */
-export class HlsWebVttConfiguration extends Message<HlsWebVttConfiguration> {
+export class CmafWebVttConfiguration extends Message<CmafWebVttConfiguration> {
   /**
    * @generated from field: norsk.api.media.MediaNodeId id = 1;
    */
@@ -9418,13 +9468,13 @@ export class HlsWebVttConfiguration extends Message<HlsWebVttConfiguration> {
    */
   sessionId = "";
 
-  constructor(data?: PartialMessage<HlsWebVttConfiguration>) {
+  constructor(data?: PartialMessage<CmafWebVttConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsWebVttConfiguration";
+  static readonly typeName = "norsk.api.media.CmafWebVttConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "segment_duration_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
@@ -9432,20 +9482,20 @@ export class HlsWebVttConfiguration extends Message<HlsWebVttConfiguration> {
     { no: 4, name: "sessionId", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsWebVttConfiguration {
-    return new HlsWebVttConfiguration().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafWebVttConfiguration {
+    return new CmafWebVttConfiguration().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsWebVttConfiguration {
-    return new HlsWebVttConfiguration().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafWebVttConfiguration {
+    return new CmafWebVttConfiguration().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsWebVttConfiguration {
-    return new HlsWebVttConfiguration().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafWebVttConfiguration {
+    return new CmafWebVttConfiguration().fromJsonString(jsonString, options);
   }
 
-  static equals(a: HlsWebVttConfiguration | PlainMessage<HlsWebVttConfiguration> | undefined, b: HlsWebVttConfiguration | PlainMessage<HlsWebVttConfiguration> | undefined): boolean {
-    return proto3.util.equals(HlsWebVttConfiguration, a, b);
+  static equals(a: CmafWebVttConfiguration | PlainMessage<CmafWebVttConfiguration> | undefined, b: CmafWebVttConfiguration | PlainMessage<CmafWebVttConfiguration> | undefined): boolean {
+    return proto3.util.equals(CmafWebVttConfiguration, a, b);
   }
 }
 
@@ -9676,11 +9726,11 @@ export class HlsWebVttPushUpdateConfiguration extends Message<HlsWebVttPushUpdat
 }
 
 /**
- * @generated from message norsk.api.media.HlsWebVttMessage
+ * @generated from message norsk.api.media.CmafWebVttMessage
  */
-export class HlsWebVttMessage extends Message<HlsWebVttMessage> {
+export class CmafWebVttMessage extends Message<CmafWebVttMessage> {
   /**
-   * @generated from oneof norsk.api.media.HlsWebVttMessage.message
+   * @generated from oneof norsk.api.media.CmafWebVttMessage.message
    */
   message: {
     /**
@@ -9690,38 +9740,38 @@ export class HlsWebVttMessage extends Message<HlsWebVttMessage> {
     case: "subscription";
   } | {
     /**
-     * @generated from field: norsk.api.media.HlsWebVttConfiguration configuration = 2;
+     * @generated from field: norsk.api.media.CmafWebVttConfiguration configuration = 2;
      */
-    value: HlsWebVttConfiguration;
+    value: CmafWebVttConfiguration;
     case: "configuration";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<HlsWebVttMessage>) {
+  constructor(data?: PartialMessage<CmafWebVttMessage>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsWebVttMessage";
+  static readonly typeName = "norsk.api.media.CmafWebVttMessage";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
-    { no: 2, name: "configuration", kind: "message", T: HlsWebVttConfiguration, oneof: "message" },
+    { no: 2, name: "configuration", kind: "message", T: CmafWebVttConfiguration, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsWebVttMessage {
-    return new HlsWebVttMessage().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafWebVttMessage {
+    return new CmafWebVttMessage().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsWebVttMessage {
-    return new HlsWebVttMessage().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafWebVttMessage {
+    return new CmafWebVttMessage().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsWebVttMessage {
-    return new HlsWebVttMessage().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafWebVttMessage {
+    return new CmafWebVttMessage().fromJsonString(jsonString, options);
   }
 
-  static equals(a: HlsWebVttMessage | PlainMessage<HlsWebVttMessage> | undefined, b: HlsWebVttMessage | PlainMessage<HlsWebVttMessage> | undefined): boolean {
-    return proto3.util.equals(HlsWebVttMessage, a, b);
+  static equals(a: CmafWebVttMessage | PlainMessage<CmafWebVttMessage> | undefined, b: CmafWebVttMessage | PlainMessage<CmafWebVttMessage> | undefined): boolean {
+    return proto3.util.equals(CmafWebVttMessage, a, b);
   }
 }
 
@@ -9783,9 +9833,9 @@ export class HlsWebVttPushMessage extends Message<HlsWebVttPushMessage> {
 }
 
 /**
- * @generated from message norsk.api.media.HlsMasterConfiguration
+ * @generated from message norsk.api.media.CmafMasterConfiguration
  */
-export class HlsMasterConfiguration extends Message<HlsMasterConfiguration> {
+export class CmafMasterConfiguration extends Message<CmafMasterConfiguration> {
   /**
    * @generated from field: norsk.api.media.MediaNodeId id = 1;
    */
@@ -9806,13 +9856,13 @@ export class HlsMasterConfiguration extends Message<HlsMasterConfiguration> {
    */
   destinations: CMAFDestination[] = [];
 
-  constructor(data?: PartialMessage<HlsMasterConfiguration>) {
+  constructor(data?: PartialMessage<CmafMasterConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsMasterConfiguration";
+  static readonly typeName = "norsk.api.media.CmafMasterConfiguration";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "message", T: MediaNodeId },
     { no: 2, name: "playlist_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
@@ -9820,29 +9870,29 @@ export class HlsMasterConfiguration extends Message<HlsMasterConfiguration> {
     { no: 4, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsMasterConfiguration {
-    return new HlsMasterConfiguration().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafMasterConfiguration {
+    return new CmafMasterConfiguration().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsMasterConfiguration {
-    return new HlsMasterConfiguration().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafMasterConfiguration {
+    return new CmafMasterConfiguration().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsMasterConfiguration {
-    return new HlsMasterConfiguration().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafMasterConfiguration {
+    return new CmafMasterConfiguration().fromJsonString(jsonString, options);
   }
 
-  static equals(a: HlsMasterConfiguration | PlainMessage<HlsMasterConfiguration> | undefined, b: HlsMasterConfiguration | PlainMessage<HlsMasterConfiguration> | undefined): boolean {
-    return proto3.util.equals(HlsMasterConfiguration, a, b);
+  static equals(a: CmafMasterConfiguration | PlainMessage<CmafMasterConfiguration> | undefined, b: CmafMasterConfiguration | PlainMessage<CmafMasterConfiguration> | undefined): boolean {
+    return proto3.util.equals(CmafMasterConfiguration, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.media.HlsMasterMessage
+ * @generated from message norsk.api.media.CmafMasterMessage
  */
-export class HlsMasterMessage extends Message<HlsMasterMessage> {
+export class CmafMasterMessage extends Message<CmafMasterMessage> {
   /**
-   * @generated from oneof norsk.api.media.HlsMasterMessage.message
+   * @generated from oneof norsk.api.media.CmafMasterMessage.message
    */
   message: {
     /**
@@ -9852,9 +9902,9 @@ export class HlsMasterMessage extends Message<HlsMasterMessage> {
     case: "subscription";
   } | {
     /**
-     * @generated from field: norsk.api.media.HlsMasterConfiguration configuration = 2;
+     * @generated from field: norsk.api.media.CmafMasterConfiguration configuration = 2;
      */
-    value: HlsMasterConfiguration;
+    value: CmafMasterConfiguration;
     case: "configuration";
   } | {
     /**
@@ -9864,33 +9914,33 @@ export class HlsMasterMessage extends Message<HlsMasterMessage> {
     case: "updateCredentials";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<HlsMasterMessage>) {
+  constructor(data?: PartialMessage<CmafMasterMessage>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.media.HlsMasterMessage";
+  static readonly typeName = "norsk.api.media.CmafMasterMessage";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
-    { no: 2, name: "configuration", kind: "message", T: HlsMasterConfiguration, oneof: "message" },
+    { no: 2, name: "configuration", kind: "message", T: CmafMasterConfiguration, oneof: "message" },
     { no: 3, name: "update_credentials", kind: "message", T: UpdateCredentials, oneof: "message" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsMasterMessage {
-    return new HlsMasterMessage().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafMasterMessage {
+    return new CmafMasterMessage().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsMasterMessage {
-    return new HlsMasterMessage().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafMasterMessage {
+    return new CmafMasterMessage().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsMasterMessage {
-    return new HlsMasterMessage().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafMasterMessage {
+    return new CmafMasterMessage().fromJsonString(jsonString, options);
   }
 
-  static equals(a: HlsMasterMessage | PlainMessage<HlsMasterMessage> | undefined, b: HlsMasterMessage | PlainMessage<HlsMasterMessage> | undefined): boolean {
-    return proto3.util.equals(HlsMasterMessage, a, b);
+  static equals(a: CmafMasterMessage | PlainMessage<CmafMasterMessage> | undefined, b: CmafMasterMessage | PlainMessage<CmafMasterMessage> | undefined): boolean {
+    return proto3.util.equals(CmafMasterMessage, a, b);
   }
 }
 
@@ -11622,7 +11672,7 @@ export class Mp4FileOutputMessage extends Message<Mp4FileOutputMessage> {
     case: "configuration";
   } | {
     /**
-     * @generated from field: norsk.api.media.Mp4FileOutputWriteMessage writeFile = 3;
+     * @generated from field: norsk.api.media.Mp4FileOutputWriteMessage write_file = 3;
      */
     value: Mp4FileOutputWriteMessage;
     case: "writeFile";
@@ -11638,7 +11688,7 @@ export class Mp4FileOutputMessage extends Message<Mp4FileOutputMessage> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
     { no: 2, name: "configuration", kind: "message", T: Mp4FileOutputConfiguration, oneof: "message" },
-    { no: 3, name: "writeFile", kind: "message", T: Mp4FileOutputWriteMessage, oneof: "message" },
+    { no: 3, name: "write_file", kind: "message", T: Mp4FileOutputWriteMessage, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mp4FileOutputMessage {
@@ -11975,8 +12025,8 @@ export class X264Codec extends Message<X264Codec> {
 
   /**
    * Sets the level flag in the output. Permissible levels are
-   * <code>1, 1.1, 1.2, 1.3, 2, 2.1, 2.2, 3, 3.1, 3.2, 4, 4.1, 4.2,
-   * 5, 5.1</code> - since this field is an integer, you pass in 10 times the
+   * 1, 1.1, 1.2, 1.3, 2, 2.1, 2.2, 3, 3.1, 3.2, 4, 4.1, 4.2,
+   * 5, 5.1 - since this field is an integer, you pass in 10 times the
    * required value (e.g., 11, 12 etc)
    *
    * @generated from field: norsk.api.media.OptionalInt level = 3;
@@ -12406,7 +12456,7 @@ export class X265Codec extends Message<X265Codec> {
 
   /**
    * Sets the level flag in the output. Permissible levels are
-   * <code>1, 2, 2.1, 3, 3.1, 4, 4.1, 5, 5.1, 5.2, 6, 6.1, 6.2</code> -
+   * `1, 2, 2.1, 3, 3.1, 4, 4.1, 5, 5.1, 5.2, 6, 6.1, 6.2` -
    * since this field is an integer, you pass in 10 times the
    * required value (e.g., 11, 12 etc)
    *
@@ -16550,6 +16600,8 @@ export class AwsTranscribeConfiguration extends Message<AwsTranscribeConfigurati
   language = "";
 
   /**
+   * Region for the transcribe endpoint
+   *
    * @generated from field: string aws_region = 4;
    */
   awsRegion = "";
@@ -17170,18 +17222,18 @@ export class SubscribeSource extends Message<SubscribeSource> {
  */
 export class Subscription extends Message<Subscription> {
   /**
-   * The individual subscription components
+   * An arbitrary id of the subscription, to enable correlating of the corresponding subscription response
    *
-   * @generated from field: repeated norsk.api.media.SubscribeSource sources = 2;
+   * @generated from field: string id = 1;
    */
-  sources: SubscribeSource[] = [];
+  id = "";
 
   /**
-   * An arbitrary id of the subscription, to enable correlating of the corresponding subscription response
+   * The individual subscription components
    *
-   * @generated from field: string id = 3;
+   * @generated from field: repeated norsk.api.media.SubscribeSource sources = 2;
    */
-  id = "";
+  sources: SubscribeSource[] = [];
 
   constructor(data?: PartialMessage<Subscription>) {
     super();
@@ -17191,8 +17243,8 @@ export class Subscription extends Message<Subscription> {
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.media.Subscription";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 2, name: "sources", kind: "message", T: SubscribeSource, repeated: true },
-    { no: 3, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Subscription {
@@ -17219,18 +17271,18 @@ export class Subscription extends Message<Subscription> {
  */
 export class SubscriptionResponse extends Message<SubscriptionResponse> {
   /**
-   * The subscription status
+   * The id of the subscription which this message is a response to
    *
-   * @generated from field: norsk.api.media.Status status = 2;
+   * @generated from field: string id = 1;
    */
-  status?: Status;
+  id = "";
 
   /**
-   * The id of the subscription which this message is a response to
+   * The error that prevented the subscription, if any
    *
-   * @generated from field: string id = 3;
+   * @generated from field: norsk.api.media.SubscriptionError error = 2;
    */
-  id = "";
+  error?: SubscriptionError;
 
   constructor(data?: PartialMessage<SubscriptionResponse>) {
     super();
@@ -17240,8 +17292,8 @@ export class SubscriptionResponse extends Message<SubscriptionResponse> {
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.media.SubscriptionResponse";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 2, name: "status", kind: "message", T: Status },
-    { no: 3, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "error", kind: "message", T: SubscriptionError },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscriptionResponse {
@@ -17261,6 +17313,380 @@ export class SubscriptionResponse extends Message<SubscriptionResponse> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.SubscriptionError
+ */
+export class SubscriptionError extends Message<SubscriptionError> {
+  /**
+   * @generated from oneof norsk.api.media.SubscriptionError.error
+   */
+  error: {
+    /**
+     * An opaque internal error
+     *
+     * @generated from field: string internal = 1;
+     */
+    value: string;
+    case: "internal";
+  } | {
+    /**
+     * The media node requesting the subscription does not exist
+     *
+     * @generated from field: norsk.api.media.MediaNodeId unknown_subscriber = 2;
+     */
+    value: MediaNodeId;
+    case: "unknownSubscriber";
+  } | {
+    /**
+     * Multiple stream keys found for the context type
+     *
+     * @generated from field: norsk.api.media.SubscriptionError.MultipleStreams multiple_streams = 3;
+     */
+    value: SubscriptionError_MultipleStreams;
+    case: "multipleStreams";
+  } | {
+    /**
+     * Per-source errors
+     *
+     * @generated from field: norsk.api.media.SubscriptionError.SourceSubscriptionErrors source_subscription_error = 4;
+     */
+    value: SubscriptionError_SourceSubscriptionErrors;
+    case: "sourceSubscriptionError";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<SubscriptionError>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SubscriptionError";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "internal", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "error" },
+    { no: 2, name: "unknown_subscriber", kind: "message", T: MediaNodeId, oneof: "error" },
+    { no: 3, name: "multiple_streams", kind: "message", T: SubscriptionError_MultipleStreams, oneof: "error" },
+    { no: 4, name: "source_subscription_error", kind: "message", T: SubscriptionError_SourceSubscriptionErrors, oneof: "error" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscriptionError {
+    return new SubscriptionError().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubscriptionError {
+    return new SubscriptionError().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubscriptionError {
+    return new SubscriptionError().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SubscriptionError | PlainMessage<SubscriptionError> | undefined, b: SubscriptionError | PlainMessage<SubscriptionError> | undefined): boolean {
+    return proto3.util.equals(SubscriptionError, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SubscriptionError.MultipleStreams
+ */
+export class SubscriptionError_MultipleStreams extends Message<SubscriptionError_MultipleStreams> {
+  /**
+   * @generated from field: norsk.api.media.ContextType context_type = 1;
+   */
+  contextType = ContextType.FULL;
+
+  /**
+   * @generated from field: repeated norsk.api.media.StreamKey stream_keys = 2;
+   */
+  streamKeys: StreamKey[] = [];
+
+  constructor(data?: PartialMessage<SubscriptionError_MultipleStreams>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SubscriptionError.MultipleStreams";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "context_type", kind: "enum", T: proto3.getEnumType(ContextType) },
+    { no: 2, name: "stream_keys", kind: "message", T: StreamKey, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscriptionError_MultipleStreams {
+    return new SubscriptionError_MultipleStreams().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubscriptionError_MultipleStreams {
+    return new SubscriptionError_MultipleStreams().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubscriptionError_MultipleStreams {
+    return new SubscriptionError_MultipleStreams().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SubscriptionError_MultipleStreams | PlainMessage<SubscriptionError_MultipleStreams> | undefined, b: SubscriptionError_MultipleStreams | PlainMessage<SubscriptionError_MultipleStreams> | undefined): boolean {
+    return proto3.util.equals(SubscriptionError_MultipleStreams, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SubscriptionError.SourceSubscriptionErrors
+ */
+export class SubscriptionError_SourceSubscriptionErrors extends Message<SubscriptionError_SourceSubscriptionErrors> {
+  /**
+   * @generated from field: repeated norsk.api.media.SourceSubscriptionError errors = 1;
+   */
+  errors: SourceSubscriptionError[] = [];
+
+  constructor(data?: PartialMessage<SubscriptionError_SourceSubscriptionErrors>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SubscriptionError.SourceSubscriptionErrors";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "errors", kind: "message", T: SourceSubscriptionError, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscriptionError_SourceSubscriptionErrors {
+    return new SubscriptionError_SourceSubscriptionErrors().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubscriptionError_SourceSubscriptionErrors {
+    return new SubscriptionError_SourceSubscriptionErrors().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubscriptionError_SourceSubscriptionErrors {
+    return new SubscriptionError_SourceSubscriptionErrors().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SubscriptionError_SourceSubscriptionErrors | PlainMessage<SubscriptionError_SourceSubscriptionErrors> | undefined, b: SubscriptionError_SourceSubscriptionErrors | PlainMessage<SubscriptionError_SourceSubscriptionErrors> | undefined): boolean {
+    return proto3.util.equals(SubscriptionError_SourceSubscriptionErrors, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SourceSubscriptionError
+ */
+export class SourceSubscriptionError extends Message<SourceSubscriptionError> {
+  /**
+   * @generated from oneof norsk.api.media.SourceSubscriptionError.error
+   */
+  error: {
+    /**
+     * An opaque internal error
+     *
+     * @generated from field: string internal = 1;
+     */
+    value: string;
+    case: "internal";
+  } | {
+    /**
+     * The media node does not exist (maybe it crashed)
+     *
+     * @generated from field: norsk.api.media.MediaNodeId unknown_source_id = 2;
+     */
+    value: MediaNodeId;
+    case: "unknownSourceId";
+  } | {
+    /**
+     * The media node exists, but does not have the stream key
+     *
+     * @generated from field: norsk.api.media.SourceSubscriptionError.SourceStream unknown_source_stream = 3;
+     */
+    value: SourceSubscriptionError_SourceStream;
+    case: "unknownSourceStream";
+  } | {
+    /**
+     * The media node is not set up to receive data on this pin (which may be auto-detected)
+     *
+     * @generated from field: norsk.api.media.SourceSubscriptionError.NoSubscriberPin no_subscriber_pin = 4;
+     */
+    value: SourceSubscriptionError_NoSubscriberPin;
+    case: "noSubscriberPin";
+  } | {
+    /**
+     * Norsk does not support conversion from the media types of the source to the media types accepted by the subscriber
+     *
+     * @generated from field: norsk.api.media.SourceSubscriptionError.UnsupportedConversion unsupported_conversion = 5;
+     */
+    value: SourceSubscriptionError_UnsupportedConversion;
+    case: "unsupportedConversion";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<SourceSubscriptionError>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SourceSubscriptionError";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "internal", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "error" },
+    { no: 2, name: "unknown_source_id", kind: "message", T: MediaNodeId, oneof: "error" },
+    { no: 3, name: "unknown_source_stream", kind: "message", T: SourceSubscriptionError_SourceStream, oneof: "error" },
+    { no: 4, name: "no_subscriber_pin", kind: "message", T: SourceSubscriptionError_NoSubscriberPin, oneof: "error" },
+    { no: 5, name: "unsupported_conversion", kind: "message", T: SourceSubscriptionError_UnsupportedConversion, oneof: "error" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SourceSubscriptionError {
+    return new SourceSubscriptionError().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SourceSubscriptionError {
+    return new SourceSubscriptionError().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SourceSubscriptionError {
+    return new SourceSubscriptionError().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SourceSubscriptionError | PlainMessage<SourceSubscriptionError> | undefined, b: SourceSubscriptionError | PlainMessage<SourceSubscriptionError> | undefined): boolean {
+    return proto3.util.equals(SourceSubscriptionError, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SourceSubscriptionError.SourceStream
+ */
+export class SourceSubscriptionError_SourceStream extends Message<SourceSubscriptionError_SourceStream> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId media_node_id = 1;
+   */
+  mediaNodeId?: MediaNodeId;
+
+  /**
+   * @generated from field: norsk.api.media.StreamKey stream_key = 2;
+   */
+  streamKey?: StreamKey;
+
+  constructor(data?: PartialMessage<SourceSubscriptionError_SourceStream>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SourceSubscriptionError.SourceStream";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "media_node_id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "stream_key", kind: "message", T: StreamKey },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SourceSubscriptionError_SourceStream {
+    return new SourceSubscriptionError_SourceStream().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SourceSubscriptionError_SourceStream {
+    return new SourceSubscriptionError_SourceStream().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SourceSubscriptionError_SourceStream {
+    return new SourceSubscriptionError_SourceStream().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SourceSubscriptionError_SourceStream | PlainMessage<SourceSubscriptionError_SourceStream> | undefined, b: SourceSubscriptionError_SourceStream | PlainMessage<SourceSubscriptionError_SourceStream> | undefined): boolean {
+    return proto3.util.equals(SourceSubscriptionError_SourceStream, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SourceSubscriptionError.NoSubscriberPin
+ */
+export class SourceSubscriptionError_NoSubscriberPin extends Message<SourceSubscriptionError_NoSubscriberPin> {
+  /**
+   * @generated from field: norsk.api.media.SourceSubscriptionError.SourceStream source_stream = 1;
+   */
+  sourceStream?: SourceSubscriptionError_SourceStream;
+
+  /**
+   * @generated from field: string pin = 2;
+   */
+  pin = "";
+
+  /**
+   * @generated from field: repeated string subscriber_pins = 3;
+   */
+  subscriberPins: string[] = [];
+
+  constructor(data?: PartialMessage<SourceSubscriptionError_NoSubscriberPin>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SourceSubscriptionError.NoSubscriberPin";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "source_stream", kind: "message", T: SourceSubscriptionError_SourceStream },
+    { no: 2, name: "pin", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "subscriber_pins", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SourceSubscriptionError_NoSubscriberPin {
+    return new SourceSubscriptionError_NoSubscriberPin().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SourceSubscriptionError_NoSubscriberPin {
+    return new SourceSubscriptionError_NoSubscriberPin().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SourceSubscriptionError_NoSubscriberPin {
+    return new SourceSubscriptionError_NoSubscriberPin().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SourceSubscriptionError_NoSubscriberPin | PlainMessage<SourceSubscriptionError_NoSubscriberPin> | undefined, b: SourceSubscriptionError_NoSubscriberPin | PlainMessage<SourceSubscriptionError_NoSubscriberPin> | undefined): boolean {
+    return proto3.util.equals(SourceSubscriptionError_NoSubscriberPin, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SourceSubscriptionError.UnsupportedConversion
+ */
+export class SourceSubscriptionError_UnsupportedConversion extends Message<SourceSubscriptionError_UnsupportedConversion> {
+  /**
+   * @generated from field: norsk.api.media.SourceSubscriptionError.SourceStream source_stream = 1;
+   */
+  sourceStream?: SourceSubscriptionError_SourceStream;
+
+  /**
+   * @generated from field: repeated string source_types = 2;
+   */
+  sourceTypes: string[] = [];
+
+  /**
+   * @generated from field: repeated string subscriber_types = 3;
+   */
+  subscriberTypes: string[] = [];
+
+  constructor(data?: PartialMessage<SourceSubscriptionError_UnsupportedConversion>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SourceSubscriptionError.UnsupportedConversion";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "source_stream", kind: "message", T: SourceSubscriptionError_SourceStream },
+    { no: 2, name: "source_types", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+    { no: 3, name: "subscriber_types", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SourceSubscriptionError_UnsupportedConversion {
+    return new SourceSubscriptionError_UnsupportedConversion().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SourceSubscriptionError_UnsupportedConversion {
+    return new SourceSubscriptionError_UnsupportedConversion().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SourceSubscriptionError_UnsupportedConversion {
+    return new SourceSubscriptionError_UnsupportedConversion().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SourceSubscriptionError_UnsupportedConversion | PlainMessage<SourceSubscriptionError_UnsupportedConversion> | undefined, b: SourceSubscriptionError_UnsupportedConversion | PlainMessage<SourceSubscriptionError_UnsupportedConversion> | undefined): boolean {
+    return proto3.util.equals(SourceSubscriptionError_UnsupportedConversion, a, b);
+  }
+}
+
 /**
  * `Struct` represents a structured data value, consisting of fields
  * which map to dynamically typed values. In some languages, `Struct`