@norskvideo/norsk-api 1.0.343 → 1.0.344

package/lib/media_grpc_pb.d.ts

@@ -59,7 +59,7 @@ interface IMediaService extends grpc.ServiceDefinition<grpc.UntypedServiceImplem
     createTransformStreamMetadataOverride: IMediaService_ICreateTransformStreamMetadataOverride;
     createTransformJitterBuffer: IMediaService_ICreateTransformJitterBuffer;
     createTransformStreamSync: IMediaService_ICreateTransformStreamSync;
-    createTransformStreamProgramJoin: IMediaService_ICreateTransformStreamProgramJoin;
+    createTransformStreamAlign: IMediaService_ICreateTransformStreamAlign;
     createControlStreamStatistics: IMediaService_ICreateControlStreamStatistics;
     createControlAudioMeasureLevels: IMediaService_ICreateControlAudioMeasureLevels;
     createTransformAncillary: IMediaService_ICreateTransformAncillary;
@@ -501,14 +501,14 @@ interface IMediaService_ICreateTransformStreamSync extends grpc.MethodDefinition
     responseSerialize: grpc.serialize<media_pb.StreamSyncEvent>;
     responseDeserialize: grpc.deserialize<media_pb.StreamSyncEvent>;
 }
-interface IMediaService_ICreateTransformStreamProgramJoin extends grpc.MethodDefinition<media_pb.StreamProgramJoinMessage, media_pb.StreamProgramJoinEvent> {
-    path: "/norsk.api.media.Media/CreateTransformStreamProgramJoin";
+interface IMediaService_ICreateTransformStreamAlign extends grpc.MethodDefinition<media_pb.StreamAlignMessage, media_pb.StreamAlignEvent> {
+    path: "/norsk.api.media.Media/CreateTransformStreamAlign";
     requestStream: true;
     responseStream: true;
-    requestSerialize: grpc.serialize<media_pb.StreamProgramJoinMessage>;
-    requestDeserialize: grpc.deserialize<media_pb.StreamProgramJoinMessage>;
-    responseSerialize: grpc.serialize<media_pb.StreamProgramJoinEvent>;
-    responseDeserialize: grpc.deserialize<media_pb.StreamProgramJoinEvent>;
+    requestSerialize: grpc.serialize<media_pb.StreamAlignMessage>;
+    requestDeserialize: grpc.deserialize<media_pb.StreamAlignMessage>;
+    responseSerialize: grpc.serialize<media_pb.StreamAlignEvent>;
+    responseDeserialize: grpc.deserialize<media_pb.StreamAlignEvent>;
 }
 interface IMediaService_ICreateControlStreamStatistics extends grpc.MethodDefinition<media_pb.StreamStatisticsMessage, media_pb.StreamStatisticsEvent> {
     path: "/norsk.api.media.Media/CreateControlStreamStatistics";
@@ -625,7 +625,7 @@ export interface IMediaServer extends grpc.UntypedServiceImplementation {
     createTransformStreamMetadataOverride: grpc.handleBidiStreamingCall<media_pb.StreamMetadataOverrideMessage, media_pb.StreamMetadataOverrideEvent>;
     createTransformJitterBuffer: grpc.handleBidiStreamingCall<media_pb.JitterBufferMessage, media_pb.JitterBufferEvent>;
     createTransformStreamSync: grpc.handleBidiStreamingCall<media_pb.StreamSyncMessage, media_pb.StreamSyncEvent>;
-    createTransformStreamProgramJoin: grpc.handleBidiStreamingCall<media_pb.StreamProgramJoinMessage, media_pb.StreamProgramJoinEvent>;
+    createTransformStreamAlign: grpc.handleBidiStreamingCall<media_pb.StreamAlignMessage, media_pb.StreamAlignEvent>;
     createControlStreamStatistics: grpc.handleBidiStreamingCall<media_pb.StreamStatisticsMessage, media_pb.StreamStatisticsEvent>;
     createControlAudioMeasureLevels: grpc.handleBidiStreamingCall<media_pb.AudioMeasureLevelsMessage, media_pb.AudioMeasureLevelsEvent>;
     createTransformAncillary: grpc.handleBidiStreamingCall<media_pb.AncillaryMessage, media_pb.AncillaryEvent>;
@@ -776,9 +776,9 @@ export interface IMediaClient {
     createTransformStreamSync(): grpc.ClientDuplexStream<media_pb.StreamSyncMessage, media_pb.StreamSyncEvent>;
     createTransformStreamSync(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamSyncMessage, media_pb.StreamSyncEvent>;
     createTransformStreamSync(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamSyncMessage, media_pb.StreamSyncEvent>;
-    createTransformStreamProgramJoin(): grpc.ClientDuplexStream<media_pb.StreamProgramJoinMessage, media_pb.StreamProgramJoinEvent>;
-    createTransformStreamProgramJoin(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamProgramJoinMessage, media_pb.StreamProgramJoinEvent>;
-    createTransformStreamProgramJoin(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamProgramJoinMessage, media_pb.StreamProgramJoinEvent>;
+    createTransformStreamAlign(): grpc.ClientDuplexStream<media_pb.StreamAlignMessage, media_pb.StreamAlignEvent>;
+    createTransformStreamAlign(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamAlignMessage, media_pb.StreamAlignEvent>;
+    createTransformStreamAlign(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamAlignMessage, media_pb.StreamAlignEvent>;
     createControlStreamStatistics(): grpc.ClientDuplexStream<media_pb.StreamStatisticsMessage, media_pb.StreamStatisticsEvent>;
     createControlStreamStatistics(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamStatisticsMessage, media_pb.StreamStatisticsEvent>;
     createControlStreamStatistics(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamStatisticsMessage, media_pb.StreamStatisticsEvent>;
@@ -900,8 +900,8 @@ export class MediaClient extends grpc.Client implements IMediaClient {
     public createTransformJitterBuffer(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.JitterBufferMessage, media_pb.JitterBufferEvent>;
     public createTransformStreamSync(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamSyncMessage, media_pb.StreamSyncEvent>;
     public createTransformStreamSync(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamSyncMessage, media_pb.StreamSyncEvent>;
-    public createTransformStreamProgramJoin(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamProgramJoinMessage, media_pb.StreamProgramJoinEvent>;
-    public createTransformStreamProgramJoin(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamProgramJoinMessage, media_pb.StreamProgramJoinEvent>;
+    public createTransformStreamAlign(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamAlignMessage, media_pb.StreamAlignEvent>;
+    public createTransformStreamAlign(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamAlignMessage, media_pb.StreamAlignEvent>;
     public createControlStreamStatistics(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamStatisticsMessage, media_pb.StreamStatisticsEvent>;
     public createControlStreamStatistics(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.StreamStatisticsMessage, media_pb.StreamStatisticsEvent>;
     public createControlAudioMeasureLevels(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<media_pb.AudioMeasureLevelsMessage, media_pb.AudioMeasureLevelsEvent>;

package/lib/media_grpc_pb.js

@@ -689,6 +689,28 @@ function deserialize_norsk_api_media_SrtOutputMessage(buffer_arg) {
   return media_pb.SrtOutputMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_norsk_api_media_StreamAlignEvent(arg) {
+  if (!(arg instanceof media_pb.StreamAlignEvent)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamAlignEvent');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_StreamAlignEvent(buffer_arg) {
+  return media_pb.StreamAlignEvent.fromBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_norsk_api_media_StreamAlignMessage(arg) {
+  if (!(arg instanceof media_pb.StreamAlignMessage)) {
+    throw new Error('Expected argument of type norsk.api.media.StreamAlignMessage');
+  }
+  return Buffer.from(arg.toBinary());
+}
+
+function deserialize_norsk_api_media_StreamAlignMessage(buffer_arg) {
+  return media_pb.StreamAlignMessage.fromBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_norsk_api_media_StreamChaosMonkeyEvent(arg) {
   if (!(arg instanceof media_pb.StreamChaosMonkeyEvent)) {
     throw new Error('Expected argument of type norsk.api.media.StreamChaosMonkeyEvent');
@@ -755,28 +777,6 @@ function deserialize_norsk_api_media_StreamMetadataOverrideMessage(buffer_arg) {
   return media_pb.StreamMetadataOverrideMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
-function serialize_norsk_api_media_StreamProgramJoinEvent(arg) {
-  if (!(arg instanceof media_pb.StreamProgramJoinEvent)) {
-    throw new Error('Expected argument of type norsk.api.media.StreamProgramJoinEvent');
-  }
-  return Buffer.from(arg.toBinary());
-}
-
-function deserialize_norsk_api_media_StreamProgramJoinEvent(buffer_arg) {
-  return media_pb.StreamProgramJoinEvent.fromBinary(new Uint8Array(buffer_arg));
-}
-
-function serialize_norsk_api_media_StreamProgramJoinMessage(arg) {
-  if (!(arg instanceof media_pb.StreamProgramJoinMessage)) {
-    throw new Error('Expected argument of type norsk.api.media.StreamProgramJoinMessage');
-  }
-  return Buffer.from(arg.toBinary());
-}
-
-function deserialize_norsk_api_media_StreamProgramJoinMessage(buffer_arg) {
-  return media_pb.StreamProgramJoinMessage.fromBinary(new Uint8Array(buffer_arg));
-}
-
 function serialize_norsk_api_media_StreamStatisticsEvent(arg) {
   if (!(arg instanceof media_pb.StreamStatisticsEvent)) {
     throw new Error('Expected argument of type norsk.api.media.StreamStatisticsEvent');
@@ -1787,21 +1787,19 @@ createTransformStreamSync: {
     responseDeserialize: deserialize_norsk_api_media_StreamSyncEvent,
   },
   // *
-// Take multiple subscriptions, wait for all frames to be available on all streams
-// Set the program of each stream to be the same, and then rebase all timestamps so that
-// all streams start at the same point.
-// This is useful if multiple inputs are supposed to be connected at the same time (file readers for example)
-// and we want their timestamps to be aligned completely
-createTransformStreamProgramJoin: {
-    path: '/norsk.api.media.Media/CreateTransformStreamProgramJoin',
+// Take multiple streams from a single program, and rebase their timestamps so that they are all aligned 
+// This can ensure that frames going into streamswitch don't end up with gaps over a switch boundary
+// Additionally, merging multiple video streams in compose and multiple audio streams in audio mix
+createTransformStreamAlign: {
+    path: '/norsk.api.media.Media/CreateTransformStreamAlign',
     requestStream: true,
     responseStream: true,
-    requestType: media_pb.StreamProgramJoinMessage,
-    responseType: media_pb.StreamProgramJoinEvent,
-    requestSerialize: serialize_norsk_api_media_StreamProgramJoinMessage,
-    requestDeserialize: deserialize_norsk_api_media_StreamProgramJoinMessage,
-    responseSerialize: serialize_norsk_api_media_StreamProgramJoinEvent,
-    responseDeserialize: deserialize_norsk_api_media_StreamProgramJoinEvent,
+    requestType: media_pb.StreamAlignMessage,
+    responseType: media_pb.StreamAlignEvent,
+    requestSerialize: serialize_norsk_api_media_StreamAlignMessage,
+    requestDeserialize: deserialize_norsk_api_media_StreamAlignMessage,
+    responseSerialize: serialize_norsk_api_media_StreamAlignEvent,
+    responseDeserialize: deserialize_norsk_api_media_StreamAlignEvent,
   },
   // *
 // Record statistical information about media streams, including bitrate,

package/lib/media_pb.d.ts

@@ -445,6 +445,23 @@ export declare enum SrtMode {
      */
     Caller = 1
 }
+/**
+ * @generated from enum norsk.api.media.TestCardPattern
+ */
+export declare enum TestCardPattern {
+    /**
+     * @generated from enum value: Black = 0;
+     */
+    Black = 0,
+    /**
+     * @generated from enum value: Smpte75 = 1;
+     */
+    Smpte75 = 1,
+    /**
+     * @generated from enum value: Smpte100 = 2;
+     */
+    Smpte100 = 2
+}
 /**
  * ///////////////////////////////
  * DeckLink Input
@@ -1778,6 +1795,12 @@ export declare class StreamMetadata_VideoMetadata extends Message<StreamMetadata
      * @generated from field: int32 bitrate = 5;
      */
     bitrate: number;
+    /**
+     * The framerate of this video
+     *
+     * @generated from field: norsk.api.media.FrameRate frame_rate = 6;
+     */
+    frameRate?: FrameRate;
     constructor(data?: PartialMessage<StreamMetadata_VideoMetadata>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.StreamMetadata.VideoMetadata";
@@ -3737,13 +3760,25 @@ export declare class TestCardVideoConfiguration extends Message<TestCardVideoCon
      */
     resolution?: Resolution;
     /**
-     * @generated from field: string source_name = 2;
+     * @generated from field: norsk.api.media.FrameRate frame_rate = 2;
+     */
+    frameRate?: FrameRate;
+    /**
+     * @generated from field: string source_name = 3;
      */
     sourceName: string;
     /**
-     * @generated from field: int32 number_of_frames = 3;
+     * @generated from field: int32 number_of_frames = 4;
      */
     numberOfFrames: number;
+    /**
+     * @generated from field: bool realtime = 5;
+     */
+    realtime: boolean;
+    /**
+     * @generated from field: norsk.api.media.TestCardPattern pattern = 6;
+     */
+    pattern: TestCardPattern;
     constructor(data?: PartialMessage<TestCardVideoConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.TestCardVideoConfiguration";
@@ -3804,12 +3839,6 @@ export declare class VideoTestCardGeneratorEvent extends Message<VideoTestCardGe
          */
         value: Context;
         case: "outboundContext";
-    } | {
-        /**
-         * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 3;
-         */
-        value: SubscriptionResponse;
-        case: "subscriptionResponse";
     } | {
         case: undefined;
         value?: undefined;
@@ -10497,34 +10526,46 @@ export declare class StreamSyncEvent extends Message<StreamSyncEvent> {
     static equals(a: StreamSyncEvent | PlainMessage<StreamSyncEvent> | undefined, b: StreamSyncEvent | PlainMessage<StreamSyncEvent> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.StreamProgramJoinConfiguration
+ * @generated from message norsk.api.media.StreamAlignConfiguration
  */
-export declare class StreamProgramJoinConfiguration extends Message<StreamProgramJoinConfiguration> {
+export declare class StreamAlignConfiguration extends Message<StreamAlignConfiguration> {
     /**
      * @generated from field: norsk.api.media.MediaNodeId id = 1;
      */
     id?: MediaNodeId;
-    constructor(data?: PartialMessage<StreamProgramJoinConfiguration>);
+    /**
+     * The normalisd sample rate of the audio output
+     *
+     * @generated from field: norsk.api.media.SampleRate sample_rate = 2;
+     */
+    sampleRate: SampleRate;
+    /**
+     * The normalised frame rate of the video output
+     *
+     * @generated from field: norsk.api.media.FrameRate frame_rate = 3;
+     */
+    frameRate?: FrameRate;
+    constructor(data?: PartialMessage<StreamAlignConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.StreamProgramJoinConfiguration";
+    static readonly typeName = "norsk.api.media.StreamAlignConfiguration";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamProgramJoinConfiguration;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamProgramJoinConfiguration;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamProgramJoinConfiguration;
-    static equals(a: StreamProgramJoinConfiguration | PlainMessage<StreamProgramJoinConfiguration> | undefined, b: StreamProgramJoinConfiguration | PlainMessage<StreamProgramJoinConfiguration> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamAlignConfiguration;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamAlignConfiguration;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamAlignConfiguration;
+    static equals(a: StreamAlignConfiguration | PlainMessage<StreamAlignConfiguration> | undefined, b: StreamAlignConfiguration | PlainMessage<StreamAlignConfiguration> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.StreamProgramJoinMessage
+ * @generated from message norsk.api.media.StreamAlignMessage
  */
-export declare class StreamProgramJoinMessage extends Message<StreamProgramJoinMessage> {
+export declare class StreamAlignMessage extends Message<StreamAlignMessage> {
     /**
-     * @generated from oneof norsk.api.media.StreamProgramJoinMessage.message
+     * @generated from oneof norsk.api.media.StreamAlignMessage.message
      */
     message: {
         /**
-         * @generated from field: norsk.api.media.StreamProgramJoinConfiguration initial_config = 1;
+         * @generated from field: norsk.api.media.StreamAlignConfiguration initial_config = 1;
          */
-        value: StreamProgramJoinConfiguration;
+        value: StreamAlignConfiguration;
         case: "initialConfig";
     } | {
         /**
@@ -10536,21 +10577,21 @@ export declare class StreamProgramJoinMessage extends Message<StreamProgramJoinM
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<StreamProgramJoinMessage>);
+    constructor(data?: PartialMessage<StreamAlignMessage>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.StreamProgramJoinMessage";
+    static readonly typeName = "norsk.api.media.StreamAlignMessage";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamProgramJoinMessage;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamProgramJoinMessage;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamProgramJoinMessage;
-    static equals(a: StreamProgramJoinMessage | PlainMessage<StreamProgramJoinMessage> | undefined, b: StreamProgramJoinMessage | PlainMessage<StreamProgramJoinMessage> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamAlignMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamAlignMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamAlignMessage;
+    static equals(a: StreamAlignMessage | PlainMessage<StreamAlignMessage> | undefined, b: StreamAlignMessage | PlainMessage<StreamAlignMessage> | undefined): boolean;
 }
 /**
- * @generated from message norsk.api.media.StreamProgramJoinEvent
+ * @generated from message norsk.api.media.StreamAlignEvent
  */
-export declare class StreamProgramJoinEvent extends Message<StreamProgramJoinEvent> {
+export declare class StreamAlignEvent extends Message<StreamAlignEvent> {
     /**
-     * @generated from oneof norsk.api.media.StreamProgramJoinEvent.message
+     * @generated from oneof norsk.api.media.StreamAlignEvent.message
      */
     message: {
         /**
@@ -10580,14 +10621,14 @@ export declare class StreamProgramJoinEvent extends Message<StreamProgramJoinEve
         case: undefined;
         value?: undefined;
     };
-    constructor(data?: PartialMessage<StreamProgramJoinEvent>);
+    constructor(data?: PartialMessage<StreamAlignEvent>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
-    static readonly typeName = "norsk.api.media.StreamProgramJoinEvent";
+    static readonly typeName = "norsk.api.media.StreamAlignEvent";
     static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamProgramJoinEvent;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamProgramJoinEvent;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamProgramJoinEvent;
-    static equals(a: StreamProgramJoinEvent | PlainMessage<StreamProgramJoinEvent> | undefined, b: StreamProgramJoinEvent | PlainMessage<StreamProgramJoinEvent> | undefined): boolean;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamAlignEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamAlignEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamAlignEvent;
+    static equals(a: StreamAlignEvent | PlainMessage<StreamAlignEvent> | undefined, b: StreamAlignEvent | PlainMessage<StreamAlignEvent> | undefined): boolean;
 }
 /**
  * ///////////////////////////////
@@ -10819,6 +10860,8 @@ export declare class StreamSwitchSmoothConfiguration extends Message<StreamSwitc
      */
     transitionDurationMs: number;
     /**
+     * Resolution of the normalised output
+     *
      * @generated from field: norsk.api.media.Resolution output_resolution = 5;
      */
     outputResolution?: Resolution;
@@ -10828,6 +10871,24 @@ export declare class StreamSwitchSmoothConfiguration extends Message<StreamSwitc
      * @generated from field: norsk.api.media.SampleRate sample_rate = 6;
      */
     sampleRate: SampleRate;
+    /**
+     * The frame rate of the output
+     *
+     * @generated from field: norsk.api.media.FrameRate frame_rate = 7;
+     */
+    frameRate?: FrameRate;
+    /**
+     * The channel layout of the output
+     *
+     * @generated from field: norsk.api.media.ChannelLayout channel_layout = 8;
+     */
+    channelLayout?: ChannelLayout;
+    /**
+     * Align all timestamps to minimise timestamp jitter on mixed streams
+     *
+     * @generated from field: norsk.api.media.StreamSwitchSmoothConfiguration.Alignment alignment = 9;
+     */
+    alignment: StreamSwitchSmoothConfiguration_Alignment;
     constructor(data?: PartialMessage<StreamSwitchSmoothConfiguration>);
     static readonly runtime: import("@bufbuild/protobuf/dist/types/private/proto-runtime.js").ProtoRuntime;
     static readonly typeName = "norsk.api.media.StreamSwitchSmoothConfiguration";
@@ -10837,6 +10898,21 @@ export declare class StreamSwitchSmoothConfiguration extends Message<StreamSwitc
     static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamSwitchSmoothConfiguration;
     static equals(a: StreamSwitchSmoothConfiguration | PlainMessage<StreamSwitchSmoothConfiguration> | undefined, b: StreamSwitchSmoothConfiguration | PlainMessage<StreamSwitchSmoothConfiguration> | undefined): boolean;
 }
+/**
+ * Whether to align all the incoming timestamps
+ *
+ * @generated from enum norsk.api.media.StreamSwitchSmoothConfiguration.Alignment
+ */
+export declare enum StreamSwitchSmoothConfiguration_Alignment {
+    /**
+     * @generated from enum value: ALIGNED = 0;
+     */
+    ALIGNED = 0,
+    /**
+     * @generated from enum value: NO_ALIGNMENT = 1;
+     */
+    NO_ALIGNMENT = 1
+}
 /**
  * @generated from message norsk.api.media.StreamSwitchSmoothSwitch
  */