@ondewo/sip-client-nodejs 3.1.0 → 5.0.0

package/api/ondewo/sip/sip_grpc_pb.js

@@ -32,164 +32,173 @@ function deserialize_google_protobuf_Empty(buffer_arg) {
   return google_protobuf_empty_pb.Empty.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
-function serialize_ondewo_sip_EndCallRequest(arg) {
-  if (!(arg instanceof ondewo_sip_sip_pb.EndCallRequest)) {
-    throw new Error('Expected argument of type ondewo.sip.EndCallRequest');
+function serialize_ondewo_sip_SipEndCallRequest(arg) {
+  if (!(arg instanceof ondewo_sip_sip_pb.SipEndCallRequest)) {
+    throw new Error('Expected argument of type ondewo.sip.SipEndCallRequest');
   }
   return Buffer.from(arg.serializeBinary());
 }
 
-function deserialize_ondewo_sip_EndCallRequest(buffer_arg) {
-  return ondewo_sip_sip_pb.EndCallRequest.deserializeBinary(new Uint8Array(buffer_arg));
+function deserialize_ondewo_sip_SipEndCallRequest(buffer_arg) {
+  return ondewo_sip_sip_pb.SipEndCallRequest.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
-function serialize_ondewo_sip_PlayWavFilesRequest(arg) {
-  if (!(arg instanceof ondewo_sip_sip_pb.PlayWavFilesRequest)) {
-    throw new Error('Expected argument of type ondewo.sip.PlayWavFilesRequest');
+function serialize_ondewo_sip_SipPlayWavFilesRequest(arg) {
+  if (!(arg instanceof ondewo_sip_sip_pb.SipPlayWavFilesRequest)) {
+    throw new Error('Expected argument of type ondewo.sip.SipPlayWavFilesRequest');
   }
   return Buffer.from(arg.serializeBinary());
 }
 
-function deserialize_ondewo_sip_PlayWavFilesRequest(buffer_arg) {
-  return ondewo_sip_sip_pb.PlayWavFilesRequest.deserializeBinary(new Uint8Array(buffer_arg));
+function deserialize_ondewo_sip_SipPlayWavFilesRequest(buffer_arg) {
+  return ondewo_sip_sip_pb.SipPlayWavFilesRequest.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
-function serialize_ondewo_sip_RegisterAccountRequest(arg) {
-  if (!(arg instanceof ondewo_sip_sip_pb.RegisterAccountRequest)) {
-    throw new Error('Expected argument of type ondewo.sip.RegisterAccountRequest');
+function serialize_ondewo_sip_SipRegisterAccountRequest(arg) {
+  if (!(arg instanceof ondewo_sip_sip_pb.SipRegisterAccountRequest)) {
+    throw new Error('Expected argument of type ondewo.sip.SipRegisterAccountRequest');
   }
   return Buffer.from(arg.serializeBinary());
 }
 
-function deserialize_ondewo_sip_RegisterAccountRequest(buffer_arg) {
-  return ondewo_sip_sip_pb.RegisterAccountRequest.deserializeBinary(new Uint8Array(buffer_arg));
+function deserialize_ondewo_sip_SipRegisterAccountRequest(buffer_arg) {
+  return ondewo_sip_sip_pb.SipRegisterAccountRequest.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
-function serialize_ondewo_sip_SipStatus(arg) {
-  if (!(arg instanceof ondewo_sip_sip_pb.SipStatus)) {
-    throw new Error('Expected argument of type ondewo.sip.SipStatus');
+function serialize_ondewo_sip_SipStartCallRequest(arg) {
+  if (!(arg instanceof ondewo_sip_sip_pb.SipStartCallRequest)) {
+    throw new Error('Expected argument of type ondewo.sip.SipStartCallRequest');
   }
   return Buffer.from(arg.serializeBinary());
 }
 
-function deserialize_ondewo_sip_SipStatus(buffer_arg) {
-  return ondewo_sip_sip_pb.SipStatus.deserializeBinary(new Uint8Array(buffer_arg));
+function deserialize_ondewo_sip_SipStartCallRequest(buffer_arg) {
+  return ondewo_sip_sip_pb.SipStartCallRequest.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
-function serialize_ondewo_sip_SipStatusHistoryResponse(arg) {
-  if (!(arg instanceof ondewo_sip_sip_pb.SipStatusHistoryResponse)) {
-    throw new Error('Expected argument of type ondewo.sip.SipStatusHistoryResponse');
+function serialize_ondewo_sip_SipStartSessionRequest(arg) {
+  if (!(arg instanceof ondewo_sip_sip_pb.SipStartSessionRequest)) {
+    throw new Error('Expected argument of type ondewo.sip.SipStartSessionRequest');
   }
   return Buffer.from(arg.serializeBinary());
 }
 
-function deserialize_ondewo_sip_SipStatusHistoryResponse(buffer_arg) {
-  return ondewo_sip_sip_pb.SipStatusHistoryResponse.deserializeBinary(new Uint8Array(buffer_arg));
+function deserialize_ondewo_sip_SipStartSessionRequest(buffer_arg) {
+  return ondewo_sip_sip_pb.SipStartSessionRequest.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
-function serialize_ondewo_sip_StartCallRequest(arg) {
-  if (!(arg instanceof ondewo_sip_sip_pb.StartCallRequest)) {
-    throw new Error('Expected argument of type ondewo.sip.StartCallRequest');
+function serialize_ondewo_sip_SipStatus(arg) {
+  if (!(arg instanceof ondewo_sip_sip_pb.SipStatus)) {
+    throw new Error('Expected argument of type ondewo.sip.SipStatus');
   }
   return Buffer.from(arg.serializeBinary());
 }
 
-function deserialize_ondewo_sip_StartCallRequest(buffer_arg) {
-  return ondewo_sip_sip_pb.StartCallRequest.deserializeBinary(new Uint8Array(buffer_arg));
+function deserialize_ondewo_sip_SipStatus(buffer_arg) {
+  return ondewo_sip_sip_pb.SipStatus.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
-function serialize_ondewo_sip_StartSessionRequest(arg) {
-  if (!(arg instanceof ondewo_sip_sip_pb.StartSessionRequest)) {
-    throw new Error('Expected argument of type ondewo.sip.StartSessionRequest');
+function serialize_ondewo_sip_SipStatusHistoryResponse(arg) {
+  if (!(arg instanceof ondewo_sip_sip_pb.SipStatusHistoryResponse)) {
+    throw new Error('Expected argument of type ondewo.sip.SipStatusHistoryResponse');
   }
   return Buffer.from(arg.serializeBinary());
 }
 
-function deserialize_ondewo_sip_StartSessionRequest(buffer_arg) {
-  return ondewo_sip_sip_pb.StartSessionRequest.deserializeBinary(new Uint8Array(buffer_arg));
+function deserialize_ondewo_sip_SipStatusHistoryResponse(buffer_arg) {
+  return ondewo_sip_sip_pb.SipStatusHistoryResponse.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
-function serialize_ondewo_sip_TransferCallRequest(arg) {
-  if (!(arg instanceof ondewo_sip_sip_pb.TransferCallRequest)) {
-    throw new Error('Expected argument of type ondewo.sip.TransferCallRequest');
+function serialize_ondewo_sip_SipTransferCallRequest(arg) {
+  if (!(arg instanceof ondewo_sip_sip_pb.SipTransferCallRequest)) {
+    throw new Error('Expected argument of type ondewo.sip.SipTransferCallRequest');
   }
   return Buffer.from(arg.serializeBinary());
 }
 
-function deserialize_ondewo_sip_TransferCallRequest(buffer_arg) {
-  return ondewo_sip_sip_pb.TransferCallRequest.deserializeBinary(new Uint8Array(buffer_arg));
+function deserialize_ondewo_sip_SipTransferCallRequest(buffer_arg) {
+  return ondewo_sip_sip_pb.SipTransferCallRequest.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
 
+// ONDEWO-SIP API available at <a href="https://github.com/ondewo/ondewo-sip-api>">GitHub</a>
 var SipService = exports.SipService = {
-  startSession: {
-    path: '/ondewo.sip.Sip/StartSession',
+  // Starts a new SIP session for an account registered at a SIP server. <code>RegisterAccount</code> need to be called before.
+sipStartSession: {
+    path: '/ondewo.sip.Sip/SipStartSession',
     requestStream: false,
     responseStream: false,
-    requestType: ondewo_sip_sip_pb.StartSessionRequest,
-    responseType: google_protobuf_empty_pb.Empty,
-    requestSerialize: serialize_ondewo_sip_StartSessionRequest,
-    requestDeserialize: deserialize_ondewo_sip_StartSessionRequest,
-    responseSerialize: serialize_google_protobuf_Empty,
-    responseDeserialize: deserialize_google_protobuf_Empty,
+    requestType: ondewo_sip_sip_pb.SipStartSessionRequest,
+    responseType: ondewo_sip_sip_pb.SipStatus,
+    requestSerialize: serialize_ondewo_sip_SipStartSessionRequest,
+    requestDeserialize: deserialize_ondewo_sip_SipStartSessionRequest,
+    responseSerialize: serialize_ondewo_sip_SipStatus,
+    responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
-  endSession: {
-    path: '/ondewo.sip.Sip/EndSession',
+  // Ends a SIP session for an account registered at a SIP server
+sipEndSession: {
+    path: '/ondewo.sip.Sip/SipEndSession',
     requestStream: false,
     responseStream: false,
     requestType: google_protobuf_empty_pb.Empty,
-    responseType: google_protobuf_empty_pb.Empty,
+    responseType: ondewo_sip_sip_pb.SipStatus,
     requestSerialize: serialize_google_protobuf_Empty,
     requestDeserialize: deserialize_google_protobuf_Empty,
-    responseSerialize: serialize_google_protobuf_Empty,
-    responseDeserialize: deserialize_google_protobuf_Empty,
+    responseSerialize: serialize_ondewo_sip_SipStatus,
+    responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
-  startCall: {
-    path: '/ondewo.sip.Sip/StartCall',
+  // Starts a call in an active SIP session for an account registered at a SIP server
+sipStartCall: {
+    path: '/ondewo.sip.Sip/SipStartCall',
     requestStream: false,
     responseStream: false,
-    requestType: ondewo_sip_sip_pb.StartCallRequest,
-    responseType: google_protobuf_empty_pb.Empty,
-    requestSerialize: serialize_ondewo_sip_StartCallRequest,
-    requestDeserialize: deserialize_ondewo_sip_StartCallRequest,
-    responseSerialize: serialize_google_protobuf_Empty,
-    responseDeserialize: deserialize_google_protobuf_Empty,
+    requestType: ondewo_sip_sip_pb.SipStartCallRequest,
+    responseType: ondewo_sip_sip_pb.SipStatus,
+    requestSerialize: serialize_ondewo_sip_SipStartCallRequest,
+    requestDeserialize: deserialize_ondewo_sip_SipStartCallRequest,
+    responseSerialize: serialize_ondewo_sip_SipStatus,
+    responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
-  endCall: {
-    path: '/ondewo.sip.Sip/EndCall',
+  // Ends a call in an active SIP session for an account registered at a SIP server
+sipEndCall: {
+    path: '/ondewo.sip.Sip/SipEndCall',
     requestStream: false,
     responseStream: false,
-    requestType: ondewo_sip_sip_pb.EndCallRequest,
-    responseType: google_protobuf_empty_pb.Empty,
-    requestSerialize: serialize_ondewo_sip_EndCallRequest,
-    requestDeserialize: deserialize_ondewo_sip_EndCallRequest,
-    responseSerialize: serialize_google_protobuf_Empty,
-    responseDeserialize: deserialize_google_protobuf_Empty,
+    requestType: ondewo_sip_sip_pb.SipEndCallRequest,
+    responseType: ondewo_sip_sip_pb.SipStatus,
+    requestSerialize: serialize_ondewo_sip_SipEndCallRequest,
+    requestDeserialize: deserialize_ondewo_sip_SipEndCallRequest,
+    responseSerialize: serialize_ondewo_sip_SipStatus,
+    responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
-  transferCall: {
-    path: '/ondewo.sip.Sip/TransferCall',
+  // Transfers a call in an active SIP session for an account registered at a SIP server to
+// another SIP account or phone number specified by <code>transfer_id</code>
+sipTransferCall: {
+    path: '/ondewo.sip.Sip/SipTransferCall',
     requestStream: false,
     responseStream: false,
-    requestType: ondewo_sip_sip_pb.TransferCallRequest,
-    responseType: google_protobuf_empty_pb.Empty,
-    requestSerialize: serialize_ondewo_sip_TransferCallRequest,
-    requestDeserialize: deserialize_ondewo_sip_TransferCallRequest,
-    responseSerialize: serialize_google_protobuf_Empty,
-    responseDeserialize: deserialize_google_protobuf_Empty,
+    requestType: ondewo_sip_sip_pb.SipTransferCallRequest,
+    responseType: ondewo_sip_sip_pb.SipStatus,
+    requestSerialize: serialize_ondewo_sip_SipTransferCallRequest,
+    requestDeserialize: deserialize_ondewo_sip_SipTransferCallRequest,
+    responseSerialize: serialize_ondewo_sip_SipStatus,
+    responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
-  registerAccount: {
-    path: '/ondewo.sip.Sip/RegisterAccount',
+  // Registers s SIP account at a SIP server
+sipRegisterAccount: {
+    path: '/ondewo.sip.Sip/SipRegisterAccount',
     requestStream: false,
     responseStream: false,
-    requestType: ondewo_sip_sip_pb.RegisterAccountRequest,
-    responseType: google_protobuf_empty_pb.Empty,
-    requestSerialize: serialize_ondewo_sip_RegisterAccountRequest,
-    requestDeserialize: deserialize_ondewo_sip_RegisterAccountRequest,
-    responseSerialize: serialize_google_protobuf_Empty,
-    responseDeserialize: deserialize_google_protobuf_Empty,
+    requestType: ondewo_sip_sip_pb.SipRegisterAccountRequest,
+    responseType: ondewo_sip_sip_pb.SipStatus,
+    requestSerialize: serialize_ondewo_sip_SipRegisterAccountRequest,
+    requestDeserialize: deserialize_ondewo_sip_SipRegisterAccountRequest,
+    responseSerialize: serialize_ondewo_sip_SipStatus,
+    responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
-  getSipStatus: {
-    path: '/ondewo.sip.Sip/GetSipStatus',
+  // Gets the current SIP status
+sipGetSipStatus: {
+    path: '/ondewo.sip.Sip/SipGetSipStatus',
     requestStream: false,
     responseStream: false,
     requestType: google_protobuf_empty_pb.Empty,
@@ -199,8 +208,9 @@ var SipService = exports.SipService = {
     responseSerialize: serialize_ondewo_sip_SipStatus,
     responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
-  getSipStatusHistory: {
-    path: '/ondewo.sip.Sip/GetSipStatusHistory',
+  // Gets the history of SIP status
+sipGetSipStatusHistory: {
+    path: '/ondewo.sip.Sip/SipGetSipStatusHistory',
     requestStream: false,
     responseStream: false,
     requestType: google_protobuf_empty_pb.Empty,
@@ -210,39 +220,43 @@ var SipService = exports.SipService = {
     responseSerialize: serialize_ondewo_sip_SipStatusHistoryResponse,
     responseDeserialize: deserialize_ondewo_sip_SipStatusHistoryResponse,
   },
-  playWavFiles: {
-    path: '/ondewo.sip.Sip/PlayWavFiles',
+  // Plays wav files during an ongoing call of an active SIP session
+sipPlayWavFiles: {
+    path: '/ondewo.sip.Sip/SipPlayWavFiles',
     requestStream: false,
     responseStream: false,
-    requestType: ondewo_sip_sip_pb.PlayWavFilesRequest,
-    responseType: google_protobuf_empty_pb.Empty,
-    requestSerialize: serialize_ondewo_sip_PlayWavFilesRequest,
-    requestDeserialize: deserialize_ondewo_sip_PlayWavFilesRequest,
-    responseSerialize: serialize_google_protobuf_Empty,
-    responseDeserialize: deserialize_google_protobuf_Empty,
+    requestType: ondewo_sip_sip_pb.SipPlayWavFilesRequest,
+    responseType: ondewo_sip_sip_pb.SipStatus,
+    requestSerialize: serialize_ondewo_sip_SipPlayWavFilesRequest,
+    requestDeserialize: deserialize_ondewo_sip_SipPlayWavFilesRequest,
+    responseSerialize: serialize_ondewo_sip_SipStatus,
+    responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
-  mute: {
-    path: '/ondewo.sip.Sip/Mute',
+  // Mutes the microphone in an ongoing call of an active SIP session
+sipMute: {
+    path: '/ondewo.sip.Sip/SipMute',
     requestStream: false,
     responseStream: false,
     requestType: google_protobuf_empty_pb.Empty,
-    responseType: google_protobuf_empty_pb.Empty,
+    responseType: ondewo_sip_sip_pb.SipStatus,
     requestSerialize: serialize_google_protobuf_Empty,
     requestDeserialize: deserialize_google_protobuf_Empty,
-    responseSerialize: serialize_google_protobuf_Empty,
-    responseDeserialize: deserialize_google_protobuf_Empty,
+    responseSerialize: serialize_ondewo_sip_SipStatus,
+    responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
-  unMute: {
-    path: '/ondewo.sip.Sip/UnMute',
+  // Un-mutes the microphone in an ongoing call of an active SIP session
+sipUnMute: {
+    path: '/ondewo.sip.Sip/SipUnMute',
     requestStream: false,
     responseStream: false,
     requestType: google_protobuf_empty_pb.Empty,
-    responseType: google_protobuf_empty_pb.Empty,
+    responseType: ondewo_sip_sip_pb.SipStatus,
     requestSerialize: serialize_google_protobuf_Empty,
     requestDeserialize: deserialize_google_protobuf_Empty,
-    responseSerialize: serialize_google_protobuf_Empty,
-    responseDeserialize: deserialize_google_protobuf_Empty,
+    responseSerialize: serialize_ondewo_sip_SipStatus,
+    responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
 };
 
 exports.SipClient = grpc.makeGenericClientConstructor(SipService);
+// SIP LifeCycle is explained at <a href="https://thanhloi2603.wordpress.com/2017/06/10/sip-lifecycle-overview/">here</a>

package/api/ondewo/sip/sip_pb.d.ts

@@ -8,44 +8,44 @@ import * as jspb from "google-protobuf";
 import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb";
 import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb";
 
-export class EndCallRequest extends jspb.Message { 
+export class SipEndCallRequest extends jspb.Message { 
     getHardHangup(): boolean;
-    setHardHangup(value: boolean): EndCallRequest;
+    setHardHangup(value: boolean): SipEndCallRequest;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): EndCallRequest.AsObject;
-    static toObject(includeInstance: boolean, msg: EndCallRequest): EndCallRequest.AsObject;
+    toObject(includeInstance?: boolean): SipEndCallRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: SipEndCallRequest): SipEndCallRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: EndCallRequest, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): EndCallRequest;
-    static deserializeBinaryFromReader(message: EndCallRequest, reader: jspb.BinaryReader): EndCallRequest;
+    static serializeBinaryToWriter(message: SipEndCallRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SipEndCallRequest;
+    static deserializeBinaryFromReader(message: SipEndCallRequest, reader: jspb.BinaryReader): SipEndCallRequest;
 }
 
-export namespace EndCallRequest {
+export namespace SipEndCallRequest {
     export type AsObject = {
         hardHangup: boolean,
     }
 }
 
-export class StartCallRequest extends jspb.Message { 
+export class SipStartCallRequest extends jspb.Message { 
     getCalleeId(): string;
-    setCalleeId(value: string): StartCallRequest;
+    setCalleeId(value: string): SipStartCallRequest;
 
     getHeadersMap(): jspb.Map<string, string>;
     clearHeadersMap(): void;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): StartCallRequest.AsObject;
-    static toObject(includeInstance: boolean, msg: StartCallRequest): StartCallRequest.AsObject;
+    toObject(includeInstance?: boolean): SipStartCallRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: SipStartCallRequest): SipStartCallRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: StartCallRequest, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): StartCallRequest;
-    static deserializeBinaryFromReader(message: StartCallRequest, reader: jspb.BinaryReader): StartCallRequest;
+    static serializeBinaryToWriter(message: SipStartCallRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SipStartCallRequest;
+    static deserializeBinaryFromReader(message: SipStartCallRequest, reader: jspb.BinaryReader): SipStartCallRequest;
 }
 
-export namespace StartCallRequest {
+export namespace SipStartCallRequest {
     export type AsObject = {
         calleeId: string,
 
@@ -53,70 +53,76 @@ export namespace StartCallRequest {
     }
 }
 
-export class RegisterAccountRequest extends jspb.Message { 
+export class SipRegisterAccountRequest extends jspb.Message { 
     getAccountName(): string;
-    setAccountName(value: string): RegisterAccountRequest;
+    setAccountName(value: string): SipRegisterAccountRequest;
     getPassword(): string;
-    setPassword(value: string): RegisterAccountRequest;
+    setPassword(value: string): SipRegisterAccountRequest;
+    getAuthUsername(): string;
+    setAuthUsername(value: string): SipRegisterAccountRequest;
+    getOutboundProxy(): string;
+    setOutboundProxy(value: string): SipRegisterAccountRequest;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): RegisterAccountRequest.AsObject;
-    static toObject(includeInstance: boolean, msg: RegisterAccountRequest): RegisterAccountRequest.AsObject;
+    toObject(includeInstance?: boolean): SipRegisterAccountRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: SipRegisterAccountRequest): SipRegisterAccountRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: RegisterAccountRequest, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): RegisterAccountRequest;
-    static deserializeBinaryFromReader(message: RegisterAccountRequest, reader: jspb.BinaryReader): RegisterAccountRequest;
+    static serializeBinaryToWriter(message: SipRegisterAccountRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SipRegisterAccountRequest;
+    static deserializeBinaryFromReader(message: SipRegisterAccountRequest, reader: jspb.BinaryReader): SipRegisterAccountRequest;
 }
 
-export namespace RegisterAccountRequest {
+export namespace SipRegisterAccountRequest {
     export type AsObject = {
         accountName: string,
         password: string,
+        authUsername: string,
+        outboundProxy: string,
     }
 }
 
-export class StartSessionRequest extends jspb.Message { 
+export class SipStartSessionRequest extends jspb.Message { 
     getAccountName(): string;
-    setAccountName(value: string): StartSessionRequest;
+    setAccountName(value: string): SipStartSessionRequest;
     getAutoAnswerInterval(): number;
-    setAutoAnswerInterval(value: number): StartSessionRequest;
+    setAutoAnswerInterval(value: number): SipStartSessionRequest;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): StartSessionRequest.AsObject;
-    static toObject(includeInstance: boolean, msg: StartSessionRequest): StartSessionRequest.AsObject;
+    toObject(includeInstance?: boolean): SipStartSessionRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: SipStartSessionRequest): SipStartSessionRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: StartSessionRequest, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): StartSessionRequest;
-    static deserializeBinaryFromReader(message: StartSessionRequest, reader: jspb.BinaryReader): StartSessionRequest;
+    static serializeBinaryToWriter(message: SipStartSessionRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SipStartSessionRequest;
+    static deserializeBinaryFromReader(message: SipStartSessionRequest, reader: jspb.BinaryReader): SipStartSessionRequest;
 }
 
-export namespace StartSessionRequest {
+export namespace SipStartSessionRequest {
     export type AsObject = {
         accountName: string,
         autoAnswerInterval: number,
     }
 }
 
-export class TransferCallRequest extends jspb.Message { 
+export class SipTransferCallRequest extends jspb.Message { 
     getTransferId(): string;
-    setTransferId(value: string): TransferCallRequest;
+    setTransferId(value: string): SipTransferCallRequest;
 
     getHeadersMap(): jspb.Map<string, string>;
     clearHeadersMap(): void;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): TransferCallRequest.AsObject;
-    static toObject(includeInstance: boolean, msg: TransferCallRequest): TransferCallRequest.AsObject;
+    toObject(includeInstance?: boolean): SipTransferCallRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: SipTransferCallRequest): SipTransferCallRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: TransferCallRequest, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): TransferCallRequest;
-    static deserializeBinaryFromReader(message: TransferCallRequest, reader: jspb.BinaryReader): TransferCallRequest;
+    static serializeBinaryToWriter(message: SipTransferCallRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SipTransferCallRequest;
+    static deserializeBinaryFromReader(message: SipTransferCallRequest, reader: jspb.BinaryReader): SipTransferCallRequest;
 }
 
-export namespace TransferCallRequest {
+export namespace SipTransferCallRequest {
     export type AsObject = {
         transferId: string,
 
@@ -141,6 +147,12 @@ export class SipStatus extends jspb.Message {
 
     getHeadersMap(): jspb.Map<string, string>;
     clearHeadersMap(): void;
+    getDescription(): string;
+    setDescription(value: string): SipStatus;
+    getExceptionName(): string;
+    setExceptionName(value: string): SipStatus;
+    getExceptionTraceback(): string;
+    setExceptionTraceback(value: string): SipStatus;
 
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): SipStatus.AsObject;
@@ -161,6 +173,9 @@ export namespace SipStatus {
         transferCallId: string,
 
         headersMap: Array<[string, string]>,
+        description: string,
+        exceptionName: string,
+        exceptionTraceback: string,
     }
 
     export enum StatusType {
@@ -178,6 +193,14 @@ export namespace SipStatus {
     OUTGOING_CALL_FAILED = 11,
     INCOMING_CALL_FINISHED = 12,
     OUTGOING_CALL_FINISHED = 13,
+    SESSION_REGISTRATION_FAILED = 14,
+    SESSION_STARTED = 15,
+    SESSION_ENDED = 16,
+    TRANSFER_CALL_FAILED = 17,
+    MICROPHONE_MUTED = 18,
+    MICROPHONE_UNMUTED = 19,
+    MICROPHONE_WAV_FILES_PLAYED = 20,
+    NO_ONGOING_CALL = 21,
     }
 
 }
@@ -204,25 +227,25 @@ export namespace SipStatusHistoryResponse {
     }
 }
 
-export class PlayWavFilesRequest extends jspb.Message { 
+export class SipPlayWavFilesRequest extends jspb.Message { 
     clearWavFilesList(): void;
     getWavFilesList(): Array<Uint8Array | string>;
     getWavFilesList_asU8(): Array<Uint8Array>;
     getWavFilesList_asB64(): Array<string>;
-    setWavFilesList(value: Array<Uint8Array | string>): PlayWavFilesRequest;
+    setWavFilesList(value: Array<Uint8Array | string>): SipPlayWavFilesRequest;
     addWavFiles(value: Uint8Array | string, index?: number): Uint8Array | string;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): PlayWavFilesRequest.AsObject;
-    static toObject(includeInstance: boolean, msg: PlayWavFilesRequest): PlayWavFilesRequest.AsObject;
+    toObject(includeInstance?: boolean): SipPlayWavFilesRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: SipPlayWavFilesRequest): SipPlayWavFilesRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: PlayWavFilesRequest, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): PlayWavFilesRequest;
-    static deserializeBinaryFromReader(message: PlayWavFilesRequest, reader: jspb.BinaryReader): PlayWavFilesRequest;
+    static serializeBinaryToWriter(message: SipPlayWavFilesRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SipPlayWavFilesRequest;
+    static deserializeBinaryFromReader(message: SipPlayWavFilesRequest, reader: jspb.BinaryReader): SipPlayWavFilesRequest;
 }
 
-export namespace PlayWavFilesRequest {
+export namespace SipPlayWavFilesRequest {
     export type AsObject = {
         wavFilesList: Array<Uint8Array | string>,
     }