@norskvideo/norsk-api 1.0.367 → 1.0.370

package/lib/media_pb.ts

@@ -7,6 +7,32 @@ import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialM
 import { Empty, Message, proto3, protoInt64, Timestamp } from "@bufbuild/protobuf";
 import { CurrentLoad, Log, OptionalBool, OptionalInt, OptionalInt64, OptionalString, UInt32OrInfinity, Version } from "./shared/common_pb.js";
 
+/**
+ * @generated from enum norsk.api.media.NodeMetricsMode
+ */
+export enum NodeMetricsMode {
+  /**
+   * @generated from enum value: NODE_METRICS_ENABLE = 0;
+   */
+  NODE_METRICS_ENABLE = 0,
+
+  /**
+   * @generated from enum value: NODE_METRICS_MINIMAL = 1;
+   */
+  NODE_METRICS_MINIMAL = 1,
+
+  /**
+   * @generated from enum value: NODE_METRICS_NONE = 2;
+   */
+  NODE_METRICS_NONE = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(NodeMetricsMode)
+proto3.util.setEnumType(NodeMetricsMode, "norsk.api.media.NodeMetricsMode", [
+  { no: 0, name: "NODE_METRICS_ENABLE" },
+  { no: 1, name: "NODE_METRICS_MINIMAL" },
+  { no: 2, name: "NODE_METRICS_NONE" },
+]);
+
 /**
  * Enumeration of possible channel positions.
  *
@@ -10546,6 +10572,16 @@ export class AudioBuildMultichannelConfiguration extends Message<AudioBuildMulti
    */
   sampleRate = SampleRate.RATE_8000;
 
+  /**
+   * @generated from field: norsk.api.media.NodeMetricsMode metrics = 9;
+   */
+  metrics = NodeMetricsMode.NODE_METRICS_ENABLE;
+
+  /**
+   * @generated from field: norsk.api.media.SampleFormat sampleFormat = 10;
+   */
+  sampleFormat = SampleFormat.S16;
+
   constructor(data?: PartialMessage<AudioBuildMultichannelConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -10562,6 +10598,8 @@ export class AudioBuildMultichannelConfiguration extends Message<AudioBuildMulti
     { no: 6, name: "channel_layout", kind: "message", T: ChannelLayout },
     { no: 7, name: "channel_list", kind: "message", T: StreamKey, repeated: true },
     { no: 8, name: "sample_rate", kind: "enum", T: proto3.getEnumType(SampleRate) },
+    { no: 9, name: "metrics", kind: "enum", T: proto3.getEnumType(NodeMetricsMode) },
+    { no: 10, name: "sampleFormat", kind: "enum", T: proto3.getEnumType(SampleFormat) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioBuildMultichannelConfiguration {
@@ -10766,6 +10804,11 @@ export class AudioSplitMultichannelConfiguration extends Message<AudioSplitMulti
    */
   outputRenditionName?: RenditionName;
 
+  /**
+   * @generated from field: norsk.api.media.NodeMetricsMode metrics = 6;
+   */
+  metrics = NodeMetricsMode.NODE_METRICS_ENABLE;
+
   constructor(data?: PartialMessage<AudioSplitMultichannelConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -10779,6 +10822,7 @@ export class AudioSplitMultichannelConfiguration extends Message<AudioSplitMulti
     { no: 3, name: "output_source_name", kind: "message", T: SourceName },
     { no: 4, name: "output_program_number", kind: "message", T: ProgramNumber },
     { no: 5, name: "output_rendition_name", kind: "message", T: RenditionName },
+    { no: 6, name: "metrics", kind: "enum", T: proto3.getEnumType(NodeMetricsMode) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AudioSplitMultichannelConfiguration {
@@ -11233,6 +11277,11 @@ export class CmafVideoConfiguration extends Message<CmafVideoConfiguration> {
    */
   name?: OptionalString;
 
+  /**
+   * @generated from field: bool pdt_every_segment = 12;
+   */
+  pdtEverySegment = false;
+
   constructor(data?: PartialMessage<CmafVideoConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -11251,6 +11300,7 @@ export class CmafVideoConfiguration extends Message<CmafVideoConfiguration> {
     { no: 9, name: "mpd_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 10, name: "bitrate", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
     { no: 11, name: "name", kind: "message", T: OptionalString },
+    { no: 12, name: "pdt_every_segment", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafVideoConfiguration {
@@ -11382,6 +11432,11 @@ export class HlsTsVideoConfiguration extends Message<HlsTsVideoConfiguration> {
    */
   name?: OptionalString;
 
+  /**
+   * @generated from field: bool pdt_every_segment = 10;
+   */
+  pdtEverySegment = false;
+
   constructor(data?: PartialMessage<HlsTsVideoConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -11398,6 +11453,7 @@ export class HlsTsVideoConfiguration extends Message<HlsTsVideoConfiguration> {
     { no: 7, name: "mpd_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 8, name: "bitrate", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
     { no: 9, name: "name", kind: "message", T: OptionalString },
+    { no: 10, name: "pdt_every_segment", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsVideoConfiguration {
@@ -11539,6 +11595,11 @@ export class CmafAudioConfiguration extends Message<CmafAudioConfiguration> {
    */
   name?: OptionalString;
 
+  /**
+   * @generated from field: bool pdt_every_segment = 13;
+   */
+  pdtEverySegment = false;
+
   constructor(data?: PartialMessage<CmafAudioConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -11557,6 +11618,7 @@ export class CmafAudioConfiguration extends Message<CmafAudioConfiguration> {
     { no: 10, name: "mpd_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 11, name: "bitrate", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
     { no: 12, name: "name", kind: "message", T: OptionalString },
+    { no: 13, name: "pdt_every_segment", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafAudioConfiguration {
@@ -11688,6 +11750,11 @@ export class HlsTsAudioConfiguration extends Message<HlsTsAudioConfiguration> {
    */
   name?: OptionalString;
 
+  /**
+   * @generated from field: bool pdt_every_segment = 10;
+   */
+  pdtEverySegment = false;
+
   constructor(data?: PartialMessage<HlsTsAudioConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -11704,6 +11771,7 @@ export class HlsTsAudioConfiguration extends Message<HlsTsAudioConfiguration> {
     { no: 7, name: "mpd_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 8, name: "bitrate", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
     { no: 9, name: "name", kind: "message", T: OptionalString },
+    { no: 10, name: "pdt_every_segment", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsAudioConfiguration {
@@ -11811,6 +11879,11 @@ export class CmafWebVttConfiguration extends Message<CmafWebVttConfiguration> {
    */
   name?: OptionalString;
 
+  /**
+   * @generated from field: bool pdt_every_segment = 10;
+   */
+  pdtEverySegment = false;
+
   constructor(data?: PartialMessage<CmafWebVttConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -11823,6 +11896,7 @@ export class CmafWebVttConfiguration extends Message<CmafWebVttConfiguration> {
     { no: 2, name: "segment_duration_seconds", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
     { no: 5, name: "destinations", kind: "message", T: CMAFDestination, repeated: true },
     { no: 9, name: "name", kind: "message", T: OptionalString },
+    { no: 10, name: "pdt_every_segment", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CmafWebVttConfiguration {
@@ -12860,6 +12934,11 @@ export class HlsTsCombinedPushConfiguration extends Message<HlsTsCombinedPushCon
    */
   name?: OptionalString;
 
+  /**
+   * @generated from field: bool pdt_every_segment = 10;
+   */
+  pdtEverySegment = false;
+
   constructor(data?: PartialMessage<HlsTsCombinedPushConfiguration>) {
     super();
     proto3.util.initPartial(data, this);
@@ -12875,6 +12954,7 @@ export class HlsTsCombinedPushConfiguration extends Message<HlsTsCombinedPushCon
     { no: 6, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
     { no: 7, name: "m3u_additions", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 9, name: "name", kind: "message", T: OptionalString },
+    { no: 10, name: "pdt_every_segment", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HlsTsCombinedPushConfiguration {
@@ -14103,6 +14183,535 @@ proto3.util.setEnumType(WhepOutputEvent_State, "norsk.api.media.WhepOutputEvent.
   { no: 1, name: "WHEP_OUTPUT_STATUS_READY" },
 ]);
 
+/**
+ * @generated from message norsk.api.media.SipConfiguration
+ */
+export class SipConfiguration extends Message<SipConfiguration> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId id = 1;
+   */
+  id?: MediaNodeId;
+
+  /**
+   * @generated from field: norsk.api.media.StreamStatisticsSampling stats_sampling = 2;
+   */
+  statsSampling?: StreamStatisticsSampling;
+
+  /**
+   * @generated from field: norsk.api.media.SipAccount account = 3;
+   */
+  account?: SipAccount;
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt buffer_delay_ms = 4;
+   */
+  bufferDelayMs?: OptionalInt;
+
+  /**
+   * @generated from field: norsk.api.media.SipCall call = 5;
+   */
+  call?: SipCall;
+
+  /**
+   * @generated from field: string source_name = 6;
+   */
+  sourceName = "";
+
+  constructor(data?: PartialMessage<SipConfiguration>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SipConfiguration";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "stats_sampling", kind: "message", T: StreamStatisticsSampling },
+    { no: 3, name: "account", kind: "message", T: SipAccount },
+    { no: 4, name: "buffer_delay_ms", kind: "message", T: OptionalInt },
+    { no: 5, name: "call", kind: "message", T: SipCall },
+    { no: 6, name: "source_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SipConfiguration {
+    return new SipConfiguration().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SipConfiguration {
+    return new SipConfiguration().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SipConfiguration {
+    return new SipConfiguration().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SipConfiguration | PlainMessage<SipConfiguration> | undefined, b: SipConfiguration | PlainMessage<SipConfiguration> | undefined): boolean {
+    return proto3.util.equals(SipConfiguration, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SipAccount
+ */
+export class SipAccount extends Message<SipAccount> {
+  /**
+   * @generated from field: string id = 1;
+   */
+  id = "";
+
+  /**
+   * @generated from field: norsk.api.media.SipCredentials credentials = 2;
+   */
+  credentials?: SipCredentials;
+
+  /**
+   * @generated from field: string reg_uri = 3;
+   */
+  regUri = "";
+
+  constructor(data?: PartialMessage<SipAccount>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SipAccount";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "credentials", kind: "message", T: SipCredentials },
+    { no: 3, name: "reg_uri", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SipAccount {
+    return new SipAccount().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SipAccount {
+    return new SipAccount().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SipAccount {
+    return new SipAccount().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SipAccount | PlainMessage<SipAccount> | undefined, b: SipAccount | PlainMessage<SipAccount> | undefined): boolean {
+    return proto3.util.equals(SipAccount, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SipCredentials
+ */
+export class SipCredentials extends Message<SipCredentials> {
+  /**
+   * @generated from field: string realm = 1;
+   */
+  realm = "";
+
+  /**
+   * @generated from field: string username = 2;
+   */
+  username = "";
+
+  /**
+   * @generated from field: norsk.api.media.SipCredentialData credential = 3;
+   */
+  credential?: SipCredentialData;
+
+  constructor(data?: PartialMessage<SipCredentials>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SipCredentials";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "realm", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "username", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "credential", kind: "message", T: SipCredentialData },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SipCredentials {
+    return new SipCredentials().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SipCredentials {
+    return new SipCredentials().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SipCredentials {
+    return new SipCredentials().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SipCredentials | PlainMessage<SipCredentials> | undefined, b: SipCredentials | PlainMessage<SipCredentials> | undefined): boolean {
+    return proto3.util.equals(SipCredentials, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SipCredentialData
+ */
+export class SipCredentialData extends Message<SipCredentialData> {
+  /**
+   * @generated from oneof norsk.api.media.SipCredentialData.message
+   */
+  message: {
+    /**
+     * @generated from field: string plain = 1;
+     */
+    value: string;
+    case: "plain";
+  } | {
+    /**
+     * @generated from field: string digest = 2;
+     */
+    value: string;
+    case: "digest";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<SipCredentialData>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SipCredentialData";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "plain", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "message" },
+    { no: 2, name: "digest", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SipCredentialData {
+    return new SipCredentialData().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SipCredentialData {
+    return new SipCredentialData().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SipCredentialData {
+    return new SipCredentialData().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SipCredentialData | PlainMessage<SipCredentialData> | undefined, b: SipCredentialData | PlainMessage<SipCredentialData> | undefined): boolean {
+    return proto3.util.equals(SipCredentialData, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SipCall
+ */
+export class SipCall extends Message<SipCall> {
+  /**
+   * @generated from field: string address = 1;
+   */
+  address = "";
+
+  constructor(data?: PartialMessage<SipCall>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SipCall";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SipCall {
+    return new SipCall().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SipCall {
+    return new SipCall().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SipCall {
+    return new SipCall().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SipCall | PlainMessage<SipCall> | undefined, b: SipCall | PlainMessage<SipCall> | undefined): boolean {
+    return proto3.util.equals(SipCall, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SipMessage
+ */
+export class SipMessage extends Message<SipMessage> {
+  /**
+   * @generated from oneof norsk.api.media.SipMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.Subscription subscription = 1;
+     */
+    value: Subscription;
+    case: "subscription";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.SipConfiguration configuration = 2;
+     */
+    value: SipConfiguration;
+    case: "configuration";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<SipMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SipMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "subscription", kind: "message", T: Subscription, oneof: "message" },
+    { no: 2, name: "configuration", kind: "message", T: SipConfiguration, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SipMessage {
+    return new SipMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SipMessage {
+    return new SipMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SipMessage {
+    return new SipMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SipMessage | PlainMessage<SipMessage> | undefined, b: SipMessage | PlainMessage<SipMessage> | undefined): boolean {
+    return proto3.util.equals(SipMessage, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SipStreamStatistics
+ */
+export class SipStreamStatistics extends Message<SipStreamStatistics> {
+  /**
+   * @generated from field: uint32 num_bytes = 1;
+   */
+  numBytes = 0;
+
+  /**
+   * @generated from field: uint32 num_packets = 2;
+   */
+  numPackets = 0;
+
+  constructor(data?: PartialMessage<SipStreamStatistics>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SipStreamStatistics";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "num_bytes", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "num_packets", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SipStreamStatistics {
+    return new SipStreamStatistics().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SipStreamStatistics {
+    return new SipStreamStatistics().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SipStreamStatistics {
+    return new SipStreamStatistics().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SipStreamStatistics | PlainMessage<SipStreamStatistics> | undefined, b: SipStreamStatistics | PlainMessage<SipStreamStatistics> | undefined): boolean {
+    return proto3.util.equals(SipStreamStatistics, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SipConnectionStatistics
+ */
+export class SipConnectionStatistics extends Message<SipConnectionStatistics> {
+  /**
+   * @generated from field: norsk.api.media.SipStreamStatistics send = 1;
+   */
+  send?: SipStreamStatistics;
+
+  /**
+   * @generated from field: norsk.api.media.SipStreamStatistics recv = 2;
+   */
+  recv?: SipStreamStatistics;
+
+  constructor(data?: PartialMessage<SipConnectionStatistics>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SipConnectionStatistics";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "send", kind: "message", T: SipStreamStatistics },
+    { no: 2, name: "recv", kind: "message", T: SipStreamStatistics },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SipConnectionStatistics {
+    return new SipConnectionStatistics().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SipConnectionStatistics {
+    return new SipConnectionStatistics().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SipConnectionStatistics {
+    return new SipConnectionStatistics().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SipConnectionStatistics | PlainMessage<SipConnectionStatistics> | undefined, b: SipConnectionStatistics | PlainMessage<SipConnectionStatistics> | undefined): boolean {
+    return proto3.util.equals(SipConnectionStatistics, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SipEvent
+ */
+export class SipEvent extends Message<SipEvent> {
+  /**
+   * @generated from oneof norsk.api.media.SipEvent.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.media.MediaNodeId node_id = 1;
+     */
+    value: MediaNodeId;
+    case: "nodeId";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.SubscriptionResponse subscription_response = 2;
+     */
+    value: SubscriptionResponse;
+    case: "subscriptionResponse";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context inbound_context = 3;
+     */
+    value: Context;
+    case: "inboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.Context outbound_context = 4;
+     */
+    value: Context;
+    case: "outboundContext";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.MultiStreamStatistics stream_statistics = 5;
+     */
+    value: MultiStreamStatistics;
+    case: "streamStatistics";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.SipEvent.Status status = 6;
+     */
+    value: SipEvent_Status;
+    case: "status";
+  } | {
+    /**
+     * @generated from field: norsk.api.media.SipConnectionStatistics connection_statistics = 7;
+     */
+    value: SipConnectionStatistics;
+    case: "connectionStatistics";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<SipEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SipEvent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "node_id", kind: "message", T: MediaNodeId, oneof: "message" },
+    { no: 2, name: "subscription_response", kind: "message", T: SubscriptionResponse, oneof: "message" },
+    { no: 3, name: "inbound_context", kind: "message", T: Context, oneof: "message" },
+    { no: 4, name: "outbound_context", kind: "message", T: Context, oneof: "message" },
+    { no: 5, name: "stream_statistics", kind: "message", T: MultiStreamStatistics, oneof: "message" },
+    { no: 6, name: "status", kind: "enum", T: proto3.getEnumType(SipEvent_Status), oneof: "message" },
+    { no: 7, name: "connection_statistics", kind: "message", T: SipConnectionStatistics, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SipEvent {
+    return new SipEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SipEvent {
+    return new SipEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SipEvent {
+    return new SipEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SipEvent | PlainMessage<SipEvent> | undefined, b: SipEvent | PlainMessage<SipEvent> | undefined): boolean {
+    return proto3.util.equals(SipEvent, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.media.SipEvent.Status
+ */
+export enum SipEvent_Status {
+  /**
+   * @generated from enum value: SIP_STATE_UNKNOWN = 0;
+   */
+  SIP_STATE_UNKNOWN = 0,
+
+  /**
+   * @generated from enum value: SIP_STATE_INITIAL = 1;
+   */
+  SIP_STATE_INITIAL = 1,
+
+  /**
+   * @generated from enum value: SIP_STATE_CALLING = 2;
+   */
+  SIP_STATE_CALLING = 2,
+
+  /**
+   * @generated from enum value: SIP_STATE_INCOMING = 3;
+   */
+  SIP_STATE_INCOMING = 3,
+
+  /**
+   * @generated from enum value: SIP_STATE_EARLY = 4;
+   */
+  SIP_STATE_EARLY = 4,
+
+  /**
+   * @generated from enum value: SIP_STATE_CONNECTING = 5;
+   */
+  SIP_STATE_CONNECTING = 5,
+
+  /**
+   * @generated from enum value: SIP_STATE_CONFIRMED = 6;
+   */
+  SIP_STATE_CONFIRMED = 6,
+
+  /**
+   * @generated from enum value: SIP_STATE_DISCONNECTED = 7;
+   */
+  SIP_STATE_DISCONNECTED = 7,
+}
+// Retrieve enum metadata with: proto3.getEnumType(SipEvent_Status)
+proto3.util.setEnumType(SipEvent_Status, "norsk.api.media.SipEvent.Status", [
+  { no: 0, name: "SIP_STATE_UNKNOWN" },
+  { no: 1, name: "SIP_STATE_INITIAL" },
+  { no: 2, name: "SIP_STATE_CALLING" },
+  { no: 3, name: "SIP_STATE_INCOMING" },
+  { no: 4, name: "SIP_STATE_EARLY" },
+  { no: 5, name: "SIP_STATE_CONNECTING" },
+  { no: 6, name: "SIP_STATE_CONFIRMED" },
+  { no: 7, name: "SIP_STATE_DISCONNECTED" },
+]);
+
 /**
  * @generated from message norsk.api.media.RtmpOutputConfiguration
  */
@@ -26658,9 +27267,9 @@ export class MediaStoreAssetFileWithHash extends Message<MediaStoreAssetFileWith
   hash = "";
 
   /**
-   * @generated from field: bool error_on_hash_mismatch = 3;
+   * @generated from field: bool import_if_needed = 3;
    */
-  errorOnHashMismatch = false;
+  importIfNeeded = false;
 
   constructor(data?: PartialMessage<MediaStoreAssetFileWithHash>) {
     super();
@@ -26672,7 +27281,7 @@ export class MediaStoreAssetFileWithHash extends Message<MediaStoreAssetFileWith
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "file", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 2, name: "hash", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: "error_on_hash_mismatch", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 3, name: "import_if_needed", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreAssetFileWithHash {
@@ -26704,9 +27313,9 @@ export class MediaStoreAssetFile extends Message<MediaStoreAssetFile> {
   file = "";
 
   /**
-   * @generated from field: bool error_on_hash_mismatch = 2;
+   * @generated from field: bool import_if_needed = 2;
    */
-  errorOnHashMismatch = false;
+  importIfNeeded = false;
 
   constructor(data?: PartialMessage<MediaStoreAssetFile>) {
     super();
@@ -26717,7 +27326,7 @@ export class MediaStoreAssetFile extends Message<MediaStoreAssetFile> {
   static readonly typeName = "norsk.api.media.MediaStoreAssetFile";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "file", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 2, name: "error_on_hash_mismatch", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 2, name: "import_if_needed", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MediaStoreAssetFile {