@ondewo/sip-client-nodejs 4.0.0 → 5.0.0

package/api/ondewo/sip/sip_grpc_pb.js

@@ -32,112 +32,112 @@ 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 = {
   // Starts a new SIP session for an account registered at a SIP server. <code>RegisterAccount</code> need to be called before.
-startSession: {
-    path: '/ondewo.sip.Sip/StartSession',
+sipStartSession: {
+    path: '/ondewo.sip.Sip/SipStartSession',
     requestStream: false,
     responseStream: false,
-    requestType: ondewo_sip_sip_pb.StartSessionRequest,
+    requestType: ondewo_sip_sip_pb.SipStartSessionRequest,
     responseType: ondewo_sip_sip_pb.SipStatus,
-    requestSerialize: serialize_ondewo_sip_StartSessionRequest,
-    requestDeserialize: deserialize_ondewo_sip_StartSessionRequest,
+    requestSerialize: serialize_ondewo_sip_SipStartSessionRequest,
+    requestDeserialize: deserialize_ondewo_sip_SipStartSessionRequest,
     responseSerialize: serialize_ondewo_sip_SipStatus,
     responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
   // Ends a SIP session for an account registered at a SIP server
-endSession: {
-    path: '/ondewo.sip.Sip/EndSession',
+sipEndSession: {
+    path: '/ondewo.sip.Sip/SipEndSession',
     requestStream: false,
     responseStream: false,
     requestType: google_protobuf_empty_pb.Empty,
@@ -148,57 +148,57 @@ endSession: {
     responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
   // Starts a call in an active SIP session for an account registered at a SIP server
-startCall: {
-    path: '/ondewo.sip.Sip/StartCall',
+sipStartCall: {
+    path: '/ondewo.sip.Sip/SipStartCall',
     requestStream: false,
     responseStream: false,
-    requestType: ondewo_sip_sip_pb.StartCallRequest,
+    requestType: ondewo_sip_sip_pb.SipStartCallRequest,
     responseType: ondewo_sip_sip_pb.SipStatus,
-    requestSerialize: serialize_ondewo_sip_StartCallRequest,
-    requestDeserialize: deserialize_ondewo_sip_StartCallRequest,
+    requestSerialize: serialize_ondewo_sip_SipStartCallRequest,
+    requestDeserialize: deserialize_ondewo_sip_SipStartCallRequest,
     responseSerialize: serialize_ondewo_sip_SipStatus,
     responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
   // Ends a call in an active SIP session for an account registered at a SIP server
-endCall: {
-    path: '/ondewo.sip.Sip/EndCall',
+sipEndCall: {
+    path: '/ondewo.sip.Sip/SipEndCall',
     requestStream: false,
     responseStream: false,
-    requestType: ondewo_sip_sip_pb.EndCallRequest,
+    requestType: ondewo_sip_sip_pb.SipEndCallRequest,
     responseType: ondewo_sip_sip_pb.SipStatus,
-    requestSerialize: serialize_ondewo_sip_EndCallRequest,
-    requestDeserialize: deserialize_ondewo_sip_EndCallRequest,
+    requestSerialize: serialize_ondewo_sip_SipEndCallRequest,
+    requestDeserialize: deserialize_ondewo_sip_SipEndCallRequest,
     responseSerialize: serialize_ondewo_sip_SipStatus,
     responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
   // 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>
-transferCall: {
-    path: '/ondewo.sip.Sip/TransferCall',
+sipTransferCall: {
+    path: '/ondewo.sip.Sip/SipTransferCall',
     requestStream: false,
     responseStream: false,
-    requestType: ondewo_sip_sip_pb.TransferCallRequest,
+    requestType: ondewo_sip_sip_pb.SipTransferCallRequest,
     responseType: ondewo_sip_sip_pb.SipStatus,
-    requestSerialize: serialize_ondewo_sip_TransferCallRequest,
-    requestDeserialize: deserialize_ondewo_sip_TransferCallRequest,
+    requestSerialize: serialize_ondewo_sip_SipTransferCallRequest,
+    requestDeserialize: deserialize_ondewo_sip_SipTransferCallRequest,
     responseSerialize: serialize_ondewo_sip_SipStatus,
     responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
   // Registers s SIP account at a SIP server
-registerAccount: {
-    path: '/ondewo.sip.Sip/RegisterAccount',
+sipRegisterAccount: {
+    path: '/ondewo.sip.Sip/SipRegisterAccount',
     requestStream: false,
     responseStream: false,
-    requestType: ondewo_sip_sip_pb.RegisterAccountRequest,
+    requestType: ondewo_sip_sip_pb.SipRegisterAccountRequest,
     responseType: ondewo_sip_sip_pb.SipStatus,
-    requestSerialize: serialize_ondewo_sip_RegisterAccountRequest,
-    requestDeserialize: deserialize_ondewo_sip_RegisterAccountRequest,
+    requestSerialize: serialize_ondewo_sip_SipRegisterAccountRequest,
+    requestDeserialize: deserialize_ondewo_sip_SipRegisterAccountRequest,
     responseSerialize: serialize_ondewo_sip_SipStatus,
     responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
   // Gets the current SIP status
-getSipStatus: {
-    path: '/ondewo.sip.Sip/GetSipStatus',
+sipGetSipStatus: {
+    path: '/ondewo.sip.Sip/SipGetSipStatus',
     requestStream: false,
     responseStream: false,
     requestType: google_protobuf_empty_pb.Empty,
@@ -209,8 +209,8 @@ getSipStatus: {
     responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
   // Gets the history of SIP status
-getSipStatusHistory: {
-    path: '/ondewo.sip.Sip/GetSipStatusHistory',
+sipGetSipStatusHistory: {
+    path: '/ondewo.sip.Sip/SipGetSipStatusHistory',
     requestStream: false,
     responseStream: false,
     requestType: google_protobuf_empty_pb.Empty,
@@ -221,20 +221,20 @@ getSipStatusHistory: {
     responseDeserialize: deserialize_ondewo_sip_SipStatusHistoryResponse,
   },
   // Plays wav files during an ongoing call of an active SIP session
-playWavFiles: {
-    path: '/ondewo.sip.Sip/PlayWavFiles',
+sipPlayWavFiles: {
+    path: '/ondewo.sip.Sip/SipPlayWavFiles',
     requestStream: false,
     responseStream: false,
-    requestType: ondewo_sip_sip_pb.PlayWavFilesRequest,
+    requestType: ondewo_sip_sip_pb.SipPlayWavFilesRequest,
     responseType: ondewo_sip_sip_pb.SipStatus,
-    requestSerialize: serialize_ondewo_sip_PlayWavFilesRequest,
-    requestDeserialize: deserialize_ondewo_sip_PlayWavFilesRequest,
+    requestSerialize: serialize_ondewo_sip_SipPlayWavFilesRequest,
+    requestDeserialize: deserialize_ondewo_sip_SipPlayWavFilesRequest,
     responseSerialize: serialize_ondewo_sip_SipStatus,
     responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
   // Mutes the microphone in an ongoing call of an active SIP session
-mute: {
-    path: '/ondewo.sip.Sip/Mute',
+sipMute: {
+    path: '/ondewo.sip.Sip/SipMute',
     requestStream: false,
     responseStream: false,
     requestType: google_protobuf_empty_pb.Empty,
@@ -244,9 +244,9 @@ mute: {
     responseSerialize: serialize_ondewo_sip_SipStatus,
     responseDeserialize: deserialize_ondewo_sip_SipStatus,
   },
-  // Unmutes the microphone in an ongoing call of an active SIP session
-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,

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,27 +53,27 @@ 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): RegisterAccountRequest;
+    setAuthUsername(value: string): SipRegisterAccountRequest;
     getOutboundProxy(): string;
-    setOutboundProxy(value: string): RegisterAccountRequest;
+    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,
@@ -82,47 +82,47 @@ export namespace RegisterAccountRequest {
     }
 }
 
-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,
 
@@ -227,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>,
     }