@norskvideo/norsk-api 1.0.391 → 1.0.392

package/lib/media_pb.ts

@@ -2933,7 +2933,8 @@ export class Context extends Message<Context> {
  * .
  * Once received, your code **must** acknowledge the context change
  * with a call through a subscription channel `Media.createSubscriptionChannel`,
- * passing in the `blockingCallRef` to an 'unblock' message; note that if using the
+ * passing in the `blockingCallRef` to an 'unblock' message; note that if using
+ * the
  * JavaScript SDK then this is automatically handled.
  *
  * @generated from message norsk.api.media.MultipleContext
@@ -8585,10 +8586,19 @@ export class FileWavOutputEvent extends Message<FileWavOutputEvent> {
  */
 export class SineWave extends Message<SineWave> {
   /**
+   * Frequency of the wave
+   *
    * @generated from field: float freq = 1;
    */
   freq = 0;
 
+  /**
+   * Initial level of the wave (default 0 being a full-scale wave). A negative number or 0.
+   *
+   * @generated from field: float db = 2;
+   */
+  db = 0;
+
   constructor(data?: PartialMessage<SineWave>) {
     super();
     proto3.util.initPartial(data, this);
@@ -8598,6 +8608,7 @@ export class SineWave extends Message<SineWave> {
   static readonly typeName = "norsk.api.media.SineWave";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "freq", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
+    { no: 2, name: "db", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SineWave {
@@ -8618,6 +8629,193 @@ export class SineWave extends Message<SineWave> {
 }
 
 /**
+ * @generated from message norsk.api.media.Silence
+ */
+export class Silence extends Message<Silence> {
+  constructor(data?: PartialMessage<Silence>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Silence";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Silence {
+    return new Silence().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Silence {
+    return new Silence().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Silence {
+    return new Silence().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Silence | PlainMessage<Silence> | undefined, b: Silence | PlainMessage<Silence> | undefined): boolean {
+    return proto3.util.equals(Silence, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Compound
+ */
+export class Compound extends Message<Compound> {
+  /**
+   * @generated from field: repeated norsk.api.media.Wave components = 1;
+   */
+  components: Wave[] = [];
+
+  constructor(data?: PartialMessage<Compound>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Compound";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "components", kind: "message", T: Wave, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Compound {
+    return new Compound().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Compound {
+    return new Compound().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Compound {
+    return new Compound().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Compound | PlainMessage<Compound> | undefined, b: Compound | PlainMessage<Compound> | undefined): boolean {
+    return proto3.util.equals(Compound, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Sequence
+ */
+export class Sequence extends Message<Sequence> {
+  /**
+   * @generated from field: repeated norsk.api.media.Wave components = 1;
+   */
+  components: Wave[] = [];
+
+  constructor(data?: PartialMessage<Sequence>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Sequence";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "components", kind: "message", T: Wave, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Sequence {
+    return new Sequence().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Sequence {
+    return new Sequence().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Sequence {
+    return new Sequence().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Sequence | PlainMessage<Sequence> | undefined, b: Sequence | PlainMessage<Sequence> | undefined): boolean {
+    return proto3.util.equals(Sequence, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Loop
+ */
+export class Loop extends Message<Loop> {
+  /**
+   * @generated from field: norsk.api.media.Wave component = 1;
+   */
+  component?: Wave;
+
+  constructor(data?: PartialMessage<Loop>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Loop";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "component", kind: "message", T: Wave },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Loop {
+    return new Loop().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Loop {
+    return new Loop().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Loop {
+    return new Loop().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Loop | PlainMessage<Loop> | undefined, b: Loop | PlainMessage<Loop> | undefined): boolean {
+    return proto3.util.equals(Loop, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.Timed
+ */
+export class Timed extends Message<Timed> {
+  /**
+   * @generated from field: norsk.api.media.Wave component = 1;
+   */
+  component?: Wave;
+
+  /**
+   * @generated from field: float duration_ms = 2;
+   */
+  durationMs = 0;
+
+  constructor(data?: PartialMessage<Timed>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.Timed";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "component", kind: "message", T: Wave },
+    { no: 2, name: "duration_ms", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Timed {
+    return new Timed().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Timed {
+    return new Timed().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Timed {
+    return new Timed().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Timed | PlainMessage<Timed> | undefined, b: Timed | PlainMessage<Timed> | undefined): boolean {
+    return proto3.util.equals(Timed, a, b);
+  }
+}
+
+/**
+ * A wave description as used by audio signal generator
+ *
  * @generated from message norsk.api.media.Wave
  */
 export class Wave extends Message<Wave> {
@@ -8630,6 +8828,36 @@ export class Wave extends Message<Wave> {
      */
     value: SineWave;
     case: "sine";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Silence silence = 2;
+     */
+    value: Silence;
+    case: "silence";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Compound compound = 3;
+     */
+    value: Compound;
+    case: "compound";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Sequence sequence = 4;
+     */
+    value: Sequence;
+    case: "sequence";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Loop loop = 5;
+     */
+    value: Loop;
+    case: "loop";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Timed timed = 6;
+     */
+    value: Timed;
+    case: "timed";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<Wave>) {
@@ -8641,6 +8869,11 @@ export class Wave extends Message<Wave> {
   static readonly typeName = "norsk.api.media.Wave";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "sine", kind: "message", T: SineWave, oneof: "message" },
+    { no: 2, name: "silence", kind: "message", T: Silence, oneof: "message" },
+    { no: 3, name: "compound", kind: "message", T: Compound, oneof: "message" },
+    { no: 4, name: "sequence", kind: "message", T: Sequence, oneof: "message" },
+    { no: 5, name: "loop", kind: "message", T: Loop, oneof: "message" },
+    { no: 6, name: "timed", kind: "message", T: Timed, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Wave {
@@ -8745,6 +8978,93 @@ export class AudioSignalGeneratorConfiguration extends Message<AudioSignalGenera
   }
 }
 
+/**
+ * @generated from message norsk.api.media.AudioSignalGeneratorConfigurationUpdate
+ */
+export class AudioSignalGeneratorConfigurationUpdate extends Message<AudioSignalGeneratorConfigurationUpdate> {
+  /**
+   * @generated from field: norsk.api.media.Wave wave = 1;
+   */
+  wave?: Wave;
+
+  constructor(data?: PartialMessage<AudioSignalGeneratorConfigurationUpdate>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AudioSignalGeneratorConfigurationUpdate";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "wave", kind: "message", T: Wave },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioSignalGeneratorConfigurationUpdate {
+    return new AudioSignalGeneratorConfigurationUpdate().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioSignalGeneratorConfigurationUpdate {
+    return new AudioSignalGeneratorConfigurationUpdate().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioSignalGeneratorConfigurationUpdate {
+    return new AudioSignalGeneratorConfigurationUpdate().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AudioSignalGeneratorConfigurationUpdate | PlainMessage<AudioSignalGeneratorConfigurationUpdate> | undefined, b: AudioSignalGeneratorConfigurationUpdate | PlainMessage<AudioSignalGeneratorConfigurationUpdate> | undefined): boolean {
+    return proto3.util.equals(AudioSignalGeneratorConfigurationUpdate, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.AudioSignalGeneratorMessage
+ */
+export class AudioSignalGeneratorMessage extends Message<AudioSignalGeneratorMessage> {
+  /**
+   * @generated from oneof norsk.api.media.AudioSignalGeneratorMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.AudioSignalGeneratorConfiguration initial_config = 1;
+     */
+    value: AudioSignalGeneratorConfiguration;
+    case: "initialConfig";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.AudioSignalGeneratorConfigurationUpdate update_config = 2;
+     */
+    value: AudioSignalGeneratorConfigurationUpdate;
+    case: "updateConfig";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<AudioSignalGeneratorMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.AudioSignalGeneratorMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "initial_config", kind: "message", T: AudioSignalGeneratorConfiguration, oneof: "message" },
+    { no: 2, name: "update_config", kind: "message", T: AudioSignalGeneratorConfigurationUpdate, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioSignalGeneratorMessage {
+    return new AudioSignalGeneratorMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AudioSignalGeneratorMessage {
+    return new AudioSignalGeneratorMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AudioSignalGeneratorMessage {
+    return new AudioSignalGeneratorMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AudioSignalGeneratorMessage | PlainMessage<AudioSignalGeneratorMessage> | undefined, b: AudioSignalGeneratorMessage | PlainMessage<AudioSignalGeneratorMessage> | undefined): boolean {
+    return proto3.util.equals(AudioSignalGeneratorMessage, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.media.AudioSignalGeneratorEvent
  */
@@ -14044,7 +14364,8 @@ export class HlsPushDestination extends Message<HlsPushDestination> {
   supportsGzip = false;
 
   /**
-   * Whether to use TLS or plain TCP transport, by default TLS used if port is 443
+   * Whether to use TLS or plain TCP transport, by default TLS used if port is
+   * 443
    *
    * @generated from field: norsk.api.common.OptionalBool tls_transport = 11;
    */
@@ -17601,6 +17922,17 @@ export class VideoEncodeStream extends Message<VideoEncodeStream> {
     case: "amdMA35DAv1";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
+  /**
+   * @generated from oneof norsk.api.media.VideoEncodeStream.hints
+   */
+  hints: {
+    /**
+     * @generated from field: norsk.api.media.QuadraEncodeHints quadra = 19;
+     */
+    value: QuadraEncodeHints;
+    case: "quadra";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
   constructor(data?: PartialMessage<VideoEncodeStream>) {
     super();
     proto3.util.initPartial(data, this);
@@ -17627,6 +17959,7 @@ export class VideoEncodeStream extends Message<VideoEncodeStream> {
     { no: 16, name: "amdMA35DHevc", kind: "message", T: AmdMA35DHevc, oneof: "codec" },
     { no: 17, name: "quadraAv1", kind: "message", T: QuadraAv1, oneof: "codec" },
     { no: 18, name: "amdMA35DAv1", kind: "message", T: AmdMA35DAv1, oneof: "codec" },
+    { no: 19, name: "quadra", kind: "message", T: QuadraEncodeHints, oneof: "hints" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VideoEncodeStream {
@@ -18388,6 +18721,69 @@ proto3.util.setEnumType(NvidiaHevc_NvidiaHevcTier, "norsk.api.media.NvidiaHevc.N
   { no: 1, name: "NVIDIA_HEVC_TIER_HIGH" },
 ]);
 
+/**
+ * @generated from message norsk.api.media.QuadraEncodeHints
+ */
+export class QuadraEncodeHints extends Message<QuadraEncodeHints> {
+  /**
+   * @generated from field: norsk.api.media.QuadraEncodeHints.QuadraRescaleAlgorithm rescale = 1;
+   */
+  rescale = QuadraEncodeHints_QuadraRescaleAlgorithm.QUADRA_RESCALE_DEFAULT;
+
+  constructor(data?: PartialMessage<QuadraEncodeHints>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.QuadraEncodeHints";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "rescale", kind: "enum", T: proto3.getEnumType(QuadraEncodeHints_QuadraRescaleAlgorithm) },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuadraEncodeHints {
+    return new QuadraEncodeHints().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuadraEncodeHints {
+    return new QuadraEncodeHints().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuadraEncodeHints {
+    return new QuadraEncodeHints().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: QuadraEncodeHints | PlainMessage<QuadraEncodeHints> | undefined, b: QuadraEncodeHints | PlainMessage<QuadraEncodeHints> | undefined): boolean {
+    return proto3.util.equals(QuadraEncodeHints, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.QuadraEncodeHints.QuadraRescaleAlgorithm
+ */
+export enum QuadraEncodeHints_QuadraRescaleAlgorithm {
+  /**
+   * @generated from enum value: QUADRA_RESCALE_DEFAULT = 0;
+   */
+  QUADRA_RESCALE_DEFAULT = 0,
+
+  /**
+   * @generated from enum value: QUADRA_RESCALE_FILTERBLIT = 1;
+   */
+  QUADRA_RESCALE_FILTERBLIT = 1,
+
+  /**
+   * @generated from enum value: QUADRA_RESCALE_BICUBIC = 2;
+   */
+  QUADRA_RESCALE_BICUBIC = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(QuadraEncodeHints_QuadraRescaleAlgorithm)
+proto3.util.setEnumType(QuadraEncodeHints_QuadraRescaleAlgorithm, "norsk.api.media.QuadraEncodeHints.QuadraRescaleAlgorithm", [
+  { no: 0, name: "QUADRA_RESCALE_DEFAULT" },
+  { no: 1, name: "QUADRA_RESCALE_FILTERBLIT" },
+  { no: 2, name: "QUADRA_RESCALE_BICUBIC" },
+]);
+
 /**
  * @generated from message norsk.api.media.QuadraH264
  */
@@ -22438,12 +22834,15 @@ export class WebVttEncodeConfiguration extends Message<WebVttEncodeConfiguration
   minimumCueLength?: OptionalInt;
 
   /**
-   * Maximum number of lines in a cue. 
+   * Maximum number of lines in a cue.
    *
-   * Consider using a value of 1 and a longer max line length and allowing the player to break lines: per the WebVTT standard
-   * "In general, therefore, authors are encouraged to write cues all on one line except when a line break is definitely necessary."
-   * However if the player does not do this adequately, using the actual max line length desired and more lines, hard line breaks 
-   * will be inserted. Note a maximum subtitle length of two lines is recommended (eg BBC guidance)
+   * Consider using a value of 1 and a longer max line length and allowing the
+   * player to break lines: per the WebVTT standard "In general, therefore,
+   * authors are encouraged to write cues all on one line except when a line
+   * break is definitely necessary." However if the player does not do this
+   * adequately, using the actual max line length desired and more lines, hard
+   * line breaks will be inserted. Note a maximum subtitle length of two lines
+   * is recommended (eg BBC guidance)
    *
    * @generated from field: norsk.api.common.OptionalInt maximum_num_lines = 3;
    */
@@ -22616,9 +23015,11 @@ export class SubtitleConvertConfiguration extends Message<SubtitleConvertConfigu
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   /**
-   * For conversion from transcribed sources containing partial and complete transcriptions, filter to only include the transcription
-   * from a fully transcribed section/utterance. Note this may be multiple sentences and span up to 30s duration or beyond, making this
-   * generally an option for non-live flows
+   * For conversion from transcribed sources containing partial and complete
+   * transcriptions, filter to only include the transcription from a fully
+   * transcribed section/utterance. Note this may be multiple sentences and span
+   * up to 30s duration or beyond, making this generally an option for non-live
+   * flows
    *
    * @generated from field: bool only_complete = 5;
    */
@@ -22948,7 +23349,8 @@ export class StreamSwitchSmoothSwitch extends Message<StreamSwitchSmoothSwitch>
   newActiveSource?: InputPin;
 
   /**
-   * Optionally the duration of the transition (otherwise the configured default transition duration is used)
+   * Optionally the duration of the transition (otherwise the configured default
+   * transition duration is used)
    *
    * @generated from field: norsk.api.common.OptionalFloat transition_duration_ms = 2;
    */
@@ -24922,7 +25324,8 @@ export class AudioTranscribeAzureConfiguration extends Message<AudioTranscribeAz
   azureRegion = "";
 
   /**
-   * * Enable dictation mode (recognise dictated punctuation etc rather than transcribing the audio verbatim)  
+   * * Enable dictation mode (recognise dictated punctuation etc rather than
+   * transcribing the audio verbatim)  
    *
    * @generated from field: norsk.api.common.OptionalBool dictation = 8;
    */
@@ -25692,7 +26095,8 @@ export class MetadataMessage extends Message<MetadataMessage> {
   stream?: StreamKey;
 
   /**
-   * The raw data of the metadata message, excluding Metadata Access Unit wrapper if present
+   * The raw data of the metadata message, excluding Metadata Access Unit
+   * wrapper if present
    *
    * @generated from field: bytes data = 2;
    */
@@ -26718,7 +27122,8 @@ export class Scte35InsertCommandComponent extends Message<Scte35InsertCommandCom
  */
 export class Scte35SpliceTime extends Message<Scte35SpliceTime> {
   /**
-   * Splice time if specified (otherwise represents the default splice time in Component Splice Mode, see SCTE 35 9.9.2.1)
+   * Splice time if specified (otherwise represents the default splice time in
+   * Component Splice Mode, see SCTE 35 9.9.2.1)
    *
    * @generated from field: norsk.api.common.OptionalInt pts_time = 1;
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@norskvideo/norsk-api",
-  "version": "1.0.391",
+  "version": "1.0.392",
   "license": "MIT",
   "dependencies": {
     "@bufbuild/protobuf": "^0.3.0",