@norskvideo/norsk-api 1.0.368 → 1.0.372

package/lib/media_pb.ts

@@ -14183,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
  */

package/package.json

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