@norskvideo/norsk-api 0.0.329 → 1.0.331

package/lib/media_pb.d.ts

@@ -371,18 +371,26 @@ export declare enum SampleRate {
  */
 export declare 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
@@ -1717,11 +1725,11 @@ export declare class StreamMetadata_SubtitleMetadata extends Message<StreamMetad
 }
 /**
  * *
- * 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
@@ -1872,33 +1880,33 @@ export declare class TimestampSourceProgramNudge extends Message<TimestampSource
  * 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 StreamStatistics node.
  *
- * @generated from message norsk.api.media.MultiStreamStats
+ * @generated from message norsk.api.media.MultiStreamStatistics
  */
-export declare class MultiStreamStats extends Message<MultiStreamStats> {
+export declare class MultiStreamStatistics extends Message<MultiStreamStatistics> {
     /**
      * @generated from field: double sample_size_seconds = 1;
      */
     sampleSizeSeconds: number;
     /**
-     * @generated from field: repeated norsk.api.media.MultiStreamStats.SingleStreamStats all_streams = 2;
+     * @generated from field: repeated norsk.api.media.MultiStreamStatistics.SingleStreamStatistics all_streams = 2;
      */
-    allStreams: MultiStreamStats_SingleStreamStats[];
-    constructor(data?: PartialMessage<MultiStreamStats>);
+    allStreams: MultiStreamStatistics_SingleStreamStatistics[];
+    constructor(data?: PartialMessage<MultiStreamStatistics>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.MultiStreamStats";
+    static readonly typeName = "norsk.api.media.MultiStreamStatistics";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MultiStreamStats;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MultiStreamStats;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MultiStreamStats;
-    static equals(a: MultiStreamStats | PlainMessage<MultiStreamStats> | undefined, b: MultiStreamStats | PlainMessage<MultiStreamStats> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MultiStreamStatistics;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MultiStreamStatistics;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MultiStreamStatistics;
+    static equals(a: MultiStreamStatistics | PlainMessage<MultiStreamStatistics> | undefined, b: MultiStreamStatistics | PlainMessage<MultiStreamStatistics> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.MultiStreamStats.SingleStreamStats
+ * @generated from message norsk.api.media.MultiStreamStatistics.SingleStreamStatistics
  */
-export declare class MultiStreamStats_SingleStreamStats extends Message<MultiStreamStats_SingleStreamStats> {
+export declare class MultiStreamStatistics_SingleStreamStatistics extends Message<MultiStreamStatistics_SingleStreamStatistics> {
     /**
      * @generated from field: norsk.api.media.StreamKey stream_key = 1;
      */
@@ -1915,31 +1923,31 @@ export declare class MultiStreamStats_SingleStreamStats extends Message<MultiStr
      * @generated from field: int32 key_frames_for_sample = 5;
      */
     keyFramesForSample: number;
-    constructor(data?: PartialMessage<MultiStreamStats_SingleStreamStats>);
+    constructor(data?: PartialMessage<MultiStreamStatistics_SingleStreamStatistics>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.MultiStreamStats.SingleStreamStats";
+    static readonly typeName = "norsk.api.media.MultiStreamStatistics.SingleStreamStatistics";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MultiStreamStats_SingleStreamStats;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MultiStreamStats_SingleStreamStats;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MultiStreamStats_SingleStreamStats;
-    static equals(a: MultiStreamStats_SingleStreamStats | PlainMessage<MultiStreamStats_SingleStreamStats> | undefined, b: MultiStreamStats_SingleStreamStats | PlainMessage<MultiStreamStats_SingleStreamStats> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MultiStreamStatistics_SingleStreamStatistics;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MultiStreamStatistics_SingleStreamStatistics;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MultiStreamStatistics_SingleStreamStatistics;
+    static equals(a: MultiStreamStatistics_SingleStreamStatistics | PlainMessage<MultiStreamStatistics_SingleStreamStatistics> | undefined, b: MultiStreamStatistics_SingleStreamStatistics | PlainMessage<MultiStreamStatistics_SingleStreamStatistics> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.StreamStatsSampling
+ * @generated from message norsk.api.media.StreamStatisticsSampling
  */
-export declare class StreamStatsSampling extends Message<StreamStatsSampling> {
+export declare class StreamStatisticsSampling extends Message<StreamStatisticsSampling> {
     /**
      * @generated from field: repeated double sample_intervals_seconds = 3;
      */
     sampleIntervalsSeconds: number[];
-    constructor(data?: PartialMessage<StreamStatsSampling>);
+    constructor(data?: PartialMessage<StreamStatisticsSampling>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.StreamStatsSampling";
+    static readonly typeName = "norsk.api.media.StreamStatisticsSampling";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamStatsSampling;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamStatsSampling;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamStatsSampling;
-    static equals(a: StreamStatsSampling | PlainMessage<StreamStatsSampling> | undefined, b: StreamStatsSampling | PlainMessage<StreamStatsSampling> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamStatisticsSampling;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamStatisticsSampling;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamStatisticsSampling;
+    static equals(a: StreamStatisticsSampling | PlainMessage<StreamStatisticsSampling> | undefined, b: StreamStatisticsSampling | PlainMessage<StreamStatisticsSampling> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.ConnectionId
@@ -1963,9 +1971,9 @@ export declare class ConnectionId extends Message<ConnectionId> {
  * Configure an RTMP Input Media Node.  Should
  * be sent once, after the node has been created.
  *
- * @generated from message norsk.api.media.RtmpInputConfiguration
+ * @generated from message norsk.api.media.RtmpServerInputConfiguration
  */
-export declare class RtmpInputConfiguration extends Message<RtmpInputConfiguration> {
+export declare class RtmpServerInputConfiguration extends Message<RtmpServerInputConfiguration> {
     /**
      * The Media Node Id
      *
@@ -1979,17 +1987,17 @@ export declare class RtmpInputConfiguration extends Message<RtmpInputConfigurati
      */
     port: number;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 3;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 3;
      */
-    statsSampling?: StreamStatsSampling;
-    constructor(data?: PartialMessage<RtmpInputConfiguration>);
+    statsSampling?: StreamStatisticsSampling;
+    constructor(data?: PartialMessage<RtmpServerInputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.RtmpInputConfiguration";
+    static readonly typeName = "norsk.api.media.RtmpServerInputConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpInputConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtmpInputConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtmpInputConfiguration;
-    static equals(a: RtmpInputConfiguration | PlainMessage<RtmpInputConfiguration> | undefined, b: RtmpInputConfiguration | PlainMessage<RtmpInputConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpServerInputConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtmpServerInputConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtmpServerInputConfiguration;
+    static equals(a: RtmpServerInputConfiguration | PlainMessage<RtmpServerInputConfiguration> | undefined, b: RtmpServerInputConfiguration | PlainMessage<RtmpServerInputConfiguration> | undefined): boolean;
 }
 /**
  * *
@@ -2106,17 +2114,17 @@ export declare class RtmpStreamReject extends Message<RtmpStreamReject> {
  * *
  * Messages that your code can send to the Norsk RTMP Input Media Node.
  *
- * @generated from message norsk.api.media.RtmpInputMessage
+ * @generated from message norsk.api.media.RtmpServerInputMessage
  */
-export declare class RtmpInputMessage extends Message<RtmpInputMessage> {
+export declare class RtmpServerInputMessage extends Message<RtmpServerInputMessage> {
     /**
-     * @generated from oneof norsk.api.media.RtmpInputMessage.message
+     * @generated from oneof norsk.api.media.RtmpServerInputMessage.message
      */
     message: {
         /**
-         * @generated from field: norsk.api.media.RtmpInputConfiguration initial_config = 1;
+         * @generated from field: norsk.api.media.RtmpServerInputConfiguration initial_config = 1;
          */
-        value: RtmpInputConfiguration;
+        value: RtmpServerInputConfiguration;
         case: "initialConfig";
     } | {
         /**
@@ -2152,20 +2160,20 @@ export declare class RtmpInputMessage extends Message<RtmpInputMessage> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<RtmpInputMessage>);
+    constructor(data?: PartialMessage<RtmpServerInputMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.RtmpInputMessage";
+    static readonly typeName = "norsk.api.media.RtmpServerInputMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpInputMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtmpInputMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtmpInputMessage;
-    static equals(a: RtmpInputMessage | PlainMessage<RtmpInputMessage> | undefined, b: RtmpInputMessage | PlainMessage<RtmpInputMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpServerInputMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtmpServerInputMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtmpServerInputMessage;
+    static equals(a: RtmpServerInputMessage | PlainMessage<RtmpServerInputMessage> | undefined, b: RtmpServerInputMessage | PlainMessage<RtmpServerInputMessage> | undefined): boolean;
 }
 /**
  * *
  * 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
  */
@@ -2202,30 +2210,30 @@ export declare class RtmpConnection extends Message<RtmpConnection> {
  * Sent to your code when an active RTMP connection changes state.
  * Currently, this is only to indicate that the remote client has disconnected.
  *
- * @generated from message norsk.api.media.RtmpInputStatus
+ * @generated from message norsk.api.media.RtmpServerInputStatus
  */
-export declare class RtmpInputStatus extends Message<RtmpInputStatus> {
+export declare class RtmpServerInputStatus extends Message<RtmpServerInputStatus> {
     /**
      * @generated from field: norsk.api.media.ConnectionId connection_id = 1;
      */
     connectionId?: ConnectionId;
     /**
-     * @generated from field: norsk.api.media.RtmpInputStatus.State state = 2;
+     * @generated from field: norsk.api.media.RtmpServerInputStatus.State state = 2;
      */
-    state: RtmpInputStatus_State;
-    constructor(data?: PartialMessage<RtmpInputStatus>);
+    state: RtmpServerInputStatus_State;
+    constructor(data?: PartialMessage<RtmpServerInputStatus>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.RtmpInputStatus";
+    static readonly typeName = "norsk.api.media.RtmpServerInputStatus";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpInputStatus;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtmpInputStatus;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtmpInputStatus;
-    static equals(a: RtmpInputStatus | PlainMessage<RtmpInputStatus> | undefined, b: RtmpInputStatus | PlainMessage<RtmpInputStatus> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpServerInputStatus;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtmpServerInputStatus;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtmpServerInputStatus;
+    static equals(a: RtmpServerInputStatus | PlainMessage<RtmpServerInputStatus> | undefined, b: RtmpServerInputStatus | PlainMessage<RtmpServerInputStatus> | undefined): boolean;
 }
 /**
- * @generated from enum norsk.api.media.RtmpInputStatus.State
+ * @generated from enum norsk.api.media.RtmpServerInputStatus.State
  */
-export declare enum RtmpInputStatus_State {
+export declare enum RtmpServerInputStatus_State {
     /**
      * @generated from enum value: DISCONNECTED = 0;
      */
@@ -2234,8 +2242,8 @@ export declare enum RtmpInputStatus_State {
 /**
  * *
  * 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
  */
@@ -2278,11 +2286,11 @@ export declare class RtmpOnStream extends Message<RtmpOnStream> {
  * Messages that Norsk can send to your code in response to various RTMP
  * events.
  *
- * @generated from message norsk.api.media.RtmpInputEvent
+ * @generated from message norsk.api.media.RtmpServerInputEvent
  */
-export declare class RtmpInputEvent extends Message<RtmpInputEvent> {
+export declare class RtmpServerInputEvent extends Message<RtmpServerInputEvent> {
     /**
-     * @generated from oneof norsk.api.media.RtmpInputEvent.message
+     * @generated from oneof norsk.api.media.RtmpServerInputEvent.message
      */
     message: {
         /**
@@ -2310,28 +2318,28 @@ export declare class RtmpInputEvent extends Message<RtmpInputEvent> {
         case: "outboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.RtmpInputStatus status = 5;
+         * @generated from field: norsk.api.media.RtmpServerInputStatus status = 5;
          */
-        value: RtmpInputStatus;
+        value: RtmpServerInputStatus;
         case: "status";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 6;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 6;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<RtmpInputEvent>);
+    constructor(data?: PartialMessage<RtmpServerInputEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.RtmpInputEvent";
+    static readonly typeName = "norsk.api.media.RtmpServerInputEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpInputEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtmpInputEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtmpInputEvent;
-    static equals(a: RtmpInputEvent | PlainMessage<RtmpInputEvent> | undefined, b: RtmpInputEvent | PlainMessage<RtmpInputEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RtmpServerInputEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RtmpServerInputEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RtmpServerInputEvent;
+    static equals(a: RtmpServerInputEvent | PlainMessage<RtmpServerInputEvent> | undefined, b: RtmpServerInputEvent | PlainMessage<RtmpServerInputEvent> | undefined): boolean;
 }
 /**
  * ////////////////////////////////////////////////////////////////////////////
@@ -2508,10 +2516,10 @@ export declare class TsInputEvent extends Message<TsInputEvent> {
         case: "outboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 5;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 5;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -2526,9 +2534,9 @@ export declare class TsInputEvent extends Message<TsInputEvent> {
     static equals(a: TsInputEvent | PlainMessage<TsInputEvent> | undefined, b: TsInputEvent | PlainMessage<TsInputEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TsFileInputConfiguration
+ * @generated from message norsk.api.media.FileTsInputConfiguration
  */
-export declare class TsFileInputConfiguration extends Message<TsFileInputConfiguration> {
+export declare class FileTsInputConfiguration extends Message<FileTsInputConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -2542,30 +2550,30 @@ export declare class TsFileInputConfiguration extends Message<TsFileInputConfigu
      */
     filename: string;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 4;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
      */
-    statsSampling?: StreamStatsSampling;
-    constructor(data?: PartialMessage<TsFileInputConfiguration>);
+    statsSampling?: StreamStatisticsSampling;
+    constructor(data?: PartialMessage<FileTsInputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TsFileInputConfiguration";
+    static readonly typeName = "norsk.api.media.FileTsInputConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TsFileInputConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TsFileInputConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TsFileInputConfiguration;
-    static equals(a: TsFileInputConfiguration | PlainMessage<TsFileInputConfiguration> | undefined, b: TsFileInputConfiguration | PlainMessage<TsFileInputConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileTsInputConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileTsInputConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileTsInputConfiguration;
+    static equals(a: FileTsInputConfiguration | PlainMessage<FileTsInputConfiguration> | undefined, b: FileTsInputConfiguration | PlainMessage<FileTsInputConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TsFileInputMessage
+ * @generated from message norsk.api.media.FileTsInputMessage
  */
-export declare class TsFileInputMessage extends Message<TsFileInputMessage> {
+export declare class FileTsInputMessage extends Message<FileTsInputMessage> {
     /**
-     * @generated from oneof norsk.api.media.TsFileInputMessage.message
+     * @generated from oneof norsk.api.media.FileTsInputMessage.message
      */
     message: {
         /**
-         * @generated from field: norsk.api.media.TsFileInputConfiguration initial_config = 1;
+         * @generated from field: norsk.api.media.FileTsInputConfiguration initial_config = 1;
          */
-        value: TsFileInputConfiguration;
+        value: FileTsInputConfiguration;
         case: "initialConfig";
     } | {
         /**
@@ -2577,45 +2585,45 @@ export declare class TsFileInputMessage extends Message<TsFileInputMessage> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<TsFileInputMessage>);
+    constructor(data?: PartialMessage<FileTsInputMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TsFileInputMessage";
+    static readonly typeName = "norsk.api.media.FileTsInputMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TsFileInputMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TsFileInputMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TsFileInputMessage;
-    static equals(a: TsFileInputMessage | PlainMessage<TsFileInputMessage> | undefined, b: TsFileInputMessage | PlainMessage<TsFileInputMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileTsInputMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileTsInputMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileTsInputMessage;
+    static equals(a: FileTsInputMessage | PlainMessage<FileTsInputMessage> | undefined, b: FileTsInputMessage | PlainMessage<FileTsInputMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TsFileInputEvent
+ * @generated from message norsk.api.media.FileTsInputEvent
  */
-export declare class TsFileInputEvent extends Message<TsFileInputEvent> {
+export declare class FileTsInputEvent extends Message<FileTsInputEvent> {
     /**
-     * @generated from oneof norsk.api.media.TsFileInputEvent.message
+     * @generated from oneof norsk.api.media.FileTsInputEvent.message
      */
     message: {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 1;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 1;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<TsFileInputEvent>);
+    constructor(data?: PartialMessage<FileTsInputEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TsFileInputEvent";
+    static readonly typeName = "norsk.api.media.FileTsInputEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TsFileInputEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TsFileInputEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TsFileInputEvent;
-    static equals(a: TsFileInputEvent | PlainMessage<TsFileInputEvent> | undefined, b: TsFileInputEvent | PlainMessage<TsFileInputEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileTsInputEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileTsInputEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileTsInputEvent;
+    static equals(a: FileTsInputEvent | PlainMessage<FileTsInputEvent> | undefined, b: FileTsInputEvent | PlainMessage<FileTsInputEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.WebVttFileInputConfiguration
+ * @generated from message norsk.api.media.FileWebVttInputConfiguration
  */
-export declare class WebVttFileInputConfiguration extends Message<WebVttFileInputConfiguration> {
+export declare class FileWebVttInputConfiguration extends Message<FileWebVttInputConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -2628,21 +2636,21 @@ export declare class WebVttFileInputConfiguration extends Message<WebVttFileInpu
      * @generated from field: string filename = 3;
      */
     filename: string;
-    constructor(data?: PartialMessage<WebVttFileInputConfiguration>);
+    constructor(data?: PartialMessage<FileWebVttInputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.WebVttFileInputConfiguration";
+    static readonly typeName = "norsk.api.media.FileWebVttInputConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebVttFileInputConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebVttFileInputConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebVttFileInputConfiguration;
-    static equals(a: WebVttFileInputConfiguration | PlainMessage<WebVttFileInputConfiguration> | undefined, b: WebVttFileInputConfiguration | PlainMessage<WebVttFileInputConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileWebVttInputConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileWebVttInputConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileWebVttInputConfiguration;
+    static equals(a: FileWebVttInputConfiguration | PlainMessage<FileWebVttInputConfiguration> | undefined, b: FileWebVttInputConfiguration | PlainMessage<FileWebVttInputConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.WebVttFileInputEvent
+ * @generated from message norsk.api.media.FileWebVttInputEvent
  */
-export declare class WebVttFileInputEvent extends Message<WebVttFileInputEvent> {
+export declare class FileWebVttInputEvent extends Message<FileWebVttInputEvent> {
     /**
-     * @generated from oneof norsk.api.media.WebVttFileInputEvent.message
+     * @generated from oneof norsk.api.media.FileWebVttInputEvent.message
      */
     message: {
         /**
@@ -2660,14 +2668,14 @@ export declare class WebVttFileInputEvent extends Message<WebVttFileInputEvent>
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<WebVttFileInputEvent>);
+    constructor(data?: PartialMessage<FileWebVttInputEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.WebVttFileInputEvent";
+    static readonly typeName = "norsk.api.media.FileWebVttInputEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebVttFileInputEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebVttFileInputEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebVttFileInputEvent;
-    static equals(a: WebVttFileInputEvent | PlainMessage<WebVttFileInputEvent> | undefined, b: WebVttFileInputEvent | PlainMessage<WebVttFileInputEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileWebVttInputEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileWebVttInputEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileWebVttInputEvent;
+    static equals(a: FileWebVttInputEvent | PlainMessage<FileWebVttInputEvent> | undefined, b: FileWebVttInputEvent | PlainMessage<FileWebVttInputEvent> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.SrtInputConfiguration
@@ -2704,9 +2712,9 @@ export declare class SrtInputConfiguration extends Message<SrtInputConfiguration
      */
     streamId?: OptionalString;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 8;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 8;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<SrtInputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.SrtInputConfiguration";
@@ -2792,7 +2800,7 @@ export declare class SrtTsContext extends Message<SrtTsContext> {
  */
 export declare 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;
      */
@@ -2967,10 +2975,10 @@ export declare class SrtInputEvent extends Message<SrtInputEvent> {
         case: "status";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 7;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 7;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -3005,9 +3013,9 @@ export declare class UdpTsInputConfiguration extends Message<UdpTsInputConfigura
      */
     port: number;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 5;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 5;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<UdpTsInputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.UdpTsInputConfiguration";
@@ -3058,10 +3066,10 @@ export declare class UdpTsInputEvent extends Message<UdpTsInputEvent> {
      */
     message: {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 1;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 1;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -3092,11 +3100,9 @@ export declare class M3u8MediaInputConfiguration extends Message<M3u8MediaInputC
      */
     url: string;
     /**
-     * Stuff here about modes/etc
-     *
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 4;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<M3u8MediaInputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.M3u8MediaInputConfiguration";
@@ -3147,10 +3153,10 @@ export declare class M3u8MediaInputEvent extends Message<M3u8MediaInputEvent> {
      */
     message: {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 1;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 1;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -3207,11 +3213,11 @@ export declare class TestCardVideoConfiguration extends Message<TestCardVideoCon
     static equals(a: TestCardVideoConfiguration | PlainMessage<TestCardVideoConfiguration> | undefined, b: TestCardVideoConfiguration | PlainMessage<TestCardVideoConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TestCardVideoGeneratorMessage
+ * @generated from message norsk.api.media.VideoTestCardGeneratorMessage
  */
-export declare class TestCardVideoGeneratorMessage extends Message<TestCardVideoGeneratorMessage> {
+export declare class VideoTestCardGeneratorMessage extends Message<VideoTestCardGeneratorMessage> {
     /**
-     * @generated from oneof norsk.api.media.TestCardVideoGeneratorMessage.message
+     * @generated from oneof norsk.api.media.VideoTestCardGeneratorMessage.message
      */
     message: {
         /**
@@ -3229,21 +3235,21 @@ export declare class TestCardVideoGeneratorMessage extends Message<TestCardVideo
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<TestCardVideoGeneratorMessage>);
+    constructor(data?: PartialMessage<VideoTestCardGeneratorMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TestCardVideoGeneratorMessage";
+    static readonly typeName = "norsk.api.media.VideoTestCardGeneratorMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TestCardVideoGeneratorMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TestCardVideoGeneratorMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TestCardVideoGeneratorMessage;
-    static equals(a: TestCardVideoGeneratorMessage | PlainMessage<TestCardVideoGeneratorMessage> | undefined, b: TestCardVideoGeneratorMessage | PlainMessage<TestCardVideoGeneratorMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoTestCardGeneratorMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoTestCardGeneratorMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoTestCardGeneratorMessage;
+    static equals(a: VideoTestCardGeneratorMessage | PlainMessage<VideoTestCardGeneratorMessage> | undefined, b: VideoTestCardGeneratorMessage | PlainMessage<VideoTestCardGeneratorMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TestCardVideoGeneratorEvent
+ * @generated from message norsk.api.media.VideoTestCardGeneratorEvent
  */
-export declare class TestCardVideoGeneratorEvent extends Message<TestCardVideoGeneratorEvent> {
+export declare class VideoTestCardGeneratorEvent extends Message<VideoTestCardGeneratorEvent> {
     /**
-     * @generated from oneof norsk.api.media.TestCardVideoGeneratorEvent.message
+     * @generated from oneof norsk.api.media.VideoTestCardGeneratorEvent.message
      */
     message: {
         /**
@@ -3267,14 +3273,14 @@ export declare class TestCardVideoGeneratorEvent extends Message<TestCardVideoGe
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<TestCardVideoGeneratorEvent>);
+    constructor(data?: PartialMessage<VideoTestCardGeneratorEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TestCardVideoGeneratorEvent";
+    static readonly typeName = "norsk.api.media.VideoTestCardGeneratorEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TestCardVideoGeneratorEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TestCardVideoGeneratorEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TestCardVideoGeneratorEvent;
-    static equals(a: TestCardVideoGeneratorEvent | PlainMessage<TestCardVideoGeneratorEvent> | undefined, b: TestCardVideoGeneratorEvent | PlainMessage<TestCardVideoGeneratorEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoTestCardGeneratorEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoTestCardGeneratorEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoTestCardGeneratorEvent;
+    static equals(a: VideoTestCardGeneratorEvent | PlainMessage<VideoTestCardGeneratorEvent> | undefined, b: VideoTestCardGeneratorEvent | PlainMessage<VideoTestCardGeneratorEvent> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.DeckLinkCardIndex
@@ -3326,9 +3332,9 @@ export declare class DeckLinkInputConfiguration extends Message<DeckLinkInputCon
      */
     pixelFormat: DeckLinkPixelFormat;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 8;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 8;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<DeckLinkInputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.DeckLinkInputConfiguration";
@@ -3391,10 +3397,10 @@ export declare class DeckLinkInputEvent extends Message<DeckLinkInputEvent> {
         case: "outboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 3;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 3;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -3409,9 +3415,9 @@ export declare class DeckLinkInputEvent extends Message<DeckLinkInputEvent> {
     static equals(a: DeckLinkInputEvent | PlainMessage<DeckLinkInputEvent> | undefined, b: DeckLinkInputEvent | PlainMessage<DeckLinkInputEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.ImageFileInputConfiguration
+ * @generated from message norsk.api.media.FileImageInputConfiguration
  */
-export declare class ImageFileInputConfiguration extends Message<ImageFileInputConfiguration> {
+export declare class FileImageInputConfiguration extends Message<FileImageInputConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -3425,26 +3431,26 @@ export declare class ImageFileInputConfiguration extends Message<ImageFileInputC
      */
     fileName: string;
     /**
-     * @generated from field: norsk.api.media.ImageFileInputConfiguration.ImageFormat image_format = 4;
+     * @generated from field: norsk.api.media.FileImageInputConfiguration.ImageFormat image_format = 4;
      */
-    imageFormat: ImageFileInputConfiguration_ImageFormat;
+    imageFormat: FileImageInputConfiguration_ImageFormat;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 5;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 5;
      */
-    statsSampling?: StreamStatsSampling;
-    constructor(data?: PartialMessage<ImageFileInputConfiguration>);
+    statsSampling?: StreamStatisticsSampling;
+    constructor(data?: PartialMessage<FileImageInputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.ImageFileInputConfiguration";
+    static readonly typeName = "norsk.api.media.FileImageInputConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ImageFileInputConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ImageFileInputConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ImageFileInputConfiguration;
-    static equals(a: ImageFileInputConfiguration | PlainMessage<ImageFileInputConfiguration> | undefined, b: ImageFileInputConfiguration | PlainMessage<ImageFileInputConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileImageInputConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileImageInputConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileImageInputConfiguration;
+    static equals(a: FileImageInputConfiguration | PlainMessage<FileImageInputConfiguration> | undefined, b: FileImageInputConfiguration | PlainMessage<FileImageInputConfiguration> | undefined): boolean;
 }
 /**
- * @generated from enum norsk.api.media.ImageFileInputConfiguration.ImageFormat
+ * @generated from enum norsk.api.media.FileImageInputConfiguration.ImageFormat
  */
-export declare enum ImageFileInputConfiguration_ImageFormat {
+export declare enum FileImageInputConfiguration_ImageFormat {
     /**
      * @generated from enum value: INFER = 0;
      */
@@ -3507,11 +3513,11 @@ export declare enum ImageFileInputConfiguration_ImageFormat {
     AVIF = 14
 }
 /**
- * @generated from message norsk.api.media.ImageFileInputEvent
+ * @generated from message norsk.api.media.FileImageInputEvent
  */
-export declare class ImageFileInputEvent extends Message<ImageFileInputEvent> {
+export declare class FileImageInputEvent extends Message<FileImageInputEvent> {
     /**
-     * @generated from oneof norsk.api.media.ImageFileInputEvent.message
+     * @generated from oneof norsk.api.media.FileImageInputEvent.message
      */
     message: {
         /**
@@ -3527,27 +3533,27 @@ export declare class ImageFileInputEvent extends Message<ImageFileInputEvent> {
         case: "outboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 3;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 3;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<ImageFileInputEvent>);
+    constructor(data?: PartialMessage<FileImageInputEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.ImageFileInputEvent";
+    static readonly typeName = "norsk.api.media.FileImageInputEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ImageFileInputEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ImageFileInputEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ImageFileInputEvent;
-    static equals(a: ImageFileInputEvent | PlainMessage<ImageFileInputEvent> | undefined, b: ImageFileInputEvent | PlainMessage<ImageFileInputEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileImageInputEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileImageInputEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileImageInputEvent;
+    static equals(a: FileImageInputEvent | PlainMessage<FileImageInputEvent> | undefined, b: FileImageInputEvent | PlainMessage<FileImageInputEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.Mp4FileInputConfiguration
+ * @generated from message norsk.api.media.FileMp4InputConfiguration
  */
-export declare class Mp4FileInputConfiguration extends Message<Mp4FileInputConfiguration> {
+export declare class FileMp4InputConfiguration extends Message<FileMp4InputConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -3561,30 +3567,30 @@ export declare class Mp4FileInputConfiguration extends Message<Mp4FileInputConfi
      */
     fileName: string;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 4;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
      */
-    statsSampling?: StreamStatsSampling;
-    constructor(data?: PartialMessage<Mp4FileInputConfiguration>);
+    statsSampling?: StreamStatisticsSampling;
+    constructor(data?: PartialMessage<FileMp4InputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.Mp4FileInputConfiguration";
+    static readonly typeName = "norsk.api.media.FileMp4InputConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mp4FileInputConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Mp4FileInputConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Mp4FileInputConfiguration;
-    static equals(a: Mp4FileInputConfiguration | PlainMessage<Mp4FileInputConfiguration> | undefined, b: Mp4FileInputConfiguration | PlainMessage<Mp4FileInputConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputConfiguration;
+    static equals(a: FileMp4InputConfiguration | PlainMessage<FileMp4InputConfiguration> | undefined, b: FileMp4InputConfiguration | PlainMessage<FileMp4InputConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.Mp4FileInputMessage
+ * @generated from message norsk.api.media.FileMp4InputMessage
  */
-export declare class Mp4FileInputMessage extends Message<Mp4FileInputMessage> {
+export declare class FileMp4InputMessage extends Message<FileMp4InputMessage> {
     /**
-     * @generated from oneof norsk.api.media.Mp4FileInputMessage.message
+     * @generated from oneof norsk.api.media.FileMp4InputMessage.message
      */
     message: {
         /**
-         * @generated from field: norsk.api.media.Mp4FileInputConfiguration initial_config = 1;
+         * @generated from field: norsk.api.media.FileMp4InputConfiguration initial_config = 1;
          */
-        value: Mp4FileInputConfiguration;
+        value: FileMp4InputConfiguration;
         case: "initialConfig";
     } | {
         /**
@@ -3596,36 +3602,36 @@ export declare class Mp4FileInputMessage extends Message<Mp4FileInputMessage> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<Mp4FileInputMessage>);
+    constructor(data?: PartialMessage<FileMp4InputMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.Mp4FileInputMessage";
+    static readonly typeName = "norsk.api.media.FileMp4InputMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mp4FileInputMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Mp4FileInputMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Mp4FileInputMessage;
-    static equals(a: Mp4FileInputMessage | PlainMessage<Mp4FileInputMessage> | undefined, b: Mp4FileInputMessage | PlainMessage<Mp4FileInputMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputMessage;
+    static equals(a: FileMp4InputMessage | PlainMessage<FileMp4InputMessage> | undefined, b: FileMp4InputMessage | PlainMessage<FileMp4InputMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.Mp4FileInputStatus
+ * @generated from message norsk.api.media.FileMp4InputStatus
  */
-export declare class Mp4FileInputStatus extends Message<Mp4FileInputStatus> {
+export declare class FileMp4InputStatus extends Message<FileMp4InputStatus> {
     /**
-     * @generated from field: norsk.api.media.Mp4FileInputStatus.State state = 1;
+     * @generated from field: norsk.api.media.FileMp4InputStatus.State state = 1;
      */
-    state: Mp4FileInputStatus_State;
-    constructor(data?: PartialMessage<Mp4FileInputStatus>);
+    state: FileMp4InputStatus_State;
+    constructor(data?: PartialMessage<FileMp4InputStatus>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.Mp4FileInputStatus";
+    static readonly typeName = "norsk.api.media.FileMp4InputStatus";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mp4FileInputStatus;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Mp4FileInputStatus;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Mp4FileInputStatus;
-    static equals(a: Mp4FileInputStatus | PlainMessage<Mp4FileInputStatus> | undefined, b: Mp4FileInputStatus | PlainMessage<Mp4FileInputStatus> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputStatus;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputStatus;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputStatus;
+    static equals(a: FileMp4InputStatus | PlainMessage<FileMp4InputStatus> | undefined, b: FileMp4InputStatus | PlainMessage<FileMp4InputStatus> | undefined): boolean;
 }
 /**
- * @generated from enum norsk.api.media.Mp4FileInputStatus.State
+ * @generated from enum norsk.api.media.FileMp4InputStatus.State
  */
-export declare enum Mp4FileInputStatus_State {
+export declare enum FileMp4InputStatus_State {
     /**
      * @generated from enum value: INPUT_STATUS_UNKNOWN = 0;
      */
@@ -3636,9 +3642,9 @@ export declare enum Mp4FileInputStatus_State {
     INPUT_STATUS_EOF = 1
 }
 /**
- * @generated from message norsk.api.media.Mp4FileInputInfo
+ * @generated from message norsk.api.media.FileMp4InputInfo
  */
-export declare class Mp4FileInputInfo extends Message<Mp4FileInputInfo> {
+export declare class FileMp4InputInfo extends Message<FileMp4InputInfo> {
     /**
      * @generated from field: norsk.api.media.OptionalInt byte_length = 1;
      */
@@ -3647,21 +3653,21 @@ export declare class Mp4FileInputInfo extends Message<Mp4FileInputInfo> {
      * @generated from field: norsk.api.media.OptionalInt duration_ms = 2;
      */
     durationMs?: OptionalInt;
-    constructor(data?: PartialMessage<Mp4FileInputInfo>);
+    constructor(data?: PartialMessage<FileMp4InputInfo>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.Mp4FileInputInfo";
+    static readonly typeName = "norsk.api.media.FileMp4InputInfo";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mp4FileInputInfo;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Mp4FileInputInfo;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Mp4FileInputInfo;
-    static equals(a: Mp4FileInputInfo | PlainMessage<Mp4FileInputInfo> | undefined, b: Mp4FileInputInfo | PlainMessage<Mp4FileInputInfo> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputInfo;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputInfo;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputInfo;
+    static equals(a: FileMp4InputInfo | PlainMessage<FileMp4InputInfo> | undefined, b: FileMp4InputInfo | PlainMessage<FileMp4InputInfo> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.Mp4FileInputEvent
+ * @generated from message norsk.api.media.FileMp4InputEvent
  */
-export declare class Mp4FileInputEvent extends Message<Mp4FileInputEvent> {
+export declare class FileMp4InputEvent extends Message<FileMp4InputEvent> {
     /**
-     * @generated from oneof norsk.api.media.Mp4FileInputEvent.message
+     * @generated from oneof norsk.api.media.FileMp4InputEvent.message
      */
     message: {
         /**
@@ -3677,41 +3683,41 @@ export declare class Mp4FileInputEvent extends Message<Mp4FileInputEvent> {
         case: "outboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.Mp4FileInputStatus status = 3;
+         * @generated from field: norsk.api.media.FileMp4InputStatus status = 3;
          */
-        value: Mp4FileInputStatus;
+        value: FileMp4InputStatus;
         case: "status";
     } | {
         /**
-         * @generated from field: norsk.api.media.Mp4FileInputInfo info = 4;
+         * @generated from field: norsk.api.media.FileMp4InputInfo info = 4;
          */
-        value: Mp4FileInputInfo;
+        value: FileMp4InputInfo;
         case: "info";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 5;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 5;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<Mp4FileInputEvent>);
+    constructor(data?: PartialMessage<FileMp4InputEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.Mp4FileInputEvent";
+    static readonly typeName = "norsk.api.media.FileMp4InputEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mp4FileInputEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Mp4FileInputEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Mp4FileInputEvent;
-    static equals(a: Mp4FileInputEvent | PlainMessage<Mp4FileInputEvent> | undefined, b: Mp4FileInputEvent | PlainMessage<Mp4FileInputEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4InputEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4InputEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4InputEvent;
+    static equals(a: FileMp4InputEvent | PlainMessage<FileMp4InputEvent> | undefined, b: FileMp4InputEvent | PlainMessage<FileMp4InputEvent> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.SineWave
  */
 export declare class SineWave extends Message<SineWave> {
     /**
-     * @generated from field: uint32 freq = 1;
+     * @generated from field: float freq = 1;
      */
     freq: number;
     constructor(data?: PartialMessage<SineWave>);
@@ -3843,9 +3849,9 @@ export declare class BrowserInputConfiguration extends Message<BrowserInputConfi
      */
     frameRate?: FrameRate;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 6;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 6;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<BrowserInputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.BrowserInputConfiguration";
@@ -4027,10 +4033,10 @@ export declare class BrowserEvent extends Message<BrowserEvent> {
         case: "onLoadError";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 5;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 5;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -4071,10 +4077,10 @@ export declare class BrowserInputEvent extends Message<BrowserInputEvent> {
         case: "browserEvent";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 4;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 4;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -4101,9 +4107,9 @@ export declare class WhipInputConfiguration extends Message<WhipInputConfigurati
      */
     sourceName: string;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 3;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 3;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<WhipInputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.WhipInputConfiguration";
@@ -4166,10 +4172,10 @@ export declare class WhipInputEvent extends Message<WhipInputEvent> {
         case: "outboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 3;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 3;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -4395,11 +4401,11 @@ export declare class PartId extends Message<PartId> {
     static equals(a: PartId | PlainMessage<PartId> | undefined, b: PartId | PlainMessage<PartId> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.ComposeVideoMessage
+ * @generated from message norsk.api.media.VideoComposeMessage
  */
-export declare class ComposeVideoMessage extends Message<ComposeVideoMessage> {
+export declare class VideoComposeMessage extends Message<VideoComposeMessage> {
     /**
-     * @generated from oneof norsk.api.media.ComposeVideoMessage.message
+     * @generated from oneof norsk.api.media.VideoComposeMessage.message
      */
     message: {
         /**
@@ -4409,36 +4415,36 @@ export declare class ComposeVideoMessage extends Message<ComposeVideoMessage> {
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.ComposeVideoConfiguration initial_config = 2;
+         * @generated from field: norsk.api.media.VideoComposeConfiguration initial_config = 2;
          */
-        value: ComposeVideoConfiguration;
+        value: VideoComposeConfiguration;
         case: "initialConfig";
     } | {
         /**
-         * @generated from field: norsk.api.media.ComposeVideoUpdateConfiguration update_config = 3;
+         * @generated from field: norsk.api.media.VideoComposeUpdateConfiguration update_config = 3;
          */
-        value: ComposeVideoUpdateConfiguration;
+        value: VideoComposeUpdateConfiguration;
         case: "updateConfig";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<ComposeVideoMessage>);
+    constructor(data?: PartialMessage<VideoComposeMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.ComposeVideoMessage";
+    static readonly typeName = "norsk.api.media.VideoComposeMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ComposeVideoMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ComposeVideoMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ComposeVideoMessage;
-    static equals(a: ComposeVideoMessage | PlainMessage<ComposeVideoMessage> | undefined, b: ComposeVideoMessage | PlainMessage<ComposeVideoMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoComposeMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoComposeMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoComposeMessage;
+    static equals(a: VideoComposeMessage | PlainMessage<VideoComposeMessage> | undefined, b: VideoComposeMessage | PlainMessage<VideoComposeMessage> | undefined): boolean;
 }
 /**
  * *
  * Configure a Compose Media Node.
  *
- * @generated from message norsk.api.media.ComposeVideoConfiguration
+ * @generated from message norsk.api.media.VideoComposeConfiguration
  */
-export declare class ComposeVideoConfiguration extends Message<ComposeVideoConfiguration> {
+export declare class VideoComposeConfiguration extends Message<VideoComposeConfiguration> {
     /**
      * The Media Node Id
      *
@@ -4487,9 +4493,9 @@ export declare class ComposeVideoConfiguration extends Message<ComposeVideoConfi
      * Output pixel format to use. If not specified, this will be chosen
      * automatically based on the sources present in the initial composition
      *
-     * @generated from field: norsk.api.media.ComposeVideoConfiguration.PixelFormat output_pixel_format = 6;
+     * @generated from field: norsk.api.media.VideoComposeConfiguration.PixelFormat output_pixel_format = 6;
      */
-    outputPixelFormat: ComposeVideoConfiguration_PixelFormat;
+    outputPixelFormat: VideoComposeConfiguration_PixelFormat;
     /**
      * Behaviour in the case of a missing stream used in an active composition
      * part. Note that this does not apply to the reference stream, but to every
@@ -4498,22 +4504,22 @@ export declare class ComposeVideoConfiguration extends Message<ComposeVideoConfi
      *
      * Missing means not present in the context or never having sent a frame.
      *
-     * @generated from field: norsk.api.media.ComposeVideoConfiguration.MissingStreamBehaviour missing_stream_behaviour = 7;
+     * @generated from field: norsk.api.media.VideoComposeConfiguration.MissingStreamBehaviour missing_stream_behaviour = 7;
      */
-    missingStreamBehaviour: ComposeVideoConfiguration_MissingStreamBehaviour;
-    constructor(data?: PartialMessage<ComposeVideoConfiguration>);
+    missingStreamBehaviour: VideoComposeConfiguration_MissingStreamBehaviour;
+    constructor(data?: PartialMessage<VideoComposeConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.ComposeVideoConfiguration";
+    static readonly typeName = "norsk.api.media.VideoComposeConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ComposeVideoConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ComposeVideoConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ComposeVideoConfiguration;
-    static equals(a: ComposeVideoConfiguration | PlainMessage<ComposeVideoConfiguration> | undefined, b: ComposeVideoConfiguration | PlainMessage<ComposeVideoConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoComposeConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoComposeConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoComposeConfiguration;
+    static equals(a: VideoComposeConfiguration | PlainMessage<VideoComposeConfiguration> | undefined, b: VideoComposeConfiguration | PlainMessage<VideoComposeConfiguration> | undefined): boolean;
 }
 /**
- * @generated from enum norsk.api.media.ComposeVideoConfiguration.PixelFormat
+ * @generated from enum norsk.api.media.VideoComposeConfiguration.PixelFormat
  */
-export declare enum ComposeVideoConfiguration_PixelFormat {
+export declare enum VideoComposeConfiguration_PixelFormat {
     /**
      * @generated from enum value: UNSPECIFIED = 0;
      */
@@ -4552,9 +4558,9 @@ export declare enum ComposeVideoConfiguration_PixelFormat {
     BGRA = 8
 }
 /**
- * @generated from enum norsk.api.media.ComposeVideoConfiguration.MissingStreamBehaviour
+ * @generated from enum norsk.api.media.VideoComposeConfiguration.MissingStreamBehaviour
  */
-export declare enum ComposeVideoConfiguration_MissingStreamBehaviour {
+export declare enum VideoComposeConfiguration_MissingStreamBehaviour {
     /**
      * @generated from enum value: UNSPECIFIED_BEHAVIOUR = 0;
      */
@@ -4574,30 +4580,30 @@ export declare enum ComposeVideoConfiguration_MissingStreamBehaviour {
     DROP_PART = 2
 }
 /**
- * @generated from message norsk.api.media.ComposeVideoUpdateConfiguration
+ * @generated from message norsk.api.media.VideoComposeUpdateConfiguration
  */
-export declare class ComposeVideoUpdateConfiguration extends Message<ComposeVideoUpdateConfiguration> {
+export declare class VideoComposeUpdateConfiguration extends Message<VideoComposeUpdateConfiguration> {
     /**
      * Update the parts (images/overlays) to include in the composition
      *
      * @generated from field: repeated norsk.api.media.ComposePart parts = 1;
      */
     parts: ComposePart[];
-    constructor(data?: PartialMessage<ComposeVideoUpdateConfiguration>);
+    constructor(data?: PartialMessage<VideoComposeUpdateConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.ComposeVideoUpdateConfiguration";
+    static readonly typeName = "norsk.api.media.VideoComposeUpdateConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ComposeVideoUpdateConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ComposeVideoUpdateConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ComposeVideoUpdateConfiguration;
-    static equals(a: ComposeVideoUpdateConfiguration | PlainMessage<ComposeVideoUpdateConfiguration> | undefined, b: ComposeVideoUpdateConfiguration | PlainMessage<ComposeVideoUpdateConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoComposeUpdateConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoComposeUpdateConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoComposeUpdateConfiguration;
+    static equals(a: VideoComposeUpdateConfiguration | PlainMessage<VideoComposeUpdateConfiguration> | undefined, b: VideoComposeUpdateConfiguration | PlainMessage<VideoComposeUpdateConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.ComposeVideoSourceEvent
+ * @generated from message norsk.api.media.VideoComposeSourceEvent
  */
-export declare class ComposeVideoSourceEvent extends Message<ComposeVideoSourceEvent> {
+export declare class VideoComposeSourceEvent extends Message<VideoComposeSourceEvent> {
     /**
-     * @generated from oneof norsk.api.media.ComposeVideoSourceEvent.message
+     * @generated from oneof norsk.api.media.VideoComposeSourceEvent.message
      */
     message: {
         /**
@@ -4627,14 +4633,14 @@ export declare class ComposeVideoSourceEvent extends Message<ComposeVideoSourceE
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<ComposeVideoSourceEvent>);
+    constructor(data?: PartialMessage<VideoComposeSourceEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.ComposeVideoSourceEvent";
+    static readonly typeName = "norsk.api.media.VideoComposeSourceEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ComposeVideoSourceEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ComposeVideoSourceEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ComposeVideoSourceEvent;
-    static equals(a: ComposeVideoSourceEvent | PlainMessage<ComposeVideoSourceEvent> | undefined, b: ComposeVideoSourceEvent | PlainMessage<ComposeVideoSourceEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoComposeSourceEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoComposeSourceEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoComposeSourceEvent;
+    static equals(a: VideoComposeSourceEvent | PlainMessage<VideoComposeSourceEvent> | undefined, b: VideoComposeSourceEvent | PlainMessage<VideoComposeSourceEvent> | undefined): boolean;
 }
 /**
  * Indicates that the transitions specified in the last config update have
@@ -4658,9 +4664,9 @@ export declare class TransitionComplete extends Message<TransitionComplete> {
  * *
  * Describe an audio source with the output gain mapping for a mixer.
  *
- * @generated from message norsk.api.media.AudioMixerSource
+ * @generated from message norsk.api.media.AudioMixSource
  */
-export declare class AudioMixerSource extends Message<AudioMixerSource> {
+export declare class AudioMixSource extends Message<AudioMixSource> {
     /**
      * Input pin for this source
      *
@@ -4673,21 +4679,21 @@ export declare class AudioMixerSource extends Message<AudioMixerSource> {
      * @generated from field: repeated norsk.api.media.Db channel_gains = 2;
      */
     channelGains: Db[];
-    constructor(data?: PartialMessage<AudioMixerSource>);
+    constructor(data?: PartialMessage<AudioMixSource>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioMixerSource";
+    static readonly typeName = "norsk.api.media.AudioMixSource";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixerSource;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixerSource;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixerSource;
-    static equals(a: AudioMixerSource | PlainMessage<AudioMixerSource> | undefined, b: AudioMixerSource | PlainMessage<AudioMixerSource> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixSource;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixSource;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixSource;
+    static equals(a: AudioMixSource | PlainMessage<AudioMixSource> | undefined, b: AudioMixSource | PlainMessage<AudioMixSource> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AudioMixerMessage
+ * @generated from message norsk.api.media.AudioMixMessage
  */
-export declare class AudioMixerMessage extends Message<AudioMixerMessage> {
+export declare class AudioMixMessage extends Message<AudioMixMessage> {
     /**
-     * @generated from oneof norsk.api.media.AudioMixerMessage.message
+     * @generated from oneof norsk.api.media.AudioMixMessage.message
      */
     message: {
         /**
@@ -4697,36 +4703,36 @@ export declare class AudioMixerMessage extends Message<AudioMixerMessage> {
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.AudioMixerConfiguration initial_config = 2;
+         * @generated from field: norsk.api.media.AudioMixConfiguration initial_config = 2;
          */
-        value: AudioMixerConfiguration;
+        value: AudioMixConfiguration;
         case: "initialConfig";
     } | {
         /**
-         * @generated from field: norsk.api.media.AudioMixerUpdateConfiguration update_config = 3;
+         * @generated from field: norsk.api.media.AudioMixUpdateConfiguration update_config = 3;
          */
-        value: AudioMixerUpdateConfiguration;
+        value: AudioMixUpdateConfiguration;
         case: "updateConfig";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<AudioMixerMessage>);
+    constructor(data?: PartialMessage<AudioMixMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioMixerMessage";
+    static readonly typeName = "norsk.api.media.AudioMixMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixerMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixerMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixerMessage;
-    static equals(a: AudioMixerMessage | PlainMessage<AudioMixerMessage> | undefined, b: AudioMixerMessage | PlainMessage<AudioMixerMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixMessage;
+    static equals(a: AudioMixMessage | PlainMessage<AudioMixMessage> | undefined, b: AudioMixMessage | PlainMessage<AudioMixMessage> | undefined): boolean;
 }
 /**
  * *
- * Configure an AudioMixer Media Node.
+ * Configure an AudioMix Media Node.
  *
- * @generated from message norsk.api.media.AudioMixerConfiguration
+ * @generated from message norsk.api.media.AudioMixConfiguration
  */
-export declare class AudioMixerConfiguration extends Message<AudioMixerConfiguration> {
+export declare class AudioMixConfiguration extends Message<AudioMixConfiguration> {
     /**
      * The Media Node Id
      *
@@ -4736,9 +4742,9 @@ export declare class AudioMixerConfiguration extends Message<AudioMixerConfigura
     /**
      * The audio sources to mix
      *
-     * @generated from field: repeated norsk.api.media.AudioMixerSource sources = 2;
+     * @generated from field: repeated norsk.api.media.AudioMixSource sources = 2;
      */
-    sources: AudioMixerSource[];
+    sources: AudioMixSource[];
     /**
      * The source name to use for the output stream
      *
@@ -4751,40 +4757,40 @@ export declare class AudioMixerConfiguration extends Message<AudioMixerConfigura
      * @generated from field: norsk.api.media.SampleRate sample_rate = 4;
      */
     sampleRate: SampleRate;
-    constructor(data?: PartialMessage<AudioMixerConfiguration>);
+    constructor(data?: PartialMessage<AudioMixConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioMixerConfiguration";
+    static readonly typeName = "norsk.api.media.AudioMixConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixerConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixerConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixerConfiguration;
-    static equals(a: AudioMixerConfiguration | PlainMessage<AudioMixerConfiguration> | undefined, b: AudioMixerConfiguration | PlainMessage<AudioMixerConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixConfiguration;
+    static equals(a: AudioMixConfiguration | PlainMessage<AudioMixConfiguration> | undefined, b: AudioMixConfiguration | PlainMessage<AudioMixConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AudioMixerUpdateConfiguration
+ * @generated from message norsk.api.media.AudioMixUpdateConfiguration
  */
-export declare class AudioMixerUpdateConfiguration extends Message<AudioMixerUpdateConfiguration> {
+export declare class AudioMixUpdateConfiguration extends Message<AudioMixUpdateConfiguration> {
     /**
      * The channels to include in the mix
      *
-     * @generated from field: repeated norsk.api.media.AudioMixerSource sources = 1;
+     * @generated from field: repeated norsk.api.media.AudioMixSource sources = 1;
      */
-    sources: AudioMixerSource[];
-    constructor(data?: PartialMessage<AudioMixerUpdateConfiguration>);
+    sources: AudioMixSource[];
+    constructor(data?: PartialMessage<AudioMixUpdateConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioMixerUpdateConfiguration";
+    static readonly typeName = "norsk.api.media.AudioMixUpdateConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixerUpdateConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixerUpdateConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixerUpdateConfiguration;
-    static equals(a: AudioMixerUpdateConfiguration | PlainMessage<AudioMixerUpdateConfiguration> | undefined, b: AudioMixerUpdateConfiguration | PlainMessage<AudioMixerUpdateConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixUpdateConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixUpdateConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixUpdateConfiguration;
+    static equals(a: AudioMixUpdateConfiguration | PlainMessage<AudioMixUpdateConfiguration> | undefined, b: AudioMixUpdateConfiguration | PlainMessage<AudioMixUpdateConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AudioMixerEvent
+ * @generated from message norsk.api.media.AudioMixEvent
  */
-export declare class AudioMixerEvent extends Message<AudioMixerEvent> {
+export declare class AudioMixEvent extends Message<AudioMixEvent> {
     /**
-     * @generated from oneof norsk.api.media.AudioMixerEvent.message
+     * @generated from oneof norsk.api.media.AudioMixEvent.message
      */
     message: {
         /**
@@ -4808,21 +4814,21 @@ export declare class AudioMixerEvent extends Message<AudioMixerEvent> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<AudioMixerEvent>);
+    constructor(data?: PartialMessage<AudioMixEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioMixerEvent";
+    static readonly typeName = "norsk.api.media.AudioMixEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixerEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixerEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixerEvent;
-    static equals(a: AudioMixerEvent | PlainMessage<AudioMixerEvent> | undefined, b: AudioMixerEvent | PlainMessage<AudioMixerEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixEvent;
+    static equals(a: AudioMixEvent | PlainMessage<AudioMixEvent> | undefined, b: AudioMixEvent | PlainMessage<AudioMixEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AudioMatrixMixerMessage
+ * @generated from message norsk.api.media.AudioMixMatrixMessage
  */
-export declare class AudioMatrixMixerMessage extends Message<AudioMatrixMixerMessage> {
+export declare class AudioMixMatrixMessage extends Message<AudioMixMatrixMessage> {
     /**
-     * @generated from oneof norsk.api.media.AudioMatrixMixerMessage.message
+     * @generated from oneof norsk.api.media.AudioMixMatrixMessage.message
      */
     message: {
         /**
@@ -4832,28 +4838,28 @@ export declare class AudioMatrixMixerMessage extends Message<AudioMatrixMixerMes
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.AudioMatrixMixerConfiguration initial_config = 2;
+         * @generated from field: norsk.api.media.AudioMixMatrixConfiguration initial_config = 2;
          */
-        value: AudioMatrixMixerConfiguration;
+        value: AudioMixMatrixConfiguration;
         case: "initialConfig";
     } | {
         /**
-         * @generated from field: norsk.api.media.AudioMatrixMixerUpdateConfiguration update_config = 3;
+         * @generated from field: norsk.api.media.AudioMixMatrixUpdateConfiguration update_config = 3;
          */
-        value: AudioMatrixMixerUpdateConfiguration;
+        value: AudioMixMatrixUpdateConfiguration;
         case: "updateConfig";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<AudioMatrixMixerMessage>);
+    constructor(data?: PartialMessage<AudioMixMatrixMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioMatrixMixerMessage";
+    static readonly typeName = "norsk.api.media.AudioMixMatrixMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMatrixMixerMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMatrixMixerMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMatrixMixerMessage;
-    static equals(a: AudioMatrixMixerMessage | PlainMessage<AudioMatrixMixerMessage> | undefined, b: AudioMatrixMixerMessage | PlainMessage<AudioMatrixMixerMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixMatrixMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixMatrixMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixMatrixMessage;
+    static equals(a: AudioMixMatrixMessage | PlainMessage<AudioMixMatrixMessage> | undefined, b: AudioMixMatrixMessage | PlainMessage<AudioMixMatrixMessage> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.ChannelGainMapping
@@ -4874,11 +4880,11 @@ export declare class ChannelGainMapping extends Message<ChannelGainMapping> {
 }
 /**
  * *
- * Configure an AudioMatrixMixerMedia Node.
+ * Configure an AudioMixMatrixMedia Node.
  *
- * @generated from message norsk.api.media.AudioMatrixMixerConfiguration
+ * @generated from message norsk.api.media.AudioMixMatrixConfiguration
  */
-export declare class AudioMatrixMixerConfiguration extends Message<AudioMatrixMixerConfiguration> {
+export declare class AudioMixMatrixConfiguration extends Message<AudioMixMatrixConfiguration> {
     /**
      * The Media Node Id
      *
@@ -4914,38 +4920,38 @@ export declare class AudioMatrixMixerConfiguration extends Message<AudioMatrixMi
      * @generated from field: repeated norsk.api.media.ChannelGainMapping channelGainMappings = 7;
      */
     channelGainMappings: ChannelGainMapping[];
-    constructor(data?: PartialMessage<AudioMatrixMixerConfiguration>);
+    constructor(data?: PartialMessage<AudioMixMatrixConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioMatrixMixerConfiguration";
+    static readonly typeName = "norsk.api.media.AudioMixMatrixConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMatrixMixerConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMatrixMixerConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMatrixMixerConfiguration;
-    static equals(a: AudioMatrixMixerConfiguration | PlainMessage<AudioMatrixMixerConfiguration> | undefined, b: AudioMatrixMixerConfiguration | PlainMessage<AudioMatrixMixerConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixMatrixConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixMatrixConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixMatrixConfiguration;
+    static equals(a: AudioMixMatrixConfiguration | PlainMessage<AudioMixMatrixConfiguration> | undefined, b: AudioMixMatrixConfiguration | PlainMessage<AudioMixMatrixConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AudioMatrixMixerUpdateConfiguration
+ * @generated from message norsk.api.media.AudioMixMatrixUpdateConfiguration
  */
-export declare class AudioMatrixMixerUpdateConfiguration extends Message<AudioMatrixMixerUpdateConfiguration> {
+export declare class AudioMixMatrixUpdateConfiguration extends Message<AudioMixMatrixUpdateConfiguration> {
     /**
      * @generated from field: repeated norsk.api.media.ChannelGainMapping channelGainMappings = 1;
      */
     channelGainMappings: ChannelGainMapping[];
-    constructor(data?: PartialMessage<AudioMatrixMixerUpdateConfiguration>);
+    constructor(data?: PartialMessage<AudioMixMatrixUpdateConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioMatrixMixerUpdateConfiguration";
+    static readonly typeName = "norsk.api.media.AudioMixMatrixUpdateConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMatrixMixerUpdateConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMatrixMixerUpdateConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMatrixMixerUpdateConfiguration;
-    static equals(a: AudioMatrixMixerUpdateConfiguration | PlainMessage<AudioMatrixMixerUpdateConfiguration> | undefined, b: AudioMatrixMixerUpdateConfiguration | PlainMessage<AudioMatrixMixerUpdateConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixMatrixUpdateConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixMatrixUpdateConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixMatrixUpdateConfiguration;
+    static equals(a: AudioMixMatrixUpdateConfiguration | PlainMessage<AudioMixMatrixUpdateConfiguration> | undefined, b: AudioMixMatrixUpdateConfiguration | PlainMessage<AudioMixMatrixUpdateConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AudioMatrixMixerEvent
+ * @generated from message norsk.api.media.AudioMixMatrixEvent
  */
-export declare class AudioMatrixMixerEvent extends Message<AudioMatrixMixerEvent> {
+export declare class AudioMixMatrixEvent extends Message<AudioMixMatrixEvent> {
     /**
-     * @generated from oneof norsk.api.media.AudioMatrixMixerEvent.message
+     * @generated from oneof norsk.api.media.AudioMixMatrixEvent.message
      */
     message: {
         /**
@@ -4969,14 +4975,14 @@ export declare class AudioMatrixMixerEvent extends Message<AudioMatrixMixerEvent
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<AudioMatrixMixerEvent>);
+    constructor(data?: PartialMessage<AudioMixMatrixEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioMatrixMixerEvent";
+    static readonly typeName = "norsk.api.media.AudioMixMatrixEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMatrixMixerEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMatrixMixerEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMatrixMixerEvent;
-    static equals(a: AudioMatrixMixerEvent | PlainMessage<AudioMatrixMixerEvent> | undefined, b: AudioMatrixMixerEvent | PlainMessage<AudioMatrixMixerEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMixMatrixEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMixMatrixEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMixMatrixEvent;
+    static equals(a: AudioMixMatrixEvent | PlainMessage<AudioMixMatrixEvent> | undefined, b: AudioMixMatrixEvent | PlainMessage<AudioMixMatrixEvent> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.AudioGainMessage
@@ -5030,7 +5036,7 @@ export declare class AudioGainConfiguration extends Message<AudioGainConfigurati
      */
     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;
      */
@@ -5049,7 +5055,7 @@ export declare class AudioGainConfiguration extends Message<AudioGainConfigurati
  */
 export declare 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;
      */
@@ -5184,6 +5190,11 @@ export declare class AudioBuildMultichannelConfiguration extends Message<AudioBu
      */
     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[];
@@ -5489,9 +5500,9 @@ export declare class CMAFDestination extends Message<CMAFDestination> {
     static equals(a: CMAFDestination | PlainMessage<CMAFDestination> | undefined, b: CMAFDestination | PlainMessage<CMAFDestination> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.HlsVideoConfiguration
+ * @generated from message norsk.api.media.CmafVideoConfiguration
  */
-export declare class HlsVideoConfiguration extends Message<HlsVideoConfiguration> {
+export declare class CmafVideoConfiguration extends Message<CmafVideoConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -5513,28 +5524,28 @@ export declare class HlsVideoConfiguration extends Message<HlsVideoConfiguration
      */
     encryption?: Mp4Encryption;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 6;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 6;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     /**
      * @generated from field: repeated norsk.api.media.CMAFDestination destinations = 7;
      */
     destinations: CMAFDestination[];
-    constructor(data?: PartialMessage<HlsVideoConfiguration>);
+    constructor(data?: PartialMessage<CmafVideoConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.HlsVideoConfiguration";
+    static readonly typeName = "norsk.api.media.CmafVideoConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsVideoConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsVideoConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsVideoConfiguration;
-    static equals(a: HlsVideoConfiguration | PlainMessage<HlsVideoConfiguration> | undefined, b: HlsVideoConfiguration | PlainMessage<HlsVideoConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafVideoConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafVideoConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafVideoConfiguration;
+    static equals(a: CmafVideoConfiguration | PlainMessage<CmafVideoConfiguration> | undefined, b: CmafVideoConfiguration | PlainMessage<CmafVideoConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.HlsVideoMessage
+ * @generated from message norsk.api.media.CmafVideoMessage
  */
-export declare class HlsVideoMessage extends Message<HlsVideoMessage> {
+export declare class CmafVideoMessage extends Message<CmafVideoMessage> {
     /**
-     * @generated from oneof norsk.api.media.HlsVideoMessage.message
+     * @generated from oneof norsk.api.media.CmafVideoMessage.message
      */
     message: {
         /**
@@ -5544,9 +5555,9 @@ export declare 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";
     } | {
         /**
@@ -5558,14 +5569,14 @@ export declare class HlsVideoMessage extends Message<HlsVideoMessage> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<HlsVideoMessage>);
+    constructor(data?: PartialMessage<CmafVideoMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.HlsVideoMessage";
+    static readonly typeName = "norsk.api.media.CmafVideoMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsVideoMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsVideoMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsVideoMessage;
-    static equals(a: HlsVideoMessage | PlainMessage<HlsVideoMessage> | undefined, b: HlsVideoMessage | PlainMessage<HlsVideoMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafVideoMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafVideoMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafVideoMessage;
+    static equals(a: CmafVideoMessage | PlainMessage<CmafVideoMessage> | undefined, b: CmafVideoMessage | PlainMessage<CmafVideoMessage> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.HlsTsVideoConfiguration
@@ -5584,9 +5595,9 @@ export declare class HlsTsVideoConfiguration extends Message<HlsTsVideoConfigura
      */
     delayOutputMs: number;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 4;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<HlsTsVideoConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.HlsTsVideoConfiguration";
@@ -5629,9 +5640,9 @@ export declare class HlsTsVideoMessage extends Message<HlsTsVideoMessage> {
     static equals(a: HlsTsVideoMessage | PlainMessage<HlsTsVideoMessage> | undefined, b: HlsTsVideoMessage | PlainMessage<HlsTsVideoMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.HlsAudioConfiguration
+ * @generated from message norsk.api.media.CmafAudioConfiguration
  */
-export declare class HlsAudioConfiguration extends Message<HlsAudioConfiguration> {
+export declare class CmafAudioConfiguration extends Message<CmafAudioConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -5653,28 +5664,28 @@ export declare class HlsAudioConfiguration extends Message<HlsAudioConfiguration
      */
     encryption?: Mp4Encryption;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 7;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 7;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     /**
      * @generated from field: repeated norsk.api.media.CMAFDestination destinations = 8;
      */
     destinations: CMAFDestination[];
-    constructor(data?: PartialMessage<HlsAudioConfiguration>);
+    constructor(data?: PartialMessage<CmafAudioConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.HlsAudioConfiguration";
+    static readonly typeName = "norsk.api.media.CmafAudioConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsAudioConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsAudioConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsAudioConfiguration;
-    static equals(a: HlsAudioConfiguration | PlainMessage<HlsAudioConfiguration> | undefined, b: HlsAudioConfiguration | PlainMessage<HlsAudioConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafAudioConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafAudioConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafAudioConfiguration;
+    static equals(a: CmafAudioConfiguration | PlainMessage<CmafAudioConfiguration> | undefined, b: CmafAudioConfiguration | PlainMessage<CmafAudioConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.HlsAudioMessage
+ * @generated from message norsk.api.media.CmafAudioMessage
  */
-export declare class HlsAudioMessage extends Message<HlsAudioMessage> {
+export declare class CmafAudioMessage extends Message<CmafAudioMessage> {
     /**
-     * @generated from oneof norsk.api.media.HlsAudioMessage.message
+     * @generated from oneof norsk.api.media.CmafAudioMessage.message
      */
     message: {
         /**
@@ -5684,9 +5695,9 @@ export declare 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";
     } | {
         /**
@@ -5698,14 +5709,14 @@ export declare class HlsAudioMessage extends Message<HlsAudioMessage> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<HlsAudioMessage>);
+    constructor(data?: PartialMessage<CmafAudioMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.HlsAudioMessage";
+    static readonly typeName = "norsk.api.media.CmafAudioMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsAudioMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsAudioMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsAudioMessage;
-    static equals(a: HlsAudioMessage | PlainMessage<HlsAudioMessage> | undefined, b: HlsAudioMessage | PlainMessage<HlsAudioMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafAudioMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafAudioMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafAudioMessage;
+    static equals(a: CmafAudioMessage | PlainMessage<CmafAudioMessage> | undefined, b: CmafAudioMessage | PlainMessage<CmafAudioMessage> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.HlsTsAudioConfiguration
@@ -5724,9 +5735,9 @@ export declare class HlsTsAudioConfiguration extends Message<HlsTsAudioConfigura
      */
     delayOutputMs: number;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 4;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<HlsTsAudioConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.HlsTsAudioConfiguration";
@@ -5769,9 +5780,9 @@ export declare class HlsTsAudioMessage extends Message<HlsTsAudioMessage> {
     static equals(a: HlsTsAudioMessage | PlainMessage<HlsTsAudioMessage> | undefined, b: HlsTsAudioMessage | PlainMessage<HlsTsAudioMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.HlsWebVttConfiguration
+ * @generated from message norsk.api.media.CmafWebVttConfiguration
  */
-export declare class HlsWebVttConfiguration extends Message<HlsWebVttConfiguration> {
+export declare class CmafWebVttConfiguration extends Message<CmafWebVttConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -5788,14 +5799,14 @@ export declare class HlsWebVttConfiguration extends Message<HlsWebVttConfigurati
      * @generated from field: string sessionId = 4;
      */
     sessionId: string;
-    constructor(data?: PartialMessage<HlsWebVttConfiguration>);
+    constructor(data?: PartialMessage<CmafWebVttConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.HlsWebVttConfiguration";
+    static readonly typeName = "norsk.api.media.CmafWebVttConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsWebVttConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsWebVttConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsWebVttConfiguration;
-    static equals(a: HlsWebVttConfiguration | PlainMessage<HlsWebVttConfiguration> | undefined, b: HlsWebVttConfiguration | PlainMessage<HlsWebVttConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafWebVttConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafWebVttConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafWebVttConfiguration;
+    static equals(a: CmafWebVttConfiguration | PlainMessage<CmafWebVttConfiguration> | undefined, b: CmafWebVttConfiguration | PlainMessage<CmafWebVttConfiguration> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.AwsCredentials
@@ -5918,11 +5929,11 @@ export declare class HlsWebVttPushUpdateConfiguration extends Message<HlsWebVttP
     static equals(a: HlsWebVttPushUpdateConfiguration | PlainMessage<HlsWebVttPushUpdateConfiguration> | undefined, b: HlsWebVttPushUpdateConfiguration | PlainMessage<HlsWebVttPushUpdateConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.HlsWebVttMessage
+ * @generated from message norsk.api.media.CmafWebVttMessage
  */
-export declare class HlsWebVttMessage extends Message<HlsWebVttMessage> {
+export declare class CmafWebVttMessage extends Message<CmafWebVttMessage> {
     /**
-     * @generated from oneof norsk.api.media.HlsWebVttMessage.message
+     * @generated from oneof norsk.api.media.CmafWebVttMessage.message
      */
     message: {
         /**
@@ -5932,22 +5943,22 @@ export declare 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;
     };
-    constructor(data?: PartialMessage<HlsWebVttMessage>);
+    constructor(data?: PartialMessage<CmafWebVttMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.HlsWebVttMessage";
+    static readonly typeName = "norsk.api.media.CmafWebVttMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsWebVttMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsWebVttMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsWebVttMessage;
-    static equals(a: HlsWebVttMessage | PlainMessage<HlsWebVttMessage> | undefined, b: HlsWebVttMessage | PlainMessage<HlsWebVttMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafWebVttMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafWebVttMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafWebVttMessage;
+    static equals(a: CmafWebVttMessage | PlainMessage<CmafWebVttMessage> | undefined, b: CmafWebVttMessage | PlainMessage<CmafWebVttMessage> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.HlsWebVttPushMessage
@@ -5988,9 +5999,9 @@ export declare class HlsWebVttPushMessage extends Message<HlsWebVttPushMessage>
     static equals(a: HlsWebVttPushMessage | PlainMessage<HlsWebVttPushMessage> | undefined, b: HlsWebVttPushMessage | PlainMessage<HlsWebVttPushMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.HlsMasterConfiguration
+ * @generated from message norsk.api.media.CmafMasterConfiguration
  */
-export declare class HlsMasterConfiguration extends Message<HlsMasterConfiguration> {
+export declare class CmafMasterConfiguration extends Message<CmafMasterConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -6000,28 +6011,28 @@ export declare class HlsMasterConfiguration extends Message<HlsMasterConfigurati
      */
     playlistName: string;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 3;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 3;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     /**
      * @generated from field: repeated norsk.api.media.CMAFDestination destinations = 4;
      */
     destinations: CMAFDestination[];
-    constructor(data?: PartialMessage<HlsMasterConfiguration>);
+    constructor(data?: PartialMessage<CmafMasterConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.HlsMasterConfiguration";
+    static readonly typeName = "norsk.api.media.CmafMasterConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsMasterConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsMasterConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsMasterConfiguration;
-    static equals(a: HlsMasterConfiguration | PlainMessage<HlsMasterConfiguration> | undefined, b: HlsMasterConfiguration | PlainMessage<HlsMasterConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafMasterConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafMasterConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafMasterConfiguration;
+    static equals(a: CmafMasterConfiguration | PlainMessage<CmafMasterConfiguration> | undefined, b: CmafMasterConfiguration | PlainMessage<CmafMasterConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.HlsMasterMessage
+ * @generated from message norsk.api.media.CmafMasterMessage
  */
-export declare class HlsMasterMessage extends Message<HlsMasterMessage> {
+export declare class CmafMasterMessage extends Message<CmafMasterMessage> {
     /**
-     * @generated from oneof norsk.api.media.HlsMasterMessage.message
+     * @generated from oneof norsk.api.media.CmafMasterMessage.message
      */
     message: {
         /**
@@ -6031,9 +6042,9 @@ export declare 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";
     } | {
         /**
@@ -6045,14 +6056,14 @@ export declare class HlsMasterMessage extends Message<HlsMasterMessage> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<HlsMasterMessage>);
+    constructor(data?: PartialMessage<CmafMasterMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.HlsMasterMessage";
+    static readonly typeName = "norsk.api.media.CmafMasterMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsMasterMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HlsMasterMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HlsMasterMessage;
-    static equals(a: HlsMasterMessage | PlainMessage<HlsMasterMessage> | undefined, b: HlsMasterMessage | PlainMessage<HlsMasterMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafMasterMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CmafMasterMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CmafMasterMessage;
+    static equals(a: CmafMasterMessage | PlainMessage<CmafMasterMessage> | undefined, b: CmafMasterMessage | PlainMessage<CmafMasterMessage> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.HlsMasterPushConfiguration
@@ -6071,9 +6082,9 @@ export declare class HlsMasterPushConfiguration extends Message<HlsMasterPushCon
      */
     destination?: CMAFDestination;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 4;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<HlsMasterPushConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.HlsMasterPushConfiguration";
@@ -6136,9 +6147,9 @@ export declare class HlsTsVideoPushConfiguration extends Message<HlsTsVideoPushC
      */
     delayOutputMs: number;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 5;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 5;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<HlsTsVideoPushConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.HlsTsVideoPushConfiguration";
@@ -6201,9 +6212,9 @@ export declare class HlsTsAudioPushConfiguration extends Message<HlsTsAudioPushC
      */
     delayOutputMs: number;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 5;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 5;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<HlsTsAudioPushConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.HlsTsAudioPushConfiguration";
@@ -6270,9 +6281,9 @@ export declare class HlsTsCombinedPushConfiguration extends Message<HlsTsCombine
      */
     playlistName: string;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 6;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 6;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<HlsTsCombinedPushConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.HlsTsCombinedPushConfiguration";
@@ -6378,10 +6389,10 @@ export declare class HlsOutputEvent extends Message<HlsOutputEvent> {
         case: "inboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 4;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 4;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -6396,9 +6407,9 @@ export declare class HlsOutputEvent extends Message<HlsOutputEvent> {
     static equals(a: HlsOutputEvent | PlainMessage<HlsOutputEvent> | undefined, b: HlsOutputEvent | PlainMessage<HlsOutputEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TsUdpOutputConfiguration
+ * @generated from message norsk.api.media.UdpTsOutputConfiguration
  */
-export declare class TsUdpOutputConfiguration extends Message<TsUdpOutputConfiguration> {
+export declare class UdpTsOutputConfiguration extends Message<UdpTsOutputConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -6416,24 +6427,24 @@ export declare class TsUdpOutputConfiguration extends Message<TsUdpOutputConfigu
      */
     destinationPort: number;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 5;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 5;
      */
-    statsSampling?: StreamStatsSampling;
-    constructor(data?: PartialMessage<TsUdpOutputConfiguration>);
+    statsSampling?: StreamStatisticsSampling;
+    constructor(data?: PartialMessage<UdpTsOutputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TsUdpOutputConfiguration";
+    static readonly typeName = "norsk.api.media.UdpTsOutputConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TsUdpOutputConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TsUdpOutputConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TsUdpOutputConfiguration;
-    static equals(a: TsUdpOutputConfiguration | PlainMessage<TsUdpOutputConfiguration> | undefined, b: TsUdpOutputConfiguration | PlainMessage<TsUdpOutputConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UdpTsOutputConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UdpTsOutputConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UdpTsOutputConfiguration;
+    static equals(a: UdpTsOutputConfiguration | PlainMessage<UdpTsOutputConfiguration> | undefined, b: UdpTsOutputConfiguration | PlainMessage<UdpTsOutputConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TsUdpOutputMessage
+ * @generated from message norsk.api.media.UdpTsOutputMessage
  */
-export declare class TsUdpOutputMessage extends Message<TsUdpOutputMessage> {
+export declare class UdpTsOutputMessage extends Message<UdpTsOutputMessage> {
     /**
-     * @generated from oneof norsk.api.media.TsUdpOutputMessage.message
+     * @generated from oneof norsk.api.media.UdpTsOutputMessage.message
      */
     message: {
         /**
@@ -6443,29 +6454,29 @@ export declare class TsUdpOutputMessage extends Message<TsUdpOutputMessage> {
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.TsUdpOutputConfiguration configuration = 2;
+         * @generated from field: norsk.api.media.UdpTsOutputConfiguration configuration = 2;
          */
-        value: TsUdpOutputConfiguration;
+        value: UdpTsOutputConfiguration;
         case: "configuration";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<TsUdpOutputMessage>);
+    constructor(data?: PartialMessage<UdpTsOutputMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TsUdpOutputMessage";
+    static readonly typeName = "norsk.api.media.UdpTsOutputMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TsUdpOutputMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TsUdpOutputMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TsUdpOutputMessage;
-    static equals(a: TsUdpOutputMessage | PlainMessage<TsUdpOutputMessage> | undefined, b: TsUdpOutputMessage | PlainMessage<TsUdpOutputMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UdpTsOutputMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UdpTsOutputMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UdpTsOutputMessage;
+    static equals(a: UdpTsOutputMessage | PlainMessage<UdpTsOutputMessage> | undefined, b: UdpTsOutputMessage | PlainMessage<UdpTsOutputMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TsUdpOutputEvent
+ * @generated from message norsk.api.media.UdpTsOutputEvent
  */
-export declare class TsUdpOutputEvent extends Message<TsUdpOutputEvent> {
+export declare class UdpTsOutputEvent extends Message<UdpTsOutputEvent> {
     /**
-     * @generated from oneof norsk.api.media.TsUdpOutputEvent.message
+     * @generated from oneof norsk.api.media.UdpTsOutputEvent.message
      */
     message: {
         /**
@@ -6487,22 +6498,22 @@ export declare class TsUdpOutputEvent extends Message<TsUdpOutputEvent> {
         case: "inboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 4;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 4;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<TsUdpOutputEvent>);
+    constructor(data?: PartialMessage<UdpTsOutputEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TsUdpOutputEvent";
+    static readonly typeName = "norsk.api.media.UdpTsOutputEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TsUdpOutputEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TsUdpOutputEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TsUdpOutputEvent;
-    static equals(a: TsUdpOutputEvent | PlainMessage<TsUdpOutputEvent> | undefined, b: TsUdpOutputEvent | PlainMessage<TsUdpOutputEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UdpTsOutputEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UdpTsOutputEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UdpTsOutputEvent;
+    static equals(a: UdpTsOutputEvent | PlainMessage<UdpTsOutputEvent> | undefined, b: UdpTsOutputEvent | PlainMessage<UdpTsOutputEvent> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.SrtOutputConfiguration
@@ -6533,9 +6544,9 @@ export declare class SrtOutputConfiguration extends Message<SrtOutputConfigurati
      */
     streamId?: OptionalString;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 8;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 8;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<SrtOutputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.SrtOutputConfiguration";
@@ -6610,10 +6621,10 @@ export declare class SrtOutputEvent extends Message<SrtOutputEvent> {
         case: "onConnect";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 5;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 5;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -6628,9 +6639,9 @@ export declare class SrtOutputEvent extends Message<SrtOutputEvent> {
     static equals(a: SrtOutputEvent | PlainMessage<SrtOutputEvent> | undefined, b: SrtOutputEvent | PlainMessage<SrtOutputEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.WebRTCWhipOutputConfiguration
+ * @generated from message norsk.api.media.WhipOutputConfiguration
  */
-export declare class WebRTCWhipOutputConfiguration extends Message<WebRTCWhipOutputConfiguration> {
+export declare class WhipOutputConfiguration extends Message<WhipOutputConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -6644,24 +6655,24 @@ export declare class WebRTCWhipOutputConfiguration extends Message<WebRTCWhipOut
      */
     authHeader: string;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 4;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
      */
-    statsSampling?: StreamStatsSampling;
-    constructor(data?: PartialMessage<WebRTCWhipOutputConfiguration>);
+    statsSampling?: StreamStatisticsSampling;
+    constructor(data?: PartialMessage<WhipOutputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.WebRTCWhipOutputConfiguration";
+    static readonly typeName = "norsk.api.media.WhipOutputConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRTCWhipOutputConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRTCWhipOutputConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRTCWhipOutputConfiguration;
-    static equals(a: WebRTCWhipOutputConfiguration | PlainMessage<WebRTCWhipOutputConfiguration> | undefined, b: WebRTCWhipOutputConfiguration | PlainMessage<WebRTCWhipOutputConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhipOutputConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WhipOutputConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WhipOutputConfiguration;
+    static equals(a: WhipOutputConfiguration | PlainMessage<WhipOutputConfiguration> | undefined, b: WhipOutputConfiguration | PlainMessage<WhipOutputConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.WebRTCWhipOutputMessage
+ * @generated from message norsk.api.media.WhipOutputMessage
  */
-export declare class WebRTCWhipOutputMessage extends Message<WebRTCWhipOutputMessage> {
+export declare class WhipOutputMessage extends Message<WhipOutputMessage> {
     /**
-     * @generated from oneof norsk.api.media.WebRTCWhipOutputMessage.message
+     * @generated from oneof norsk.api.media.WhipOutputMessage.message
      */
     message: {
         /**
@@ -6671,50 +6682,50 @@ export declare class WebRTCWhipOutputMessage extends Message<WebRTCWhipOutputMes
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.WebRTCWhipOutputConfiguration configuration = 2;
+         * @generated from field: norsk.api.media.WhipOutputConfiguration configuration = 2;
          */
-        value: WebRTCWhipOutputConfiguration;
+        value: WhipOutputConfiguration;
         case: "configuration";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<WebRTCWhipOutputMessage>);
+    constructor(data?: PartialMessage<WhipOutputMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.WebRTCWhipOutputMessage";
+    static readonly typeName = "norsk.api.media.WhipOutputMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRTCWhipOutputMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRTCWhipOutputMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRTCWhipOutputMessage;
-    static equals(a: WebRTCWhipOutputMessage | PlainMessage<WebRTCWhipOutputMessage> | undefined, b: WebRTCWhipOutputMessage | PlainMessage<WebRTCWhipOutputMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhipOutputMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WhipOutputMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WhipOutputMessage;
+    static equals(a: WhipOutputMessage | PlainMessage<WhipOutputMessage> | undefined, b: WhipOutputMessage | PlainMessage<WhipOutputMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.WebRTCLocalOutputConfiguration
+ * @generated from message norsk.api.media.WebRTCBrowserDuplexConfiguration
  */
-export declare class WebRTCLocalOutputConfiguration extends Message<WebRTCLocalOutputConfiguration> {
+export declare class WebRTCBrowserDuplexConfiguration extends Message<WebRTCBrowserDuplexConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
     id?: MediaNodeId;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 2;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 2;
      */
-    statsSampling?: StreamStatsSampling;
-    constructor(data?: PartialMessage<WebRTCLocalOutputConfiguration>);
+    statsSampling?: StreamStatisticsSampling;
+    constructor(data?: PartialMessage<WebRTCBrowserDuplexConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.WebRTCLocalOutputConfiguration";
+    static readonly typeName = "norsk.api.media.WebRTCBrowserDuplexConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRTCLocalOutputConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRTCLocalOutputConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRTCLocalOutputConfiguration;
-    static equals(a: WebRTCLocalOutputConfiguration | PlainMessage<WebRTCLocalOutputConfiguration> | undefined, b: WebRTCLocalOutputConfiguration | PlainMessage<WebRTCLocalOutputConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRTCBrowserDuplexConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRTCBrowserDuplexConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRTCBrowserDuplexConfiguration;
+    static equals(a: WebRTCBrowserDuplexConfiguration | PlainMessage<WebRTCBrowserDuplexConfiguration> | undefined, b: WebRTCBrowserDuplexConfiguration | PlainMessage<WebRTCBrowserDuplexConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.WebRTCLocalOutputMessage
+ * @generated from message norsk.api.media.WebRTCBrowserDuplexMessage
  */
-export declare class WebRTCLocalOutputMessage extends Message<WebRTCLocalOutputMessage> {
+export declare class WebRTCBrowserDuplexMessage extends Message<WebRTCBrowserDuplexMessage> {
     /**
-     * @generated from oneof norsk.api.media.WebRTCLocalOutputMessage.message
+     * @generated from oneof norsk.api.media.WebRTCBrowserDuplexMessage.message
      */
     message: {
         /**
@@ -6724,29 +6735,29 @@ export declare class WebRTCLocalOutputMessage extends Message<WebRTCLocalOutputM
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.WebRTCLocalOutputConfiguration configuration = 2;
+         * @generated from field: norsk.api.media.WebRTCBrowserDuplexConfiguration configuration = 2;
          */
-        value: WebRTCLocalOutputConfiguration;
+        value: WebRTCBrowserDuplexConfiguration;
         case: "configuration";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<WebRTCLocalOutputMessage>);
+    constructor(data?: PartialMessage<WebRTCBrowserDuplexMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.WebRTCLocalOutputMessage";
+    static readonly typeName = "norsk.api.media.WebRTCBrowserDuplexMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRTCLocalOutputMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRTCLocalOutputMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRTCLocalOutputMessage;
-    static equals(a: WebRTCLocalOutputMessage | PlainMessage<WebRTCLocalOutputMessage> | undefined, b: WebRTCLocalOutputMessage | PlainMessage<WebRTCLocalOutputMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRTCBrowserDuplexMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRTCBrowserDuplexMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRTCBrowserDuplexMessage;
+    static equals(a: WebRTCBrowserDuplexMessage | PlainMessage<WebRTCBrowserDuplexMessage> | undefined, b: WebRTCBrowserDuplexMessage | PlainMessage<WebRTCBrowserDuplexMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.WebRTCWhipOutputEvent
+ * @generated from message norsk.api.media.WhipOutputEvent
  */
-export declare class WebRTCWhipOutputEvent extends Message<WebRTCWhipOutputEvent> {
+export declare class WhipOutputEvent extends Message<WhipOutputEvent> {
     /**
-     * @generated from oneof norsk.api.media.WebRTCWhipOutputEvent.message
+     * @generated from oneof norsk.api.media.WhipOutputEvent.message
      */
     message: {
         /**
@@ -6768,22 +6779,22 @@ export declare class WebRTCWhipOutputEvent extends Message<WebRTCWhipOutputEvent
         case: "inboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 4;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 4;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<WebRTCWhipOutputEvent>);
+    constructor(data?: PartialMessage<WhipOutputEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.WebRTCWhipOutputEvent";
+    static readonly typeName = "norsk.api.media.WhipOutputEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebRTCWhipOutputEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebRTCWhipOutputEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebRTCWhipOutputEvent;
-    static equals(a: WebRTCWhipOutputEvent | PlainMessage<WebRTCWhipOutputEvent> | undefined, b: WebRTCWhipOutputEvent | PlainMessage<WebRTCWhipOutputEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WhipOutputEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WhipOutputEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WhipOutputEvent;
+    static equals(a: WhipOutputEvent | PlainMessage<WhipOutputEvent> | undefined, b: WhipOutputEvent | PlainMessage<WhipOutputEvent> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.WebRTCBrowserDuplexEvent
@@ -6818,10 +6829,10 @@ export declare class WebRTCBrowserDuplexEvent extends Message<WebRTCBrowserDuple
         case: "outboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 5;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 5;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -6848,13 +6859,9 @@ export declare class RtmpOutputConfiguration extends Message<RtmpOutputConfigura
      */
     url: string;
     /**
-     * @generated from field: uint32 number_of_streams = 3;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 3;
      */
-    numberOfStreams: number;
-    /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 4;
-     */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<RtmpOutputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.RtmpOutputConfiguration";
@@ -6923,10 +6930,10 @@ export declare class RtmpOutputEvent extends Message<RtmpOutputEvent> {
         case: "inboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 4;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 4;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -6941,9 +6948,9 @@ export declare class RtmpOutputEvent extends Message<RtmpOutputEvent> {
     static equals(a: RtmpOutputEvent | PlainMessage<RtmpOutputEvent> | undefined, b: RtmpOutputEvent | PlainMessage<RtmpOutputEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TsFileOutputConfiguration
+ * @generated from message norsk.api.media.FileTsOutputConfiguration
  */
-export declare class TsFileOutputConfiguration extends Message<TsFileOutputConfiguration> {
+export declare class FileTsOutputConfiguration extends Message<FileTsOutputConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -6953,24 +6960,24 @@ export declare class TsFileOutputConfiguration extends Message<TsFileOutputConfi
      */
     fileName: string;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 3;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 3;
      */
-    statsSampling?: StreamStatsSampling;
-    constructor(data?: PartialMessage<TsFileOutputConfiguration>);
+    statsSampling?: StreamStatisticsSampling;
+    constructor(data?: PartialMessage<FileTsOutputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TsFileOutputConfiguration";
+    static readonly typeName = "norsk.api.media.FileTsOutputConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TsFileOutputConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TsFileOutputConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TsFileOutputConfiguration;
-    static equals(a: TsFileOutputConfiguration | PlainMessage<TsFileOutputConfiguration> | undefined, b: TsFileOutputConfiguration | PlainMessage<TsFileOutputConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileTsOutputConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileTsOutputConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileTsOutputConfiguration;
+    static equals(a: FileTsOutputConfiguration | PlainMessage<FileTsOutputConfiguration> | undefined, b: FileTsOutputConfiguration | PlainMessage<FileTsOutputConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TsFileOutputMessage
+ * @generated from message norsk.api.media.FileTsOutputMessage
  */
-export declare class TsFileOutputMessage extends Message<TsFileOutputMessage> {
+export declare class FileTsOutputMessage extends Message<FileTsOutputMessage> {
     /**
-     * @generated from oneof norsk.api.media.TsFileOutputMessage.message
+     * @generated from oneof norsk.api.media.FileTsOutputMessage.message
      */
     message: {
         /**
@@ -6980,29 +6987,29 @@ export declare class TsFileOutputMessage extends Message<TsFileOutputMessage> {
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.TsFileOutputConfiguration configuration = 2;
+         * @generated from field: norsk.api.media.FileTsOutputConfiguration configuration = 2;
          */
-        value: TsFileOutputConfiguration;
+        value: FileTsOutputConfiguration;
         case: "configuration";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<TsFileOutputMessage>);
+    constructor(data?: PartialMessage<FileTsOutputMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TsFileOutputMessage";
+    static readonly typeName = "norsk.api.media.FileTsOutputMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TsFileOutputMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TsFileOutputMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TsFileOutputMessage;
-    static equals(a: TsFileOutputMessage | PlainMessage<TsFileOutputMessage> | undefined, b: TsFileOutputMessage | PlainMessage<TsFileOutputMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileTsOutputMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileTsOutputMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileTsOutputMessage;
+    static equals(a: FileTsOutputMessage | PlainMessage<FileTsOutputMessage> | undefined, b: FileTsOutputMessage | PlainMessage<FileTsOutputMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TsFileOutputEvent
+ * @generated from message norsk.api.media.FileTsOutputEvent
  */
-export declare class TsFileOutputEvent extends Message<TsFileOutputEvent> {
+export declare class FileTsOutputEvent extends Message<FileTsOutputEvent> {
     /**
-     * @generated from oneof norsk.api.media.TsFileOutputEvent.message
+     * @generated from oneof norsk.api.media.FileTsOutputEvent.message
      */
     message: {
         /**
@@ -7024,27 +7031,27 @@ export declare class TsFileOutputEvent extends Message<TsFileOutputEvent> {
         case: "inboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 4;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 4;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<TsFileOutputEvent>);
+    constructor(data?: PartialMessage<FileTsOutputEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TsFileOutputEvent";
+    static readonly typeName = "norsk.api.media.FileTsOutputEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TsFileOutputEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TsFileOutputEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TsFileOutputEvent;
-    static equals(a: TsFileOutputEvent | PlainMessage<TsFileOutputEvent> | undefined, b: TsFileOutputEvent | PlainMessage<TsFileOutputEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileTsOutputEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileTsOutputEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileTsOutputEvent;
+    static equals(a: FileTsOutputEvent | PlainMessage<FileTsOutputEvent> | undefined, b: FileTsOutputEvent | PlainMessage<FileTsOutputEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.Mp4FileOutputConfiguration
+ * @generated from message norsk.api.media.FileMp4OutputConfiguration
  */
-export declare class Mp4FileOutputConfiguration extends Message<Mp4FileOutputConfiguration> {
+export declare class FileMp4OutputConfiguration extends Message<FileMp4OutputConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -7062,41 +7069,41 @@ export declare class Mp4FileOutputConfiguration extends Message<Mp4FileOutputCon
      */
     encryption?: Mp4Encryption;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 5;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 5;
      */
-    statsSampling?: StreamStatsSampling;
-    constructor(data?: PartialMessage<Mp4FileOutputConfiguration>);
+    statsSampling?: StreamStatisticsSampling;
+    constructor(data?: PartialMessage<FileMp4OutputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.Mp4FileOutputConfiguration";
+    static readonly typeName = "norsk.api.media.FileMp4OutputConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mp4FileOutputConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Mp4FileOutputConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Mp4FileOutputConfiguration;
-    static equals(a: Mp4FileOutputConfiguration | PlainMessage<Mp4FileOutputConfiguration> | undefined, b: Mp4FileOutputConfiguration | PlainMessage<Mp4FileOutputConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4OutputConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4OutputConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4OutputConfiguration;
+    static equals(a: FileMp4OutputConfiguration | PlainMessage<FileMp4OutputConfiguration> | undefined, b: FileMp4OutputConfiguration | PlainMessage<FileMp4OutputConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.Mp4FileOutputWriteMessage
+ * @generated from message norsk.api.media.FileMp4OutputWriteMessage
  */
-export declare class Mp4FileOutputWriteMessage extends Message<Mp4FileOutputWriteMessage> {
+export declare class FileMp4OutputWriteMessage extends Message<FileMp4OutputWriteMessage> {
     /**
      * @generated from field: string nonfragmented_file_name = 1;
      */
     nonfragmentedFileName: string;
-    constructor(data?: PartialMessage<Mp4FileOutputWriteMessage>);
+    constructor(data?: PartialMessage<FileMp4OutputWriteMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.Mp4FileOutputWriteMessage";
+    static readonly typeName = "norsk.api.media.FileMp4OutputWriteMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mp4FileOutputWriteMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Mp4FileOutputWriteMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Mp4FileOutputWriteMessage;
-    static equals(a: Mp4FileOutputWriteMessage | PlainMessage<Mp4FileOutputWriteMessage> | undefined, b: Mp4FileOutputWriteMessage | PlainMessage<Mp4FileOutputWriteMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4OutputWriteMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4OutputWriteMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4OutputWriteMessage;
+    static equals(a: FileMp4OutputWriteMessage | PlainMessage<FileMp4OutputWriteMessage> | undefined, b: FileMp4OutputWriteMessage | PlainMessage<FileMp4OutputWriteMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.Mp4FileOutputMessage
+ * @generated from message norsk.api.media.FileMp4OutputMessage
  */
-export declare class Mp4FileOutputMessage extends Message<Mp4FileOutputMessage> {
+export declare class FileMp4OutputMessage extends Message<FileMp4OutputMessage> {
     /**
-     * @generated from oneof norsk.api.media.Mp4FileOutputMessage.message
+     * @generated from oneof norsk.api.media.FileMp4OutputMessage.message
      */
     message: {
         /**
@@ -7106,35 +7113,35 @@ export declare class Mp4FileOutputMessage extends Message<Mp4FileOutputMessage>
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.Mp4FileOutputConfiguration configuration = 2;
+         * @generated from field: norsk.api.media.FileMp4OutputConfiguration configuration = 2;
          */
-        value: Mp4FileOutputConfiguration;
+        value: FileMp4OutputConfiguration;
         case: "configuration";
     } | {
         /**
-         * @generated from field: norsk.api.media.Mp4FileOutputWriteMessage writeFile = 3;
+         * @generated from field: norsk.api.media.FileMp4OutputWriteMessage write_file = 3;
          */
-        value: Mp4FileOutputWriteMessage;
+        value: FileMp4OutputWriteMessage;
         case: "writeFile";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<Mp4FileOutputMessage>);
+    constructor(data?: PartialMessage<FileMp4OutputMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.Mp4FileOutputMessage";
+    static readonly typeName = "norsk.api.media.FileMp4OutputMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mp4FileOutputMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Mp4FileOutputMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Mp4FileOutputMessage;
-    static equals(a: Mp4FileOutputMessage | PlainMessage<Mp4FileOutputMessage> | undefined, b: Mp4FileOutputMessage | PlainMessage<Mp4FileOutputMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4OutputMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4OutputMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4OutputMessage;
+    static equals(a: FileMp4OutputMessage | PlainMessage<FileMp4OutputMessage> | undefined, b: FileMp4OutputMessage | PlainMessage<FileMp4OutputMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.Mp4FileOutputEvent
+ * @generated from message norsk.api.media.FileMp4OutputEvent
  */
-export declare class Mp4FileOutputEvent extends Message<Mp4FileOutputEvent> {
+export declare class FileMp4OutputEvent extends Message<FileMp4OutputEvent> {
     /**
-     * @generated from oneof norsk.api.media.Mp4FileOutputEvent.message
+     * @generated from oneof norsk.api.media.FileMp4OutputEvent.message
      */
     message: {
         /**
@@ -7156,22 +7163,22 @@ export declare class Mp4FileOutputEvent extends Message<Mp4FileOutputEvent> {
         case: "inboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 4;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 4;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<Mp4FileOutputEvent>);
+    constructor(data?: PartialMessage<FileMp4OutputEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.Mp4FileOutputEvent";
+    static readonly typeName = "norsk.api.media.FileMp4OutputEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mp4FileOutputEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Mp4FileOutputEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Mp4FileOutputEvent;
-    static equals(a: Mp4FileOutputEvent | PlainMessage<Mp4FileOutputEvent> | undefined, b: Mp4FileOutputEvent | PlainMessage<Mp4FileOutputEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FileMp4OutputEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FileMp4OutputEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FileMp4OutputEvent;
+    static equals(a: FileMp4OutputEvent | PlainMessage<FileMp4OutputEvent> | undefined, b: FileMp4OutputEvent | PlainMessage<FileMp4OutputEvent> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.FrameRate
@@ -7322,8 +7329,8 @@ export declare class X264Codec extends Message<X264Codec> {
     profile: X264Codec_X264Profile;
     /**
      * 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;
@@ -7630,7 +7637,7 @@ export declare class X265Codec extends Message<X265Codec> {
     profile: X265Codec_X265Profile;
     /**
      * 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)
      *
@@ -7826,9 +7833,9 @@ export declare enum X265Codec_X265Tune {
     ANIMATION = 6
 }
 /**
- * @generated from message norsk.api.media.VideoEncodeLadderStream
+ * @generated from message norsk.api.media.VideoEncodeStream
  */
-export declare class VideoEncodeLadderStream extends Message<VideoEncodeLadderStream> {
+export declare class VideoEncodeStream extends Message<VideoEncodeStream> {
     /**
      * @generated from field: string name = 1;
      */
@@ -7846,7 +7853,7 @@ export declare class VideoEncodeLadderStream extends Message<VideoEncodeLadderSt
      */
     sampleAspectRatio?: SampleAspectRatio;
     /**
-     * @generated from oneof norsk.api.media.VideoEncodeLadderStream.codec
+     * @generated from oneof norsk.api.media.VideoEncodeStream.codec
      */
     codec: {
         /**
@@ -7888,42 +7895,42 @@ export declare class VideoEncodeLadderStream extends Message<VideoEncodeLadderSt
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<VideoEncodeLadderStream>);
+    constructor(data?: PartialMessage<VideoEncodeStream>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.VideoEncodeLadderStream";
+    static readonly typeName = "norsk.api.media.VideoEncodeStream";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncodeLadderStream;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoEncodeLadderStream;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoEncodeLadderStream;
-    static equals(a: VideoEncodeLadderStream | PlainMessage<VideoEncodeLadderStream> | undefined, b: VideoEncodeLadderStream | PlainMessage<VideoEncodeLadderStream> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncodeStream;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoEncodeStream;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoEncodeStream;
+    static equals(a: VideoEncodeStream | PlainMessage<VideoEncodeStream> | undefined, b: VideoEncodeStream | PlainMessage<VideoEncodeStream> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.VideoEncodeLadderConfiguration
+ * @generated from message norsk.api.media.VideoEncodeConfiguration
  */
-export declare class VideoEncodeLadderConfiguration extends Message<VideoEncodeLadderConfiguration> {
+export declare class VideoEncodeConfiguration extends Message<VideoEncodeConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
     id?: MediaNodeId;
     /**
-     * @generated from field: repeated norsk.api.media.VideoEncodeLadderStream streams = 2;
+     * @generated from field: repeated norsk.api.media.VideoEncodeStream streams = 2;
      */
-    streams: VideoEncodeLadderStream[];
-    constructor(data?: PartialMessage<VideoEncodeLadderConfiguration>);
+    streams: VideoEncodeStream[];
+    constructor(data?: PartialMessage<VideoEncodeConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.VideoEncodeLadderConfiguration";
+    static readonly typeName = "norsk.api.media.VideoEncodeConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncodeLadderConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoEncodeLadderConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoEncodeLadderConfiguration;
-    static equals(a: VideoEncodeLadderConfiguration | PlainMessage<VideoEncodeLadderConfiguration> | undefined, b: VideoEncodeLadderConfiguration | PlainMessage<VideoEncodeLadderConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncodeConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoEncodeConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoEncodeConfiguration;
+    static equals(a: VideoEncodeConfiguration | PlainMessage<VideoEncodeConfiguration> | undefined, b: VideoEncodeConfiguration | PlainMessage<VideoEncodeConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.VideoEncodeLadderMessage
+ * @generated from message norsk.api.media.VideoEncodeMessage
  */
-export declare class VideoEncodeLadderMessage extends Message<VideoEncodeLadderMessage> {
+export declare class VideoEncodeMessage extends Message<VideoEncodeMessage> {
     /**
-     * @generated from oneof norsk.api.media.VideoEncodeLadderMessage.message
+     * @generated from oneof norsk.api.media.VideoEncodeMessage.message
      */
     message: {
         /**
@@ -7933,29 +7940,29 @@ export declare class VideoEncodeLadderMessage extends Message<VideoEncodeLadderM
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.VideoEncodeLadderConfiguration configuration = 2;
+         * @generated from field: norsk.api.media.VideoEncodeConfiguration configuration = 2;
          */
-        value: VideoEncodeLadderConfiguration;
+        value: VideoEncodeConfiguration;
         case: "configuration";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<VideoEncodeLadderMessage>);
+    constructor(data?: PartialMessage<VideoEncodeMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.VideoEncodeLadderMessage";
+    static readonly typeName = "norsk.api.media.VideoEncodeMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncodeLadderMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoEncodeLadderMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoEncodeLadderMessage;
-    static equals(a: VideoEncodeLadderMessage | PlainMessage<VideoEncodeLadderMessage> | undefined, b: VideoEncodeLadderMessage | PlainMessage<VideoEncodeLadderMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncodeMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoEncodeMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoEncodeMessage;
+    static equals(a: VideoEncodeMessage | PlainMessage<VideoEncodeMessage> | undefined, b: VideoEncodeMessage | PlainMessage<VideoEncodeMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.VideoEncodeLadderEvent
+ * @generated from message norsk.api.media.VideoEncodeEvent
  */
-export declare class VideoEncodeLadderEvent extends Message<VideoEncodeLadderEvent> {
+export declare class VideoEncodeEvent extends Message<VideoEncodeEvent> {
     /**
-     * @generated from oneof norsk.api.media.VideoEncodeLadderEvent.message
+     * @generated from oneof norsk.api.media.VideoEncodeEvent.message
      */
     message: {
         /**
@@ -7979,14 +7986,14 @@ export declare class VideoEncodeLadderEvent extends Message<VideoEncodeLadderEve
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<VideoEncodeLadderEvent>);
+    constructor(data?: PartialMessage<VideoEncodeEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.VideoEncodeLadderEvent";
+    static readonly typeName = "norsk.api.media.VideoEncodeEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncodeLadderEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoEncodeLadderEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoEncodeLadderEvent;
-    static equals(a: VideoEncodeLadderEvent | PlainMessage<VideoEncodeLadderEvent> | undefined, b: VideoEncodeLadderEvent | PlainMessage<VideoEncodeLadderEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncodeEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VideoEncodeEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VideoEncodeEvent;
+    static equals(a: VideoEncodeEvent | PlainMessage<VideoEncodeEvent> | undefined, b: VideoEncodeEvent | PlainMessage<VideoEncodeEvent> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.NvidiaRateControl
@@ -8528,15 +8535,15 @@ export declare class VideoTransformEvent extends Message<VideoTransformEvent> {
     static equals(a: VideoTransformEvent | PlainMessage<VideoTransformEvent> | undefined, b: VideoTransformEvent | PlainMessage<VideoTransformEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.ChaosMonkeyConfiguration
+ * @generated from message norsk.api.media.StreamChaosMonkeyConfiguration
  */
-export declare class ChaosMonkeyConfiguration extends Message<ChaosMonkeyConfiguration> {
+export declare class StreamChaosMonkeyConfiguration extends Message<StreamChaosMonkeyConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
     id?: MediaNodeId;
     /**
-     * @generated from oneof norsk.api.media.ChaosMonkeyConfiguration.dropFramesMode
+     * @generated from oneof norsk.api.media.StreamChaosMonkeyConfiguration.dropFramesMode
      */
     dropFramesMode: {
         /**
@@ -8554,21 +8561,21 @@ export declare class ChaosMonkeyConfiguration extends Message<ChaosMonkeyConfigu
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<ChaosMonkeyConfiguration>);
+    constructor(data?: PartialMessage<StreamChaosMonkeyConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.ChaosMonkeyConfiguration";
+    static readonly typeName = "norsk.api.media.StreamChaosMonkeyConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ChaosMonkeyConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ChaosMonkeyConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ChaosMonkeyConfiguration;
-    static equals(a: ChaosMonkeyConfiguration | PlainMessage<ChaosMonkeyConfiguration> | undefined, b: ChaosMonkeyConfiguration | PlainMessage<ChaosMonkeyConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamChaosMonkeyConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamChaosMonkeyConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamChaosMonkeyConfiguration;
+    static equals(a: StreamChaosMonkeyConfiguration | PlainMessage<StreamChaosMonkeyConfiguration> | undefined, b: StreamChaosMonkeyConfiguration | PlainMessage<StreamChaosMonkeyConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.ChaosMonkeyMessage
+ * @generated from message norsk.api.media.StreamChaosMonkeyMessage
  */
-export declare class ChaosMonkeyMessage extends Message<ChaosMonkeyMessage> {
+export declare class StreamChaosMonkeyMessage extends Message<StreamChaosMonkeyMessage> {
     /**
-     * @generated from oneof norsk.api.media.ChaosMonkeyMessage.message
+     * @generated from oneof norsk.api.media.StreamChaosMonkeyMessage.message
      */
     message: {
         /**
@@ -8578,29 +8585,29 @@ export declare class ChaosMonkeyMessage extends Message<ChaosMonkeyMessage> {
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.ChaosMonkeyConfiguration configuration = 2;
+         * @generated from field: norsk.api.media.StreamChaosMonkeyConfiguration configuration = 2;
          */
-        value: ChaosMonkeyConfiguration;
+        value: StreamChaosMonkeyConfiguration;
         case: "configuration";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<ChaosMonkeyMessage>);
+    constructor(data?: PartialMessage<StreamChaosMonkeyMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.ChaosMonkeyMessage";
+    static readonly typeName = "norsk.api.media.StreamChaosMonkeyMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ChaosMonkeyMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ChaosMonkeyMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ChaosMonkeyMessage;
-    static equals(a: ChaosMonkeyMessage | PlainMessage<ChaosMonkeyMessage> | undefined, b: ChaosMonkeyMessage | PlainMessage<ChaosMonkeyMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamChaosMonkeyMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamChaosMonkeyMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamChaosMonkeyMessage;
+    static equals(a: StreamChaosMonkeyMessage | PlainMessage<StreamChaosMonkeyMessage> | undefined, b: StreamChaosMonkeyMessage | PlainMessage<StreamChaosMonkeyMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.ChaosMonkeyEvent
+ * @generated from message norsk.api.media.StreamChaosMonkeyEvent
  */
-export declare class ChaosMonkeyEvent extends Message<ChaosMonkeyEvent> {
+export declare class StreamChaosMonkeyEvent extends Message<StreamChaosMonkeyEvent> {
     /**
-     * @generated from oneof norsk.api.media.ChaosMonkeyEvent.message
+     * @generated from oneof norsk.api.media.StreamChaosMonkeyEvent.message
      */
     message: {
         /**
@@ -8624,19 +8631,19 @@ export declare class ChaosMonkeyEvent extends Message<ChaosMonkeyEvent> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<ChaosMonkeyEvent>);
+    constructor(data?: PartialMessage<StreamChaosMonkeyEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.ChaosMonkeyEvent";
+    static readonly typeName = "norsk.api.media.StreamChaosMonkeyEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ChaosMonkeyEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ChaosMonkeyEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ChaosMonkeyEvent;
-    static equals(a: ChaosMonkeyEvent | PlainMessage<ChaosMonkeyEvent> | undefined, b: ChaosMonkeyEvent | PlainMessage<ChaosMonkeyEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamChaosMonkeyEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamChaosMonkeyEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamChaosMonkeyEvent;
+    static equals(a: StreamChaosMonkeyEvent | PlainMessage<StreamChaosMonkeyEvent> | undefined, b: StreamChaosMonkeyEvent | PlainMessage<StreamChaosMonkeyEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TimestampNudgerConfiguration
+ * @generated from message norsk.api.media.StreamTimestampNudgeConfiguration
  */
-export declare class TimestampNudgerConfiguration extends Message<TimestampNudgerConfiguration> {
+export declare class StreamTimestampNudgeConfiguration extends Message<StreamTimestampNudgeConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -8645,27 +8652,27 @@ export declare class TimestampNudgerConfiguration extends Message<TimestampNudge
      * @generated from field: norsk.api.media.TimestampNudge nudge = 2;
      */
     nudge?: TimestampNudge;
-    constructor(data?: PartialMessage<TimestampNudgerConfiguration>);
+    constructor(data?: PartialMessage<StreamTimestampNudgeConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TimestampNudgerConfiguration";
+    static readonly typeName = "norsk.api.media.StreamTimestampNudgeConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TimestampNudgerConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TimestampNudgerConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TimestampNudgerConfiguration;
-    static equals(a: TimestampNudgerConfiguration | PlainMessage<TimestampNudgerConfiguration> | undefined, b: TimestampNudgerConfiguration | PlainMessage<TimestampNudgerConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamTimestampNudgeConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamTimestampNudgeConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamTimestampNudgeConfiguration;
+    static equals(a: StreamTimestampNudgeConfiguration | PlainMessage<StreamTimestampNudgeConfiguration> | undefined, b: StreamTimestampNudgeConfiguration | PlainMessage<StreamTimestampNudgeConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TimestampNudgerMessage
+ * @generated from message norsk.api.media.StreamTimestampNudgeMessage
  */
-export declare class TimestampNudgerMessage extends Message<TimestampNudgerMessage> {
+export declare class StreamTimestampNudgeMessage extends Message<StreamTimestampNudgeMessage> {
     /**
-     * @generated from oneof norsk.api.media.TimestampNudgerMessage.message
+     * @generated from oneof norsk.api.media.StreamTimestampNudgeMessage.message
      */
     message: {
         /**
-         * @generated from field: norsk.api.media.TimestampNudgerConfiguration initial_config = 1;
+         * @generated from field: norsk.api.media.StreamTimestampNudgeConfiguration initial_config = 1;
          */
-        value: TimestampNudgerConfiguration;
+        value: StreamTimestampNudgeConfiguration;
         case: "initialConfig";
     } | {
         /**
@@ -8683,21 +8690,21 @@ export declare class TimestampNudgerMessage extends Message<TimestampNudgerMessa
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<TimestampNudgerMessage>);
+    constructor(data?: PartialMessage<StreamTimestampNudgeMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TimestampNudgerMessage";
+    static readonly typeName = "norsk.api.media.StreamTimestampNudgeMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TimestampNudgerMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TimestampNudgerMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TimestampNudgerMessage;
-    static equals(a: TimestampNudgerMessage | PlainMessage<TimestampNudgerMessage> | undefined, b: TimestampNudgerMessage | PlainMessage<TimestampNudgerMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamTimestampNudgeMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamTimestampNudgeMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamTimestampNudgeMessage;
+    static equals(a: StreamTimestampNudgeMessage | PlainMessage<StreamTimestampNudgeMessage> | undefined, b: StreamTimestampNudgeMessage | PlainMessage<StreamTimestampNudgeMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.TimestampNudgerEvent
+ * @generated from message norsk.api.media.StreamTimestampNudgeEvent
  */
-export declare class TimestampNudgerEvent extends Message<TimestampNudgerEvent> {
+export declare class StreamTimestampNudgeEvent extends Message<StreamTimestampNudgeEvent> {
     /**
-     * @generated from oneof norsk.api.media.TimestampNudgerEvent.message
+     * @generated from oneof norsk.api.media.StreamTimestampNudgeEvent.message
      */
     message: {
         /**
@@ -8721,14 +8728,14 @@ export declare class TimestampNudgerEvent extends Message<TimestampNudgerEvent>
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<TimestampNudgerEvent>);
+    constructor(data?: PartialMessage<StreamTimestampNudgeEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.TimestampNudgerEvent";
+    static readonly typeName = "norsk.api.media.StreamTimestampNudgeEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TimestampNudgerEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TimestampNudgerEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TimestampNudgerEvent;
-    static equals(a: TimestampNudgerEvent | PlainMessage<TimestampNudgerEvent> | undefined, b: TimestampNudgerEvent | PlainMessage<TimestampNudgerEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamTimestampNudgeEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamTimestampNudgeEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamTimestampNudgeEvent;
+    static equals(a: StreamTimestampNudgeEvent | PlainMessage<StreamTimestampNudgeEvent> | undefined, b: StreamTimestampNudgeEvent | PlainMessage<StreamTimestampNudgeEvent> | undefined): boolean;
 }
 /**
  * @generated from message norsk.api.media.StreamKeyOverrideConfiguration
@@ -8822,9 +8829,9 @@ export declare class StreamKeyOverrideEvent extends Message<StreamKeyOverrideEve
     static equals(a: StreamKeyOverrideEvent | PlainMessage<StreamKeyOverrideEvent> | undefined, b: StreamKeyOverrideEvent | PlainMessage<StreamKeyOverrideEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.MetadataOverrideConfiguration
+ * @generated from message norsk.api.media.StreamMetadataOverrideConfiguration
  */
-export declare class MetadataOverrideConfiguration extends Message<MetadataOverrideConfiguration> {
+export declare class StreamMetadataOverrideConfiguration extends Message<StreamMetadataOverrideConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -8853,19 +8860,19 @@ export declare class MetadataOverrideConfiguration extends Message<MetadataOverr
      * @generated from field: norsk.api.media.OptionalString subtitles_language = 5;
      */
     subtitlesLanguage?: OptionalString;
-    constructor(data?: PartialMessage<MetadataOverrideConfiguration>);
+    constructor(data?: PartialMessage<StreamMetadataOverrideConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.MetadataOverrideConfiguration";
+    static readonly typeName = "norsk.api.media.StreamMetadataOverrideConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MetadataOverrideConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MetadataOverrideConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MetadataOverrideConfiguration;
-    static equals(a: MetadataOverrideConfiguration | PlainMessage<MetadataOverrideConfiguration> | undefined, b: MetadataOverrideConfiguration | PlainMessage<MetadataOverrideConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadataOverrideConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamMetadataOverrideConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamMetadataOverrideConfiguration;
+    static equals(a: StreamMetadataOverrideConfiguration | PlainMessage<StreamMetadataOverrideConfiguration> | undefined, b: StreamMetadataOverrideConfiguration | PlainMessage<StreamMetadataOverrideConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.MetadataOverrideUpdateConfiguration
+ * @generated from message norsk.api.media.StreamMetadataOverrideUpdateConfiguration
  */
-export declare class MetadataOverrideUpdateConfiguration extends Message<MetadataOverrideUpdateConfiguration> {
+export declare class StreamMetadataOverrideUpdateConfiguration extends Message<StreamMetadataOverrideUpdateConfiguration> {
     /**
      * * Override the bitrate metadata of a compressed video stream, or `0` to clear
      *
@@ -8890,33 +8897,33 @@ export declare class MetadataOverrideUpdateConfiguration extends Message<Metadat
      * @generated from field: norsk.api.media.OptionalString subtitles_language = 5;
      */
     subtitlesLanguage?: OptionalString;
-    constructor(data?: PartialMessage<MetadataOverrideUpdateConfiguration>);
+    constructor(data?: PartialMessage<StreamMetadataOverrideUpdateConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.MetadataOverrideUpdateConfiguration";
+    static readonly typeName = "norsk.api.media.StreamMetadataOverrideUpdateConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MetadataOverrideUpdateConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MetadataOverrideUpdateConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MetadataOverrideUpdateConfiguration;
-    static equals(a: MetadataOverrideUpdateConfiguration | PlainMessage<MetadataOverrideUpdateConfiguration> | undefined, b: MetadataOverrideUpdateConfiguration | PlainMessage<MetadataOverrideUpdateConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadataOverrideUpdateConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamMetadataOverrideUpdateConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamMetadataOverrideUpdateConfiguration;
+    static equals(a: StreamMetadataOverrideUpdateConfiguration | PlainMessage<StreamMetadataOverrideUpdateConfiguration> | undefined, b: StreamMetadataOverrideUpdateConfiguration | PlainMessage<StreamMetadataOverrideUpdateConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.MetadataOverrideMessage
+ * @generated from message norsk.api.media.StreamMetadataOverrideMessage
  */
-export declare class MetadataOverrideMessage extends Message<MetadataOverrideMessage> {
+export declare class StreamMetadataOverrideMessage extends Message<StreamMetadataOverrideMessage> {
     /**
-     * @generated from oneof norsk.api.media.MetadataOverrideMessage.message
+     * @generated from oneof norsk.api.media.StreamMetadataOverrideMessage.message
      */
     message: {
         /**
-         * @generated from field: norsk.api.media.MetadataOverrideConfiguration initial_config = 1;
+         * @generated from field: norsk.api.media.StreamMetadataOverrideConfiguration initial_config = 1;
          */
-        value: MetadataOverrideConfiguration;
+        value: StreamMetadataOverrideConfiguration;
         case: "initialConfig";
     } | {
         /**
-         * @generated from field: norsk.api.media.MetadataOverrideUpdateConfiguration update_config = 2;
+         * @generated from field: norsk.api.media.StreamMetadataOverrideUpdateConfiguration update_config = 2;
          */
-        value: MetadataOverrideUpdateConfiguration;
+        value: StreamMetadataOverrideUpdateConfiguration;
         case: "updateConfig";
     } | {
         /**
@@ -8928,21 +8935,21 @@ export declare class MetadataOverrideMessage extends Message<MetadataOverrideMes
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<MetadataOverrideMessage>);
+    constructor(data?: PartialMessage<StreamMetadataOverrideMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.MetadataOverrideMessage";
+    static readonly typeName = "norsk.api.media.StreamMetadataOverrideMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MetadataOverrideMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MetadataOverrideMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MetadataOverrideMessage;
-    static equals(a: MetadataOverrideMessage | PlainMessage<MetadataOverrideMessage> | undefined, b: MetadataOverrideMessage | PlainMessage<MetadataOverrideMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadataOverrideMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamMetadataOverrideMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamMetadataOverrideMessage;
+    static equals(a: StreamMetadataOverrideMessage | PlainMessage<StreamMetadataOverrideMessage> | undefined, b: StreamMetadataOverrideMessage | PlainMessage<StreamMetadataOverrideMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.MetadataOverrideEvent
+ * @generated from message norsk.api.media.StreamMetadataOverrideEvent
  */
-export declare class MetadataOverrideEvent extends Message<MetadataOverrideEvent> {
+export declare class StreamMetadataOverrideEvent extends Message<StreamMetadataOverrideEvent> {
     /**
-     * @generated from oneof norsk.api.media.MetadataOverrideEvent.message
+     * @generated from oneof norsk.api.media.StreamMetadataOverrideEvent.message
      */
     message: {
         /**
@@ -8966,44 +8973,44 @@ export declare class MetadataOverrideEvent extends Message<MetadataOverrideEvent
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<MetadataOverrideEvent>);
+    constructor(data?: PartialMessage<StreamMetadataOverrideEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.MetadataOverrideEvent";
+    static readonly typeName = "norsk.api.media.StreamMetadataOverrideEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MetadataOverrideEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MetadataOverrideEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MetadataOverrideEvent;
-    static equals(a: MetadataOverrideEvent | PlainMessage<MetadataOverrideEvent> | undefined, b: MetadataOverrideEvent | PlainMessage<MetadataOverrideEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamMetadataOverrideEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamMetadataOverrideEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamMetadataOverrideEvent;
+    static equals(a: StreamMetadataOverrideEvent | PlainMessage<StreamMetadataOverrideEvent> | undefined, b: StreamMetadataOverrideEvent | PlainMessage<StreamMetadataOverrideEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.SyncConfiguration
+ * @generated from message norsk.api.media.StreamSyncConfiguration
  */
-export declare class SyncConfiguration extends Message<SyncConfiguration> {
+export declare class StreamSyncConfiguration extends Message<StreamSyncConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
     id?: MediaNodeId;
-    constructor(data?: PartialMessage<SyncConfiguration>);
+    constructor(data?: PartialMessage<StreamSyncConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.SyncConfiguration";
+    static readonly typeName = "norsk.api.media.StreamSyncConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SyncConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SyncConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SyncConfiguration;
-    static equals(a: SyncConfiguration | PlainMessage<SyncConfiguration> | undefined, b: SyncConfiguration | PlainMessage<SyncConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSyncConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSyncConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSyncConfiguration;
+    static equals(a: StreamSyncConfiguration | PlainMessage<StreamSyncConfiguration> | undefined, b: StreamSyncConfiguration | PlainMessage<StreamSyncConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.SyncMessage
+ * @generated from message norsk.api.media.StreamSyncMessage
  */
-export declare class SyncMessage extends Message<SyncMessage> {
+export declare class StreamSyncMessage extends Message<StreamSyncMessage> {
     /**
-     * @generated from oneof norsk.api.media.SyncMessage.message
+     * @generated from oneof norsk.api.media.StreamSyncMessage.message
      */
     message: {
         /**
-         * @generated from field: norsk.api.media.SyncConfiguration initial_config = 1;
+         * @generated from field: norsk.api.media.StreamSyncConfiguration initial_config = 1;
          */
-        value: SyncConfiguration;
+        value: StreamSyncConfiguration;
         case: "initialConfig";
     } | {
         /**
@@ -9015,21 +9022,21 @@ export declare class SyncMessage extends Message<SyncMessage> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<SyncMessage>);
+    constructor(data?: PartialMessage<StreamSyncMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.SyncMessage";
+    static readonly typeName = "norsk.api.media.StreamSyncMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SyncMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SyncMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SyncMessage;
-    static equals(a: SyncMessage | PlainMessage<SyncMessage> | undefined, b: SyncMessage | PlainMessage<SyncMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSyncMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSyncMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSyncMessage;
+    static equals(a: StreamSyncMessage | PlainMessage<StreamSyncMessage> | undefined, b: StreamSyncMessage | PlainMessage<StreamSyncMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.SyncEvent
+ * @generated from message norsk.api.media.StreamSyncEvent
  */
-export declare class SyncEvent extends Message<SyncEvent> {
+export declare class StreamSyncEvent extends Message<StreamSyncEvent> {
     /**
-     * @generated from oneof norsk.api.media.SyncEvent.message
+     * @generated from oneof norsk.api.media.StreamSyncEvent.message
      */
     message: {
         /**
@@ -9053,47 +9060,47 @@ export declare class SyncEvent extends Message<SyncEvent> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<SyncEvent>);
+    constructor(data?: PartialMessage<StreamSyncEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.SyncEvent";
+    static readonly typeName = "norsk.api.media.StreamSyncEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SyncEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SyncEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SyncEvent;
-    static equals(a: SyncEvent | PlainMessage<SyncEvent> | undefined, b: SyncEvent | PlainMessage<SyncEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSyncEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSyncEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSyncEvent;
+    static equals(a: StreamSyncEvent | PlainMessage<StreamSyncEvent> | undefined, b: StreamSyncEvent | PlainMessage<StreamSyncEvent> | undefined): boolean;
 }
 /**
  * ///////////////////////////////
- * AudioEncoder
+ * AudioEncode
  *
- * @generated from message norsk.api.media.AacEncoderConfiguration
+ * @generated from message norsk.api.media.AacEncodeConfiguration
  */
-export declare class AacEncoderConfiguration extends Message<AacEncoderConfiguration> {
+export declare class AacEncodeConfiguration extends Message<AacEncodeConfiguration> {
     /**
      * @generated from field: norsk.api.media.SampleRate sample_rate = 1;
      */
     sampleRate: SampleRate;
     /**
-     * @generated from field: norsk.api.media.AacEncoderConfiguration.AacProfile profile = 2;
+     * @generated from field: norsk.api.media.AacEncodeConfiguration.AacProfile profile = 2;
      */
-    profile: AacEncoderConfiguration_AacProfile;
+    profile: AacEncodeConfiguration_AacProfile;
     /**
-     * @generated from field: norsk.api.media.AacEncoderConfiguration.AacEncapsulation encapsulation = 3;
+     * @generated from field: norsk.api.media.AacEncodeConfiguration.AacEncapsulation encapsulation = 3;
      */
-    encapsulation: AacEncoderConfiguration_AacEncapsulation;
-    constructor(data?: PartialMessage<AacEncoderConfiguration>);
+    encapsulation: AacEncodeConfiguration_AacEncapsulation;
+    constructor(data?: PartialMessage<AacEncodeConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AacEncoderConfiguration";
+    static readonly typeName = "norsk.api.media.AacEncodeConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AacEncoderConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AacEncoderConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AacEncoderConfiguration;
-    static equals(a: AacEncoderConfiguration | PlainMessage<AacEncoderConfiguration> | undefined, b: AacEncoderConfiguration | PlainMessage<AacEncoderConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AacEncodeConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AacEncodeConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AacEncodeConfiguration;
+    static equals(a: AacEncodeConfiguration | PlainMessage<AacEncodeConfiguration> | undefined, b: AacEncodeConfiguration | PlainMessage<AacEncodeConfiguration> | undefined): boolean;
 }
 /**
- * @generated from enum norsk.api.media.AacEncoderConfiguration.AacProfile
+ * @generated from enum norsk.api.media.AacEncodeConfiguration.AacProfile
  */
-export declare enum AacEncoderConfiguration_AacProfile {
+export declare enum AacEncodeConfiguration_AacProfile {
     /**
      * @generated from enum value: AAC_LC_PROFILE = 0;
      */
@@ -9108,9 +9115,9 @@ export declare enum AacEncoderConfiguration_AacProfile {
     AAC_HIGH_PROFILE = 2
 }
 /**
- * @generated from enum norsk.api.media.AacEncoderConfiguration.AacEncapsulation
+ * @generated from enum norsk.api.media.AacEncodeConfiguration.AacEncapsulation
  */
-export declare enum AacEncoderConfiguration_AacEncapsulation {
+export declare enum AacEncodeConfiguration_AacEncapsulation {
     /**
      * @generated from enum value: AAC_ADTS_ENCAPSULATION = 0;
      */
@@ -9121,22 +9128,22 @@ export declare enum AacEncoderConfiguration_AacEncapsulation {
     AAC_RAW_ENCAPSULATION = 1
 }
 /**
- * @generated from message norsk.api.media.OpusEncoderConfiguration
+ * @generated from message norsk.api.media.OpusEncodeConfiguration
  */
-export declare class OpusEncoderConfiguration extends Message<OpusEncoderConfiguration> {
-    constructor(data?: PartialMessage<OpusEncoderConfiguration>);
+export declare class OpusEncodeConfiguration extends Message<OpusEncodeConfiguration> {
+    constructor(data?: PartialMessage<OpusEncodeConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.OpusEncoderConfiguration";
+    static readonly typeName = "norsk.api.media.OpusEncodeConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OpusEncoderConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OpusEncoderConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OpusEncoderConfiguration;
-    static equals(a: OpusEncoderConfiguration | PlainMessage<OpusEncoderConfiguration> | undefined, b: OpusEncoderConfiguration | PlainMessage<OpusEncoderConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OpusEncodeConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OpusEncodeConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OpusEncodeConfiguration;
+    static equals(a: OpusEncodeConfiguration | PlainMessage<OpusEncodeConfiguration> | undefined, b: OpusEncodeConfiguration | PlainMessage<OpusEncodeConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AudioEncoderConfiguration
+ * @generated from message norsk.api.media.AudioEncodeConfiguration
  */
-export declare class AudioEncoderConfiguration extends Message<AudioEncoderConfiguration> {
+export declare class AudioEncodeConfiguration extends Message<AudioEncodeConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -9154,43 +9161,43 @@ export declare class AudioEncoderConfiguration extends Message<AudioEncoderConfi
      */
     renditionName?: RenditionName;
     /**
-     * @generated from oneof norsk.api.media.AudioEncoderConfiguration.encoder
+     * @generated from oneof norsk.api.media.AudioEncodeConfiguration.encoder
      */
     encoder: {
         /**
-         * @generated from field: norsk.api.media.AacEncoderConfiguration aac = 5;
+         * @generated from field: norsk.api.media.AacEncodeConfiguration aac = 5;
          */
-        value: AacEncoderConfiguration;
+        value: AacEncodeConfiguration;
         case: "aac";
     } | {
         /**
-         * @generated from field: norsk.api.media.OpusEncoderConfiguration opus = 6;
+         * @generated from field: norsk.api.media.OpusEncodeConfiguration opus = 6;
          */
-        value: OpusEncoderConfiguration;
+        value: OpusEncodeConfiguration;
         case: "opus";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<AudioEncoderConfiguration>);
+    constructor(data?: PartialMessage<AudioEncodeConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioEncoderConfiguration";
+    static readonly typeName = "norsk.api.media.AudioEncodeConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioEncoderConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioEncoderConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioEncoderConfiguration;
-    static equals(a: AudioEncoderConfiguration | PlainMessage<AudioEncoderConfiguration> | undefined, b: AudioEncoderConfiguration | PlainMessage<AudioEncoderConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioEncodeConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioEncodeConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioEncodeConfiguration;
+    static equals(a: AudioEncodeConfiguration | PlainMessage<AudioEncodeConfiguration> | undefined, b: AudioEncodeConfiguration | PlainMessage<AudioEncodeConfiguration> | undefined): boolean;
 }
 /**
  * Message to change how an audio encode is performed.
  *
- * @generated from message norsk.api.media.AudioEncoderMessage
+ * @generated from message norsk.api.media.AudioEncodeMessage
  */
-export declare class AudioEncoderMessage extends Message<AudioEncoderMessage> {
+export declare class AudioEncodeMessage extends Message<AudioEncodeMessage> {
     /**
      * Subscription or configuration
      *
-     * @generated from oneof norsk.api.media.AudioEncoderMessage.message
+     * @generated from oneof norsk.api.media.AudioEncodeMessage.message
      */
     message: {
         /**
@@ -9204,29 +9211,29 @@ export declare class AudioEncoderMessage extends Message<AudioEncoderMessage> {
         /**
          * Settings to control the encode characteristics
          *
-         * @generated from field: norsk.api.media.AudioEncoderConfiguration configuration = 2;
+         * @generated from field: norsk.api.media.AudioEncodeConfiguration configuration = 2;
          */
-        value: AudioEncoderConfiguration;
+        value: AudioEncodeConfiguration;
         case: "configuration";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<AudioEncoderMessage>);
+    constructor(data?: PartialMessage<AudioEncodeMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioEncoderMessage";
+    static readonly typeName = "norsk.api.media.AudioEncodeMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioEncoderMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioEncoderMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioEncoderMessage;
-    static equals(a: AudioEncoderMessage | PlainMessage<AudioEncoderMessage> | undefined, b: AudioEncoderMessage | PlainMessage<AudioEncoderMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioEncodeMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioEncodeMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioEncodeMessage;
+    static equals(a: AudioEncodeMessage | PlainMessage<AudioEncodeMessage> | undefined, b: AudioEncodeMessage | PlainMessage<AudioEncodeMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AudioEncoderEvent
+ * @generated from message norsk.api.media.AudioEncodeEvent
  */
-export declare class AudioEncoderEvent extends Message<AudioEncoderEvent> {
+export declare class AudioEncodeEvent extends Message<AudioEncodeEvent> {
     /**
-     * @generated from oneof norsk.api.media.AudioEncoderEvent.message
+     * @generated from oneof norsk.api.media.AudioEncodeEvent.message
      */
     message: {
         /**
@@ -9250,19 +9257,19 @@ export declare class AudioEncoderEvent extends Message<AudioEncoderEvent> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<AudioEncoderEvent>);
+    constructor(data?: PartialMessage<AudioEncodeEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioEncoderEvent";
+    static readonly typeName = "norsk.api.media.AudioEncodeEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioEncoderEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioEncoderEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioEncoderEvent;
-    static equals(a: AudioEncoderEvent | PlainMessage<AudioEncoderEvent> | undefined, b: AudioEncoderEvent | PlainMessage<AudioEncoderEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioEncodeEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioEncodeEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioEncodeEvent;
+    static equals(a: AudioEncodeEvent | PlainMessage<AudioEncodeEvent> | undefined, b: AudioEncodeEvent | PlainMessage<AudioEncodeEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.SmoothSwitcherConfiguration
+ * @generated from message norsk.api.media.StreamSwitchSmoothConfiguration
  */
-export declare class SmoothSwitcherConfiguration extends Message<SmoothSwitcherConfiguration> {
+export declare class StreamSwitchSmoothConfiguration extends Message<StreamSwitchSmoothConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -9295,40 +9302,40 @@ export declare class SmoothSwitcherConfiguration extends Message<SmoothSwitcherC
      * @generated from field: norsk.api.media.SampleRate sample_rate = 6;
      */
     sampleRate: SampleRate;
-    constructor(data?: PartialMessage<SmoothSwitcherConfiguration>);
+    constructor(data?: PartialMessage<StreamSwitchSmoothConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.SmoothSwitcherConfiguration";
+    static readonly typeName = "norsk.api.media.StreamSwitchSmoothConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SmoothSwitcherConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SmoothSwitcherConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SmoothSwitcherConfiguration;
-    static equals(a: SmoothSwitcherConfiguration | PlainMessage<SmoothSwitcherConfiguration> | undefined, b: SmoothSwitcherConfiguration | PlainMessage<SmoothSwitcherConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchSmoothConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSwitchSmoothConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSwitchSmoothConfiguration;
+    static equals(a: StreamSwitchSmoothConfiguration | PlainMessage<StreamSwitchSmoothConfiguration> | undefined, b: StreamSwitchSmoothConfiguration | PlainMessage<StreamSwitchSmoothConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.SmoothSwitcherSwitch
+ * @generated from message norsk.api.media.StreamSwitchSmoothSwitch
  */
-export declare class SmoothSwitcherSwitch extends Message<SmoothSwitcherSwitch> {
+export declare class StreamSwitchSmoothSwitch extends Message<StreamSwitchSmoothSwitch> {
     /**
      * The pin to select as the new active source
      *
      * @generated from field: norsk.api.media.InputPin new_active_source = 1;
      */
     newActiveSource?: InputPin;
-    constructor(data?: PartialMessage<SmoothSwitcherSwitch>);
+    constructor(data?: PartialMessage<StreamSwitchSmoothSwitch>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.SmoothSwitcherSwitch";
+    static readonly typeName = "norsk.api.media.StreamSwitchSmoothSwitch";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SmoothSwitcherSwitch;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SmoothSwitcherSwitch;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SmoothSwitcherSwitch;
-    static equals(a: SmoothSwitcherSwitch | PlainMessage<SmoothSwitcherSwitch> | undefined, b: SmoothSwitcherSwitch | PlainMessage<SmoothSwitcherSwitch> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchSmoothSwitch;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSwitchSmoothSwitch;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSwitchSmoothSwitch;
+    static equals(a: StreamSwitchSmoothSwitch | PlainMessage<StreamSwitchSmoothSwitch> | undefined, b: StreamSwitchSmoothSwitch | PlainMessage<StreamSwitchSmoothSwitch> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.SmoothSwitcherMessage
+ * @generated from message norsk.api.media.StreamSwitchSmoothMessage
  */
-export declare class SmoothSwitcherMessage extends Message<SmoothSwitcherMessage> {
+export declare class StreamSwitchSmoothMessage extends Message<StreamSwitchSmoothMessage> {
     /**
-     * @generated from oneof norsk.api.media.SmoothSwitcherMessage.message
+     * @generated from oneof norsk.api.media.StreamSwitchSmoothMessage.message
      */
     message: {
         /**
@@ -9338,35 +9345,35 @@ export declare class SmoothSwitcherMessage extends Message<SmoothSwitcherMessage
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.SmoothSwitcherConfiguration initial_config = 2;
+         * @generated from field: norsk.api.media.StreamSwitchSmoothConfiguration initial_config = 2;
          */
-        value: SmoothSwitcherConfiguration;
+        value: StreamSwitchSmoothConfiguration;
         case: "initialConfig";
     } | {
         /**
-         * @generated from field: norsk.api.media.SmoothSwitcherSwitch switch_source = 3;
+         * @generated from field: norsk.api.media.StreamSwitchSmoothSwitch switch_source = 3;
          */
-        value: SmoothSwitcherSwitch;
+        value: StreamSwitchSmoothSwitch;
         case: "switchSource";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<SmoothSwitcherMessage>);
+    constructor(data?: PartialMessage<StreamSwitchSmoothMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.SmoothSwitcherMessage";
+    static readonly typeName = "norsk.api.media.StreamSwitchSmoothMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SmoothSwitcherMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SmoothSwitcherMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SmoothSwitcherMessage;
-    static equals(a: SmoothSwitcherMessage | PlainMessage<SmoothSwitcherMessage> | undefined, b: SmoothSwitcherMessage | PlainMessage<SmoothSwitcherMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchSmoothMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSwitchSmoothMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSwitchSmoothMessage;
+    static equals(a: StreamSwitchSmoothMessage | PlainMessage<StreamSwitchSmoothMessage> | undefined, b: StreamSwitchSmoothMessage | PlainMessage<StreamSwitchSmoothMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.SmoothSwitcherEvent
+ * @generated from message norsk.api.media.StreamSwitchSmoothEvent
  */
-export declare class SmoothSwitcherEvent extends Message<SmoothSwitcherEvent> {
+export declare class StreamSwitchSmoothEvent extends Message<StreamSwitchSmoothEvent> {
     /**
-     * @generated from oneof norsk.api.media.SmoothSwitcherEvent.message
+     * @generated from oneof norsk.api.media.StreamSwitchSmoothEvent.message
      */
     message: {
         /**
@@ -9390,19 +9397,19 @@ export declare class SmoothSwitcherEvent extends Message<SmoothSwitcherEvent> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<SmoothSwitcherEvent>);
+    constructor(data?: PartialMessage<StreamSwitchSmoothEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.SmoothSwitcherEvent";
+    static readonly typeName = "norsk.api.media.StreamSwitchSmoothEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SmoothSwitcherEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SmoothSwitcherEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SmoothSwitcherEvent;
-    static equals(a: SmoothSwitcherEvent | PlainMessage<SmoothSwitcherEvent> | undefined, b: SmoothSwitcherEvent | PlainMessage<SmoothSwitcherEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchSmoothEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSwitchSmoothEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSwitchSmoothEvent;
+    static equals(a: StreamSwitchSmoothEvent | PlainMessage<StreamSwitchSmoothEvent> | undefined, b: StreamSwitchSmoothEvent | PlainMessage<StreamSwitchSmoothEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.HardSwitcherConfiguration
+ * @generated from message norsk.api.media.StreamSwitchHardConfiguration
  */
-export declare class HardSwitcherConfiguration extends Message<HardSwitcherConfiguration> {
+export declare class StreamSwitchHardConfiguration extends Message<StreamSwitchHardConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -9419,40 +9426,40 @@ export declare class HardSwitcherConfiguration extends Message<HardSwitcherConfi
      * @generated from field: string output_source = 3;
      */
     outputSource: string;
-    constructor(data?: PartialMessage<HardSwitcherConfiguration>);
+    constructor(data?: PartialMessage<StreamSwitchHardConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.HardSwitcherConfiguration";
+    static readonly typeName = "norsk.api.media.StreamSwitchHardConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HardSwitcherConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HardSwitcherConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HardSwitcherConfiguration;
-    static equals(a: HardSwitcherConfiguration | PlainMessage<HardSwitcherConfiguration> | undefined, b: HardSwitcherConfiguration | PlainMessage<HardSwitcherConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchHardConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSwitchHardConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSwitchHardConfiguration;
+    static equals(a: StreamSwitchHardConfiguration | PlainMessage<StreamSwitchHardConfiguration> | undefined, b: StreamSwitchHardConfiguration | PlainMessage<StreamSwitchHardConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.HardSwitcherSwitch
+ * @generated from message norsk.api.media.StreamSwitchHardSwitch
  */
-export declare class HardSwitcherSwitch extends Message<HardSwitcherSwitch> {
+export declare class StreamSwitchHardSwitch extends Message<StreamSwitchHardSwitch> {
     /**
      * The pin to select as the new active source
      *
      * @generated from field: norsk.api.media.InputPin new_active_source = 1;
      */
     newActiveSource?: InputPin;
-    constructor(data?: PartialMessage<HardSwitcherSwitch>);
+    constructor(data?: PartialMessage<StreamSwitchHardSwitch>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.HardSwitcherSwitch";
+    static readonly typeName = "norsk.api.media.StreamSwitchHardSwitch";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HardSwitcherSwitch;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HardSwitcherSwitch;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HardSwitcherSwitch;
-    static equals(a: HardSwitcherSwitch | PlainMessage<HardSwitcherSwitch> | undefined, b: HardSwitcherSwitch | PlainMessage<HardSwitcherSwitch> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchHardSwitch;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSwitchHardSwitch;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSwitchHardSwitch;
+    static equals(a: StreamSwitchHardSwitch | PlainMessage<StreamSwitchHardSwitch> | undefined, b: StreamSwitchHardSwitch | PlainMessage<StreamSwitchHardSwitch> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.HardSwitcherMessage
+ * @generated from message norsk.api.media.StreamSwitchHardMessage
  */
-export declare class HardSwitcherMessage extends Message<HardSwitcherMessage> {
+export declare class StreamSwitchHardMessage extends Message<StreamSwitchHardMessage> {
     /**
-     * @generated from oneof norsk.api.media.HardSwitcherMessage.message
+     * @generated from oneof norsk.api.media.StreamSwitchHardMessage.message
      */
     message: {
         /**
@@ -9462,35 +9469,35 @@ export declare class HardSwitcherMessage extends Message<HardSwitcherMessage> {
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.HardSwitcherConfiguration initial_config = 2;
+         * @generated from field: norsk.api.media.StreamSwitchHardConfiguration initial_config = 2;
          */
-        value: HardSwitcherConfiguration;
+        value: StreamSwitchHardConfiguration;
         case: "initialConfig";
     } | {
         /**
-         * @generated from field: norsk.api.media.HardSwitcherSwitch switch_source = 3;
+         * @generated from field: norsk.api.media.StreamSwitchHardSwitch switch_source = 3;
          */
-        value: HardSwitcherSwitch;
+        value: StreamSwitchHardSwitch;
         case: "switchSource";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<HardSwitcherMessage>);
+    constructor(data?: PartialMessage<StreamSwitchHardMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.HardSwitcherMessage";
+    static readonly typeName = "norsk.api.media.StreamSwitchHardMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HardSwitcherMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HardSwitcherMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HardSwitcherMessage;
-    static equals(a: HardSwitcherMessage | PlainMessage<HardSwitcherMessage> | undefined, b: HardSwitcherMessage | PlainMessage<HardSwitcherMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchHardMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSwitchHardMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSwitchHardMessage;
+    static equals(a: StreamSwitchHardMessage | PlainMessage<StreamSwitchHardMessage> | undefined, b: StreamSwitchHardMessage | PlainMessage<StreamSwitchHardMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.HardSwitcherEvent
+ * @generated from message norsk.api.media.StreamSwitchHardEvent
  */
-export declare class HardSwitcherEvent extends Message<HardSwitcherEvent> {
+export declare class StreamSwitchHardEvent extends Message<StreamSwitchHardEvent> {
     /**
-     * @generated from oneof norsk.api.media.HardSwitcherEvent.message
+     * @generated from oneof norsk.api.media.StreamSwitchHardEvent.message
      */
     message: {
         /**
@@ -9514,45 +9521,45 @@ export declare class HardSwitcherEvent extends Message<HardSwitcherEvent> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<HardSwitcherEvent>);
+    constructor(data?: PartialMessage<StreamSwitchHardEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.HardSwitcherEvent";
+    static readonly typeName = "norsk.api.media.StreamSwitchHardEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HardSwitcherEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HardSwitcherEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HardSwitcherEvent;
-    static equals(a: HardSwitcherEvent | PlainMessage<HardSwitcherEvent> | undefined, b: HardSwitcherEvent | PlainMessage<HardSwitcherEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamSwitchHardEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamSwitchHardEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSwitchHardEvent;
+    static equals(a: StreamSwitchHardEvent | PlainMessage<StreamSwitchHardEvent> | undefined, b: StreamSwitchHardEvent | PlainMessage<StreamSwitchHardEvent> | undefined): boolean;
 }
 /**
  * *
  * The default sampling windows are 1s, 5s, and 30s.
  *
- * @generated from message norsk.api.media.StreamStatsConfiguration
+ * @generated from message norsk.api.media.StreamStatisticsConfiguration
  */
-export declare class StreamStatsConfiguration extends Message<StreamStatsConfiguration> {
+export declare class StreamStatisticsConfiguration extends Message<StreamStatisticsConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
     id?: MediaNodeId;
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 2;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 2;
      */
-    statsSampling?: StreamStatsSampling;
-    constructor(data?: PartialMessage<StreamStatsConfiguration>);
+    statsSampling?: StreamStatisticsSampling;
+    constructor(data?: PartialMessage<StreamStatisticsConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.StreamStatsConfiguration";
+    static readonly typeName = "norsk.api.media.StreamStatisticsConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamStatsConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamStatsConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamStatsConfiguration;
-    static equals(a: StreamStatsConfiguration | PlainMessage<StreamStatsConfiguration> | undefined, b: StreamStatsConfiguration | PlainMessage<StreamStatsConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamStatisticsConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamStatisticsConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamStatisticsConfiguration;
+    static equals(a: StreamStatisticsConfiguration | PlainMessage<StreamStatisticsConfiguration> | undefined, b: StreamStatisticsConfiguration | PlainMessage<StreamStatisticsConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.StreamStatsMessage
+ * @generated from message norsk.api.media.StreamStatisticsMessage
  */
-export declare class StreamStatsMessage extends Message<StreamStatsMessage> {
+export declare class StreamStatisticsMessage extends Message<StreamStatisticsMessage> {
     /**
-     * @generated from oneof norsk.api.media.StreamStatsMessage.message
+     * @generated from oneof norsk.api.media.StreamStatisticsMessage.message
      */
     message: {
         /**
@@ -9562,29 +9569,29 @@ export declare class StreamStatsMessage extends Message<StreamStatsMessage> {
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.StreamStatsConfiguration configuration = 2;
+         * @generated from field: norsk.api.media.StreamStatisticsConfiguration configuration = 2;
          */
-        value: StreamStatsConfiguration;
+        value: StreamStatisticsConfiguration;
         case: "configuration";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<StreamStatsMessage>);
+    constructor(data?: PartialMessage<StreamStatisticsMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.StreamStatsMessage";
+    static readonly typeName = "norsk.api.media.StreamStatisticsMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamStatsMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamStatsMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamStatsMessage;
-    static equals(a: StreamStatsMessage | PlainMessage<StreamStatsMessage> | undefined, b: StreamStatsMessage | PlainMessage<StreamStatsMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamStatisticsMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamStatisticsMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamStatisticsMessage;
+    static equals(a: StreamStatisticsMessage | PlainMessage<StreamStatisticsMessage> | undefined, b: StreamStatisticsMessage | PlainMessage<StreamStatisticsMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.StreamStatsEvent
+ * @generated from message norsk.api.media.StreamStatisticsEvent
  */
-export declare class StreamStatsEvent extends Message<StreamStatsEvent> {
+export declare class StreamStatisticsEvent extends Message<StreamStatisticsEvent> {
     /**
-     * @generated from oneof norsk.api.media.StreamStatsEvent.message
+     * @generated from oneof norsk.api.media.StreamStatisticsEvent.message
      */
     message: {
         /**
@@ -9600,10 +9607,10 @@ export declare class StreamStatsEvent extends Message<StreamStatsEvent> {
         case: "outboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 3;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 3;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         /**
          * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 4;
@@ -9614,19 +9621,19 @@ export declare class StreamStatsEvent extends Message<StreamStatsEvent> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<StreamStatsEvent>);
+    constructor(data?: PartialMessage<StreamStatisticsEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.StreamStatsEvent";
+    static readonly typeName = "norsk.api.media.StreamStatisticsEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamStatsEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamStatsEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamStatsEvent;
-    static equals(a: StreamStatsEvent | PlainMessage<StreamStatsEvent> | undefined, b: StreamStatsEvent | PlainMessage<StreamStatsEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamStatisticsEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamStatisticsEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamStatisticsEvent;
+    static equals(a: StreamStatisticsEvent | PlainMessage<StreamStatisticsEvent> | undefined, b: StreamStatisticsEvent | PlainMessage<StreamStatisticsEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AudioLevelsConfiguration
+ * @generated from message norsk.api.media.AudioMeasureLevelsConfiguration
  */
-export declare class AudioLevelsConfiguration extends Message<AudioLevelsConfiguration> {
+export declare class AudioMeasureLevelsConfiguration extends Message<AudioMeasureLevelsConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -9635,21 +9642,21 @@ export declare class AudioLevelsConfiguration extends Message<AudioLevelsConfigu
      * @generated from field: uint32 intervalFrames = 2;
      */
     intervalFrames: number;
-    constructor(data?: PartialMessage<AudioLevelsConfiguration>);
+    constructor(data?: PartialMessage<AudioMeasureLevelsConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioLevelsConfiguration";
+    static readonly typeName = "norsk.api.media.AudioMeasureLevelsConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioLevelsConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioLevelsConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioLevelsConfiguration;
-    static equals(a: AudioLevelsConfiguration | PlainMessage<AudioLevelsConfiguration> | undefined, b: AudioLevelsConfiguration | PlainMessage<AudioLevelsConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMeasureLevelsConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMeasureLevelsConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMeasureLevelsConfiguration;
+    static equals(a: AudioMeasureLevelsConfiguration | PlainMessage<AudioMeasureLevelsConfiguration> | undefined, b: AudioMeasureLevelsConfiguration | PlainMessage<AudioMeasureLevelsConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AudioLevelsMessage
+ * @generated from message norsk.api.media.AudioMeasureLevelsMessage
  */
-export declare class AudioLevelsMessage extends Message<AudioLevelsMessage> {
+export declare class AudioMeasureLevelsMessage extends Message<AudioMeasureLevelsMessage> {
     /**
-     * @generated from oneof norsk.api.media.AudioLevelsMessage.message
+     * @generated from oneof norsk.api.media.AudioMeasureLevelsMessage.message
      */
     message: {
         /**
@@ -9659,22 +9666,22 @@ export declare class AudioLevelsMessage extends Message<AudioLevelsMessage> {
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.AudioLevelsConfiguration configuration = 2;
+         * @generated from field: norsk.api.media.AudioMeasureLevelsConfiguration configuration = 2;
          */
-        value: AudioLevelsConfiguration;
+        value: AudioMeasureLevelsConfiguration;
         case: "configuration";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<AudioLevelsMessage>);
+    constructor(data?: PartialMessage<AudioMeasureLevelsMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioLevelsMessage";
+    static readonly typeName = "norsk.api.media.AudioMeasureLevelsMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioLevelsMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioLevelsMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioLevelsMessage;
-    static equals(a: AudioLevelsMessage | PlainMessage<AudioLevelsMessage> | undefined, b: AudioLevelsMessage | PlainMessage<AudioLevelsMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMeasureLevelsMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMeasureLevelsMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMeasureLevelsMessage;
+    static equals(a: AudioMeasureLevelsMessage | PlainMessage<AudioMeasureLevelsMessage> | undefined, b: AudioMeasureLevelsMessage | PlainMessage<AudioMeasureLevelsMessage> | undefined): boolean;
 }
 /**
  * A time interval measured as ticks / (ticks per second)
@@ -9749,9 +9756,9 @@ export declare class ChannelLevels extends Message<ChannelLevels> {
     static equals(a: ChannelLevels | PlainMessage<ChannelLevels> | undefined, b: ChannelLevels | PlainMessage<ChannelLevels> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AudioLevels
+ * @generated from message norsk.api.media.AudioMeasureLevels
  */
-export declare class AudioLevels extends Message<AudioLevels> {
+export declare class AudioMeasureLevels extends Message<AudioMeasureLevels> {
     /**
      * @generated from field: norsk.api.media.StreamKey stream = 1;
      */
@@ -9764,21 +9771,21 @@ export declare class AudioLevels extends Message<AudioLevels> {
      * @generated from field: repeated norsk.api.media.ChannelLevels channel_levels = 3;
      */
     channelLevels: ChannelLevels[];
-    constructor(data?: PartialMessage<AudioLevels>);
+    constructor(data?: PartialMessage<AudioMeasureLevels>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioLevels";
+    static readonly typeName = "norsk.api.media.AudioMeasureLevels";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioLevels;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioLevels;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioLevels;
-    static equals(a: AudioLevels | PlainMessage<AudioLevels> | undefined, b: AudioLevels | PlainMessage<AudioLevels> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMeasureLevels;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMeasureLevels;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMeasureLevels;
+    static equals(a: AudioMeasureLevels | PlainMessage<AudioMeasureLevels> | undefined, b: AudioMeasureLevels | PlainMessage<AudioMeasureLevels> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AudioLevelsEvent
+ * @generated from message norsk.api.media.AudioMeasureLevelsEvent
  */
-export declare class AudioLevelsEvent extends Message<AudioLevelsEvent> {
+export declare class AudioMeasureLevelsEvent extends Message<AudioMeasureLevelsEvent> {
     /**
-     * @generated from oneof norsk.api.media.AudioLevelsEvent.message
+     * @generated from oneof norsk.api.media.AudioMeasureLevelsEvent.message
      */
     message: {
         /**
@@ -9794,9 +9801,9 @@ export declare class AudioLevelsEvent extends Message<AudioLevelsEvent> {
         case: "outboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.AudioLevels levels = 3;
+         * @generated from field: norsk.api.media.AudioMeasureLevels levels = 3;
          */
-        value: AudioLevels;
+        value: AudioMeasureLevels;
         case: "levels";
     } | {
         /**
@@ -9808,14 +9815,14 @@ export declare class AudioLevelsEvent extends Message<AudioLevelsEvent> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<AudioLevelsEvent>);
+    constructor(data?: PartialMessage<AudioMeasureLevelsEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AudioLevelsEvent";
+    static readonly typeName = "norsk.api.media.AudioMeasureLevelsEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioLevelsEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioLevelsEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioLevelsEvent;
-    static equals(a: AudioLevelsEvent | PlainMessage<AudioLevelsEvent> | undefined, b: AudioLevelsEvent | PlainMessage<AudioLevelsEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioMeasureLevelsEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioMeasureLevelsEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioMeasureLevelsEvent;
+    static equals(a: AudioMeasureLevelsEvent | PlainMessage<AudioMeasureLevelsEvent> | undefined, b: AudioMeasureLevelsEvent | PlainMessage<AudioMeasureLevelsEvent> | undefined): boolean;
 }
 /**
  * ///////////////////////////////
@@ -10076,9 +10083,9 @@ export declare class RtpInputConfiguration extends Message<RtpInputConfiguration
      */
     streams: RtpStream[];
     /**
-     * @generated from field: norsk.api.media.StreamStatsSampling stats_sampling = 4;
+     * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 4;
      */
-    statsSampling?: StreamStatsSampling;
+    statsSampling?: StreamStatisticsSampling;
     constructor(data?: PartialMessage<RtpInputConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.RtpInputConfiguration";
@@ -10141,10 +10148,10 @@ export declare class RtpInputEvent extends Message<RtpInputEvent> {
         case: "outboundContext";
     } | {
         /**
-         * @generated from field: norsk.api.media.MultiStreamStats stream_stats = 3;
+         * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 3;
          */
-        value: MultiStreamStats;
-        case: "streamStats";
+        value: MultiStreamStatistics;
+        case: "streamStatistics";
     } | {
         case: undefined;
         value?: undefined;
@@ -10162,9 +10169,9 @@ export declare class RtpInputEvent extends Message<RtpInputEvent> {
  * aws_region is the transcribe endpoint.  The region in aws_credentials is the
  * authentication region
  *
- * @generated from message norsk.api.media.AwsTranscribeConfiguration
+ * @generated from message norsk.api.media.AudioTranscribeAwsConfiguration
  */
-export declare class AwsTranscribeConfiguration extends Message<AwsTranscribeConfiguration> {
+export declare class AudioTranscribeAwsConfiguration extends Message<AudioTranscribeAwsConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
@@ -10178,6 +10185,8 @@ export declare class AwsTranscribeConfiguration extends Message<AwsTranscribeCon
      */
     language: string;
     /**
+     * Region for the transcribe endpoint
+     *
      * @generated from field: string aws_region = 4;
      */
     awsRegion: string;
@@ -10193,21 +10202,21 @@ export declare class AwsTranscribeConfiguration extends Message<AwsTranscribeCon
      * @generated from field: norsk.api.media.SentenceStabilizationMode sentence_stabilization_mode = 7;
      */
     sentenceStabilizationMode: SentenceStabilizationMode;
-    constructor(data?: PartialMessage<AwsTranscribeConfiguration>);
+    constructor(data?: PartialMessage<AudioTranscribeAwsConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AwsTranscribeConfiguration";
+    static readonly typeName = "norsk.api.media.AudioTranscribeAwsConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AwsTranscribeConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AwsTranscribeConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AwsTranscribeConfiguration;
-    static equals(a: AwsTranscribeConfiguration | PlainMessage<AwsTranscribeConfiguration> | undefined, b: AwsTranscribeConfiguration | PlainMessage<AwsTranscribeConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioTranscribeAwsConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioTranscribeAwsConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioTranscribeAwsConfiguration;
+    static equals(a: AudioTranscribeAwsConfiguration | PlainMessage<AudioTranscribeAwsConfiguration> | undefined, b: AudioTranscribeAwsConfiguration | PlainMessage<AudioTranscribeAwsConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AwsTranscribeMessage
+ * @generated from message norsk.api.media.AudioTranscribeAwsMessage
  */
-export declare class AwsTranscribeMessage extends Message<AwsTranscribeMessage> {
+export declare class AudioTranscribeAwsMessage extends Message<AudioTranscribeAwsMessage> {
     /**
-     * @generated from oneof norsk.api.media.AwsTranscribeMessage.message
+     * @generated from oneof norsk.api.media.AudioTranscribeAwsMessage.message
      */
     message: {
         /**
@@ -10217,29 +10226,29 @@ export declare class AwsTranscribeMessage extends Message<AwsTranscribeMessage>
         case: "subscription";
     } | {
         /**
-         * @generated from field: norsk.api.media.AwsTranscribeConfiguration configuration = 2;
+         * @generated from field: norsk.api.media.AudioTranscribeAwsConfiguration configuration = 2;
          */
-        value: AwsTranscribeConfiguration;
+        value: AudioTranscribeAwsConfiguration;
         case: "configuration";
     } | {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<AwsTranscribeMessage>);
+    constructor(data?: PartialMessage<AudioTranscribeAwsMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AwsTranscribeMessage";
+    static readonly typeName = "norsk.api.media.AudioTranscribeAwsMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AwsTranscribeMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AwsTranscribeMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AwsTranscribeMessage;
-    static equals(a: AwsTranscribeMessage | PlainMessage<AwsTranscribeMessage> | undefined, b: AwsTranscribeMessage | PlainMessage<AwsTranscribeMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioTranscribeAwsMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioTranscribeAwsMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioTranscribeAwsMessage;
+    static equals(a: AudioTranscribeAwsMessage | PlainMessage<AudioTranscribeAwsMessage> | undefined, b: AudioTranscribeAwsMessage | PlainMessage<AudioTranscribeAwsMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.AwsTranscribeEvent
+ * @generated from message norsk.api.media.AudioTranscribeAwsEvent
  */
-export declare class AwsTranscribeEvent extends Message<AwsTranscribeEvent> {
+export declare class AudioTranscribeAwsEvent extends Message<AudioTranscribeAwsEvent> {
     /**
-     * @generated from oneof norsk.api.media.AwsTranscribeEvent.message
+     * @generated from oneof norsk.api.media.AudioTranscribeAwsEvent.message
      */
     message: {
         /**
@@ -10263,14 +10272,14 @@ export declare class AwsTranscribeEvent extends Message<AwsTranscribeEvent> {
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<AwsTranscribeEvent>);
+    constructor(data?: PartialMessage<AudioTranscribeAwsEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.AwsTranscribeEvent";
+    static readonly typeName = "norsk.api.media.AudioTranscribeAwsEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AwsTranscribeEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AwsTranscribeEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AwsTranscribeEvent;
-    static equals(a: AwsTranscribeEvent | PlainMessage<AwsTranscribeEvent> | undefined, b: AwsTranscribeEvent | PlainMessage<AwsTranscribeEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioTranscribeAwsEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioTranscribeAwsEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioTranscribeAwsEvent;
+    static equals(a: AudioTranscribeAwsEvent | PlainMessage<AudioTranscribeAwsEvent> | undefined, b: AudioTranscribeAwsEvent | PlainMessage<AudioTranscribeAwsEvent> | undefined): boolean;
 }
 /**
  * ////////////////////////////////////////////////////////////////////////////