@norskvideo/norsk-api 0.0.330 → 1.0.331

package/lib/media_pb.d.ts

@@ -1881,32 +1881,32 @@ export declare class TimestampSourceProgramNudge extends Message<TimestampSource
  * sent to the client.
  *
  * These are reported on most input and output media nodes and also for the
- * dedicated StreamStats node.
+ * 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;
      */
@@ -1923,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
@@ -1971,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
      *
@@ -1987,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;
 }
 /**
  * *
@@ -2114,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";
     } | {
         /**
@@ -2160,14 +2160,14 @@ 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;
 }
 /**
  * *
@@ -2210,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;
      */
@@ -2286,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: {
         /**
@@ -2318,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;
 }
 /**
  * ////////////////////////////////////////////////////////////////////////////
@@ -2516,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;
@@ -2534,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;
      */
@@ -2550,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";
     } | {
         /**
@@ -2585,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;
      */
@@ -2636,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: {
         /**
@@ -2668,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
@@ -2712,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";
@@ -2975,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;
@@ -3013,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";
@@ -3066,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;
@@ -3100,9 +3100,9 @@ export declare class M3u8MediaInputConfiguration extends Message<M3u8MediaInputC
      */
     url: string;
     /**
-     * @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";
@@ -3153,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;
@@ -3213,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: {
         /**
@@ -3235,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: {
         /**
@@ -3273,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
@@ -3332,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";
@@ -3397,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;
@@ -3415,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;
      */
@@ -3431,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;
      */
@@ -3513,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: {
         /**
@@ -3533,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;
      */
@@ -3567,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";
     } | {
         /**
@@ -3602,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;
      */
@@ -3642,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;
      */
@@ -3653,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: {
         /**
@@ -3683,34 +3683,34 @@ 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
@@ -3849,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";
@@ -4033,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;
@@ -4077,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;
@@ -4107,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";
@@ -4172,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;
@@ -4401,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: {
         /**
@@ -4415,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
      *
@@ -4493,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
@@ -4504,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;
      */
@@ -4558,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;
      */
@@ -4580,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: {
         /**
@@ -4633,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
@@ -4664,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
      *
@@ -4679,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: {
         /**
@@ -4703,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
      *
@@ -4742,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
      *
@@ -4757,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: {
         /**
@@ -4814,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: {
         /**
@@ -4838,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
@@ -4880,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
      *
@@ -4920,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: {
         /**
@@ -4975,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
@@ -5524,9 +5524,9 @@ export declare class CmafVideoConfiguration extends Message<CmafVideoConfigurati
      */
     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;
      */
@@ -5595,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";
@@ -5664,9 +5664,9 @@ export declare class CmafAudioConfiguration extends Message<CmafAudioConfigurati
      */
     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;
      */
@@ -5735,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";
@@ -6011,9 +6011,9 @@ export declare class CmafMasterConfiguration extends Message<CmafMasterConfigura
      */
     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;
      */
@@ -6082,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";
@@ -6147,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";
@@ -6212,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";
@@ -6281,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";
@@ -6389,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;
@@ -6407,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;
      */
@@ -6427,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: {
         /**
@@ -6454,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: {
         /**
@@ -6498,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
@@ -6544,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";
@@ -6621,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;
@@ -6639,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;
      */
@@ -6655,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: {
         /**
@@ -6682,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: {
         /**
@@ -6735,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: {
         /**
@@ -6779,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
@@ -6829,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;
@@ -6859,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";
@@ -6934,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;
@@ -6952,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;
      */
@@ -6964,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: {
         /**
@@ -6991,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: {
         /**
@@ -7035,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;
      */
@@ -7073,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: {
         /**
@@ -7117,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 write_file = 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: {
         /**
@@ -7167,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
@@ -7837,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;
      */
@@ -7857,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: {
         /**
@@ -7899,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: {
         /**
@@ -7944,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: {
         /**
@@ -7990,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
@@ -8539,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: {
         /**
@@ -8565,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: {
         /**
@@ -8589,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: {
         /**
@@ -8635,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;
      */
@@ -8656,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";
     } | {
         /**
@@ -8694,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: {
         /**
@@ -8732,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
@@ -8833,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;
      */
@@ -8864,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
      *
@@ -8901,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";
     } | {
         /**
@@ -8939,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: {
         /**
@@ -8977,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";
     } | {
         /**
@@ -9026,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: {
         /**
@@ -9064,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;
      */
@@ -9119,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;
      */
@@ -9132,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;
      */
@@ -9165,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: {
         /**
@@ -9215,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: {
         /**
@@ -9261,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;
      */
@@ -9306,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: {
         /**
@@ -9349,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: {
         /**
@@ -9401,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;
      */
@@ -9430,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: {
         /**
@@ -9473,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: {
         /**
@@ -9525,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: {
         /**
@@ -9573,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: {
         /**
@@ -9611,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;
@@ -9625,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;
      */
@@ -9646,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: {
         /**
@@ -9670,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)
@@ -9760,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;
      */
@@ -9775,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: {
         /**
@@ -9805,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";
     } | {
         /**
@@ -9819,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;
 }
 /**
  * ///////////////////////////////
@@ -10087,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";
@@ -10152,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;
@@ -10173,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;
      */
@@ -10206,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: {
         /**
@@ -10230,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: {
         /**
@@ -10276,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;
 }
 /**
  * ////////////////////////////////////////////////////////////////////////////