@unboundcx/sdk-internal 1.0.0

package/README.md

@@ -0,0 +1,239 @@
+# Unbound Internal SDK
+
+[![npm version](https://badge.fury.io/js/%40unbound%2Fsdk-internal.svg)](https://badge.fury.io/js/%40unbound%2Fsdk-internal)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Internal SDK extension for Unbound that provides access to internal APIs and administrative functions. This package is designed for use within Unbound's internal infrastructure and requires the main `@unbound/sdk` package.
+
+## ⚠️ Important Notice
+
+This package contains internal APIs and is intended for use within Unbound's infrastructure only. It provides access to administrative functions that should not be exposed to external developers or applications.
+
+## Installation
+
+```bash
+npm install @unbound/sdk-internal
+```
+
+**Requirements:**
+- `@unbound/sdk` ^1.0.0
+- Node.js environment (browser usage not supported)
+
+## Usage
+
+### Basic Setup
+
+```javascript
+import SDK from '@unbound/sdk';
+import InternalSDK from '@unbound/sdk-internal';
+
+const api = new SDK({
+  namespace: 'namespace',
+  callId: 'call-id',
+  token: 'jwt-token'
+});
+
+// Extend with internal functionality
+api.use(InternalSDK);
+
+// Now has access to internal methods
+await api.buildMasterAuth({ 
+  namespace: 'target-namespace',
+  accountId: 'account-123', 
+  userId: 'user-456' 
+});
+```
+
+### Extension Pattern
+
+```javascript
+import SDK from '@unbound/sdk';
+import { InternalSDK } from '@unbound/sdk-internal';
+
+const api = new SDK({ namespace: 'namespace' });
+api.extend(InternalSDK);
+
+// Access internal services
+await api.internal.sip.router('+1234567890', '+0987654321', 'call-123');
+```
+
+## API Reference
+
+### Master Authentication
+
+Build master authentication tokens for cross-account access:
+
+```javascript
+const token = await api.buildMasterAuth({
+  namespace: 'target-namespace',  // Target namespace
+  accountId: 'account-123',       // Target account ID
+  userId: 'user-456'             // Target user ID
+});
+
+// Token is automatically set on the SDK instance
+console.log(api.token); // JWT token for the target account/user
+```
+
+### Internal SIP Service (`api.internal.sip`)
+
+Administrative SIP functions for call routing and registration:
+
+#### Router
+```javascript
+await api.internal.sip.router(
+  '+1234567890',    // to
+  '+0987654321',    // from  
+  'call-123',       // callId
+  { /* auth */ },   // auth object
+  'inbound'         // peerDirection
+);
+```
+
+#### Server Management
+```javascript
+const server = await api.internal.sip.getServer(
+  'voice',          // type
+  'us-east-1',      // regionCode
+  'call-123'        // callId
+);
+```
+
+#### Registration Management
+```javascript
+// Register SIP endpoint
+await api.internal.sip.register({
+  accountId: 'account-123',
+  serverId: 'server-456',
+  callId: 'call-789',
+  username: 'user123',
+  userId: 'user-456',
+  clientIp: '192.168.1.100',
+  isWebRtc: false,
+  transport: 'UDP',
+  contact: 'sip:user@example.com',
+  domain: 'sip.example.com',
+  userAgent: 'Unbound-SIP/1.0',
+  expiresAt: Date.now() + 3600000 // 1 hour from now
+});
+
+// Unregister SIP endpoint
+await api.internal.sip.unregister('call-123', 'user123', 'account-123');
+```
+
+#### Authentication Validation
+```javascript
+await api.internal.sip.validate({
+  method: 'INVITE',
+  username: 'user123',
+  realm: 'sip.example.com',
+  uri: 'sip:+1234567890@sip.example.com',
+  nonce: 'abc123',
+  nc: '00000001',
+  cnonce: 'xyz789',
+  qop: 'auth',
+  response: 'hash-response',
+  authType: 'digest',
+  ip: '192.168.1.100',
+  peerDirection: 'inbound',
+  location: 'us-east-1'
+});
+```
+
+#### Logging
+```javascript
+await api.internal.sip.log({
+  callId: 'call-123',
+  level: 'info',
+  message: 'Call established',
+  data: { /* additional data */ }
+});
+```
+
+## Environment Requirements
+
+This package is designed for **Node.js environments only** and will throw errors when used in browser environments. The internal APIs require server-side authentication and access patterns.
+
+### Supported Environments
+- ✅ Node.js servers
+- ✅ AWS Lambda functions  
+- ✅ Docker containers
+- ✅ Kubernetes pods
+- ❌ Browser applications
+- ❌ Client-side JavaScript
+
+## Security Considerations
+
+### Access Control
+- All internal APIs require elevated authentication
+- Methods may bypass normal user permission checks
+- Use with extreme caution in production environments
+
+### Authentication
+- Requires valid JWT tokens with administrative privileges
+- `buildMasterAuth` provides cross-account access capabilities
+- Always validate target accounts/users before authentication
+
+### Network Security
+- Internal APIs may be accessible only from specific IP ranges
+- SIP functions interact with core telephony infrastructure
+- Audit all usage for security compliance
+
+## Error Handling
+
+```javascript
+try {
+  await api.buildMasterAuth({ 
+    namespace: 'invalid-namespace',
+    accountId: 'invalid-account' 
+  });
+} catch (error) {
+  if (error.message.includes('Master authentication failed')) {
+    // Handle authentication failure
+  } else if (error.message.includes('only available in Node.js')) {
+    // Handle environment error
+  }
+}
+```
+
+## Development
+
+### Setup
+```bash
+git clone https://github.com/unbound/sdk-js-internal.git
+cd sdk-js-internal
+npm install
+```
+
+### Testing
+```bash
+npm test              # Run tests
+npm run test:watch    # Watch mode  
+```
+
+### Building
+```bash
+npm run build         # Build for production
+npm run lint          # Check code style
+```
+
+## Contributing
+
+Internal package contributions require:
+
+1. Security review for all changes
+2. Infrastructure team approval
+3. Testing in isolated environments
+4. Documentation of security implications
+
+## Support
+
+For internal support:
+- 📧 [Internal Support](mailto:internal-support@unbound.cx)
+- 📚 [Internal Documentation](https://internal-docs.unbound.cx/sdk)
+- 🚨 [Security Issues](mailto:security@unbound.cx)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+**Note**: While the code is MIT licensed, access to Unbound's internal APIs requires proper authentication and authorization.

package/index.js

@@ -0,0 +1,63 @@
+/* eslint-disable indent */
+/* eslint-disable prettier/prettier */
+
+import { InternalSipService } from './services/sip.js';
+import { InternalEmailService } from './services/email.js';
+import { InternalProgrammableVoiceService } from './services/programmableVoice.js';
+import { InternalServersService } from './services/servers.js';
+import { InternalSocketService } from './services/socket.js';
+
+export class InternalSDK {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.sip = new InternalSipService(sdk);
+    this.email = new InternalEmailService(sdk);
+    this.programmableVoice = new InternalProgrammableVoiceService(sdk);
+    this.servers = new InternalServersService(sdk);
+    this.socket = new InternalSocketService(sdk);
+  }
+
+  // Master auth method - only available in Node.js
+  async buildMasterAuth({ namespace, accountId, userId }) {
+    if (typeof window !== 'undefined') {
+      throw new Error('buildMasterAuth is only available in Node.js environment');
+    }
+    
+    const { buildMasterApiAuth } = await import('../src/utils/index.js');
+    if (namespace) {
+      this.sdk.setNamespace(namespace);
+    }
+    const auth = await buildMasterApiAuth(this.sdk.namespace, accountId, userId);
+    if (auth?.token?.jwt) {
+      this.sdk.token = auth.token.jwt;
+    }
+    return this.sdk.token;
+  }
+}
+
+// Extension pattern for the main SDK
+export function install(sdk) {
+  const internal = new InternalSDK(sdk);
+  
+  // Add buildMasterAuth to the main SDK instance
+  sdk.buildMasterAuth = internal.buildMasterAuth.bind(internal);
+  
+  // Add internal services
+  sdk.internal = {
+    sip: internal.sip,
+    email: internal.email,
+    programmableVoice: internal.programmableVoice,
+    servers: internal.servers,
+    socket: internal.socket,
+  };
+}
+
+// Default export for ease of use
+export default { install };
+
+// Individual service exports
+export { InternalSipService } from './services/sip.js';
+export { InternalEmailService } from './services/email.js';
+export { InternalProgrammableVoiceService, VoiceChannelService, TranscriptionService } from './services/programmableVoice.js';
+export { InternalServersService, AwsServersService } from './services/servers.js';
+export { InternalSocketService } from './services/socket.js';

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@unboundcx/sdk-internal",
+  "version": "1.0.0",
+  "description": "Internal SDK extension for Unbound - Provides access to internal APIs and administrative functions",
+  "main": "index.js",
+  "type": "module",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "keywords": [
+    "unbound",
+    "sdk",
+    "internal",
+    "sip",
+    "administrative",
+    "extension"
+  ],
+  "author": {
+    "name": "Unbound Team",
+    "email": "support@unbound.cx",
+    "url": "https://unbound.cx"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/unbound/sdk-js-internal.git"
+  },
+  "bugs": {
+    "url": "https://github.com/unbound/sdk-js-internal/issues"
+  },
+  "homepage": "https://docs.unbound.cx/sdk/internal",
+  "files": [
+    "*.js",
+    "services/**/*.js",
+    "types/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "require": "./index.cjs"
+    },
+    "./services/*": {
+      "import": "./services/*.js"
+    }
+  },
+  "scripts": {
+    "build": "echo 'Build complete - ESM modules ready'",
+    "test": "echo 'Tests would run here'", 
+    "lint": "echo 'Linting would run here'",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "@unboundcx/sdk": "^1.0.0"
+  },
+  "devDependencies": {},
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "restricted"
+  }
+}

package/services/email.js

@@ -0,0 +1,62 @@
+export class InternalEmailService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async incrementOpen(emailId) {
+    this.sdk.validateParams(
+      { emailId },
+      {
+        emailId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/internal/email/open/${emailId}`,
+      'POST',
+    );
+    return result;
+  }
+
+  async incrementLinkClick(linkId, { trackingCookie }) {
+    this.sdk.validateParams(
+      { linkId, trackingCookie },
+      {
+        linkId: { type: 'string', required: true },
+        trackingCookie: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: { trackingCookie },
+    };
+
+    const result = await this.sdk._fetch(
+      `/internal/email/click/${linkId}`,
+      'POST',
+      params,
+    );
+    return result;
+  }
+
+  async processUnsubscribe(emailId, { to }) {
+    this.sdk.validateParams(
+      { emailId, to },
+      {
+        emailId: { type: 'string', required: true },
+        to: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: { to },
+    };
+
+    const result = await this.sdk._fetch(
+      `/internal/email/unsubscribe/${emailId}`,
+      'POST',
+      params,
+    );
+    return result;
+  }
+}

package/services/programmableVoice.js

@@ -0,0 +1,378 @@
+export class InternalProgrammableVoiceService {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.voiceChannel = new VoiceChannelService(sdk);
+    this.transcription = new TranscriptionService(sdk);
+  }
+
+  async streamProxy(streamData) {
+    this.sdk.validateParams(
+      { streamData },
+      {
+        streamData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: streamData,
+    };
+
+    const result = await this.sdk._fetch('/internal/programmableVoice/streamProxy', 'POST', params);
+    return result;
+  }
+
+  async webhookProxy(webhookData) {
+    this.sdk.validateParams(
+      { webhookData },
+      {
+        webhookData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: webhookData,
+    };
+
+    const result = await this.sdk._fetch('/internal/programmableVoice/proxy', 'POST', params);
+    return result;
+  }
+
+  async setVariable({ channelId, serverId, variable, value }) {
+    if (!serverId) {
+      serverId = process.env.SERVER_ID;
+    }
+
+    this.sdk.validateParams(
+      { channelId, serverId, variable, value },
+      {
+        channelId: { type: 'string', required: true },
+        serverId: { type: 'string', required: true },
+        variable: { type: 'string', required: true },
+        value: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: {
+        channelId,
+        serverId,
+        variable,
+        value,
+      },
+    };
+
+    const result = await this.sdk._fetch('/internal/programmableVoice/setVariable', 'POST', params);
+    return result;
+  }
+
+  async getVariable({ channelId, serverId, variables }) {
+    if (!serverId) {
+      serverId = process.env.SERVER_ID;
+    }
+
+    this.sdk.validateParams(
+      { channelId, serverId, variables },
+      {
+        channelId: { type: 'string', required: true },
+        serverId: { type: 'string', required: true },
+        variables: { type: 'array', required: true },
+      },
+    );
+
+    const params = {
+      body: {
+        channelId,
+        serverId,
+        variables,
+      },
+    };
+
+    const result = await this.sdk._fetch('/internal/programmableVoice/getVariable', 'POST', params);
+    return result;
+  }
+
+  async joinMeetingRoom({
+    meetingId,
+    meetingPassword,
+    meetingJoinType,
+    numberCalled,
+    callerIdNumber,
+    channelId,
+    loopCount,
+    engagementSessionId,
+    voiceChannelId,
+    serverId
+  }) {
+    this.sdk.validateParams(
+      { meetingId },
+      {
+        meetingId: { type: 'string', required: true },
+        meetingPassword: { type: 'string', required: false },
+        meetingJoinType: { type: 'string', required: false },
+        numberCalled: { type: 'string', required: false },
+        callerIdNumber: { type: 'string', required: false },
+        channelId: { type: 'string', required: false },
+        loopCount: { type: 'number', required: false },
+        engagementSessionId: { type: 'string', required: false },
+        voiceChannelId: { type: 'string', required: false },
+        serverId: { type: 'string', required: false },
+      },
+    );
+
+    const meetingData = { meetingId };
+    if (meetingPassword) meetingData.meetingPassword = meetingPassword;
+    if (meetingJoinType) meetingData.meetingJoinType = meetingJoinType;
+    if (numberCalled) meetingData.numberCalled = numberCalled;
+    if (callerIdNumber) meetingData.callerIdNumber = callerIdNumber;
+    if (channelId) meetingData.channelId = channelId;
+    if (loopCount) meetingData.loopCount = loopCount;
+    if (engagementSessionId) meetingData.engagementSessionId = engagementSessionId;
+    if (voiceChannelId) meetingData.voiceChannelId = voiceChannelId;
+    if (serverId) meetingData.serverId = serverId;
+
+    const params = {
+      body: meetingData,
+    };
+
+    const result = await this.sdk._fetch('/internal/programmableVoice/joinMeetingRoom', 'POST', params);
+    return result;
+  }
+
+  async createNewVoiceAppSession(location, sessionData) {
+    this.sdk.validateParams(
+      { location, sessionData },
+      {
+        location: { type: 'string', required: true },
+        sessionData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: sessionData,
+    };
+
+    const result = await this.sdk._fetch(`/internal/programmableVoice/${location}`, 'POST', params);
+    return result;
+  }
+}
+
+export class VoiceChannelService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async create({
+    channelId,
+    serverId,
+    isVoice,
+    accountId,
+    engagementSessionId,
+    to,
+    from,
+    direction,
+    isCopy,
+    originalChannelId,
+    isComplete,
+  }) {
+    if (!serverId) {
+      serverId = process.env.SERVER_ID;
+    }
+
+    this.sdk.validateParams(
+      {
+        channelId,
+        serverId,
+        isVoice,
+        accountId,
+        engagementSessionId,
+        to,
+        from,
+        direction,
+        isCopy,
+        originalChannelId,
+        isComplete,
+      },
+      {
+        channelId: { type: 'string', required: true },
+        serverId: { type: 'string', required: true },
+        isVoice: { type: 'boolean', required: true },
+        accountId: { type: 'string', required: false },
+        engagementSessionId: { type: 'string', required: false },
+        to: { type: 'string', required: true },
+        from: { type: 'string', required: true },
+        direction: { type: 'string', required: true },
+        isCopy: { type: 'boolean', required: false },
+        originalChannelId: { type: 'string', required: false },
+        isComplete: { type: 'boolean', required: false },
+      },
+    );
+
+    const params = {
+      body: {
+        channelId,
+        serverId,
+        isVoice,
+        accountId,
+        engagementSessionId,
+        to,
+        from,
+        direction,
+        isCopy,
+        originalChannelId,
+        isComplete,
+      },
+    };
+
+    const result = await this.sdk._fetch('/internal/programmableVoice/voiceChannel', 'POST', params);
+    return result;
+  }
+
+  async update({
+    channelId,
+    serverId,
+    isVoice,
+    accountId,
+    engagementSessionId,
+    to,
+    from,
+    direction,
+    voiceChannelId,
+    isCopy,
+    originalChannelId,
+    isComplete,
+  }) {
+    if (!serverId) {
+      serverId = process.env.SERVER_ID;
+    }
+
+    this.sdk.validateParams(
+      {
+        channelId,
+        serverId,
+        isVoice,
+        accountId,
+        engagementSessionId,
+        to,
+        from,
+        direction,
+        voiceChannelId,
+        isCopy,
+        originalChannelId,
+        isComplete,
+      },
+      {
+        channelId: { type: 'string', required: true },
+        serverId: { type: 'string', required: true },
+        isVoice: { type: 'boolean', required: true },
+        accountId: { type: 'string', required: false },
+        engagementSessionId: { type: 'string', required: false },
+        to: { type: 'string', required: true },
+        from: { type: 'string', required: true },
+        direction: { type: 'string', required: true },
+        voiceChannelId: { type: 'string', required: false },
+        isCopy: { type: 'boolean', required: false },
+        originalChannelId: { type: 'string', required: false },
+        isComplete: { type: 'boolean', required: false },
+      },
+    );
+
+    const params = {
+      body: {
+        channelId,
+        serverId,
+        isVoice,
+        accountId,
+        engagementSessionId,
+        to,
+        from,
+        direction,
+        voiceChannelId,
+        isCopy,
+        originalChannelId,
+        isComplete,
+      },
+    };
+
+    const result = await this.sdk._fetch('/internal/programmableVoice/voiceChannel', 'PUT', params);
+    return result;
+  }
+}
+
+export class TranscriptionService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async create({
+    voiceChannelId,
+    engagementSessionId,
+    accountId,
+    name,
+    direction,
+    role,
+    userId,
+    playbookId
+  }) {
+    this.sdk.validateParams(
+      { voiceChannelId, engagementSessionId, accountId },
+      {
+        voiceChannelId: { type: 'string', required: true },
+        engagementSessionId: { type: 'string', required: true },
+        accountId: { type: 'string', required: true },
+        name: { type: 'string', required: false },
+        direction: { type: 'string', required: false },
+        role: { type: 'string', required: false },
+        userId: { type: 'string', required: false },
+        playbookId: { type: 'string', required: false },
+      },
+    );
+
+    const transcriptionData = { voiceChannelId, engagementSessionId, accountId };
+    if (name) transcriptionData.name = name;
+    if (direction) transcriptionData.direction = direction;
+    if (role) transcriptionData.role = role;
+    if (userId) transcriptionData.userId = userId;
+    if (playbookId) transcriptionData.playbookId = playbookId;
+
+    const params = {
+      body: transcriptionData,
+    };
+
+    const result = await this.sdk._fetch('/internal/programmableVoice/transcription/', 'POST', params);
+    return result;
+  }
+
+  async complete(id, completionData) {
+    this.sdk.validateParams(
+      { id, completionData },
+      {
+        id: { type: 'string', required: true },
+        completionData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: completionData,
+    };
+
+    const result = await this.sdk._fetch(`/internal/programmableVoice/transcription/${id}`, 'PUT', params);
+    return result;
+  }
+
+  async logMessage(id, messageData) {
+    this.sdk.validateParams(
+      { id, messageData },
+      {
+        id: { type: 'string', required: true },
+        messageData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: messageData,
+    };
+
+    const result = await this.sdk._fetch(`/internal/programmableVoice/transcription/${id}`, 'POST', params);
+    return result;
+  }
+}

package/services/servers.js

@@ -0,0 +1,130 @@
+export class InternalServersService {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.aws = new AwsServersService(sdk);
+  }
+
+  async create({
+    type,
+    region,
+    privateIp,
+    publicIp,
+    status,
+    arch,
+    podName,
+    namespace,
+    K8S_SERVICE_NAME,
+    K8S_DEPLOYMENT_TYPE
+  }) {
+    this.sdk.validateParams(
+      { type, region },
+      {
+        type: { type: 'string', required: true },
+        region: { type: 'string', required: true },
+        privateIp: { type: 'string', required: false },
+        publicIp: { type: 'string', required: false },
+        status: { type: 'string', required: false },
+        arch: { type: 'string', required: false },
+        podName: { type: 'string', required: false },
+        namespace: { type: 'string', required: false },
+        K8S_SERVICE_NAME: { type: 'string', required: false },
+        K8S_DEPLOYMENT_TYPE: { type: 'string', required: false },
+      },
+    );
+
+    const serverData = { type, region };
+    if (privateIp) serverData.privateIp = privateIp;
+    if (publicIp) serverData.publicIp = publicIp;
+    if (status) serverData.status = status;
+    if (arch) serverData.arch = arch;
+    if (podName) serverData.podName = podName;
+    if (namespace) serverData.namespace = namespace;
+    if (K8S_SERVICE_NAME) serverData.K8S_SERVICE_NAME = K8S_SERVICE_NAME;
+    if (K8S_DEPLOYMENT_TYPE) serverData.K8S_DEPLOYMENT_TYPE = K8S_DEPLOYMENT_TYPE;
+
+    const params = {
+      body: serverData,
+    };
+
+    const result = await this.sdk._fetch('/internal/servers/', 'POST', params);
+    return result;
+  }
+
+  async update(id, { status, region, privateIp }) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+        status: { type: 'string', required: false },
+        region: { type: 'string', required: false },
+        privateIp: { type: 'string', required: false },
+      },
+    );
+
+    // Validate status if provided
+    if (status) {
+      const validStatuses = ['booting', 'ready', 'maintenance', 'error', 'stopped', 'stopping'];
+      if (!validStatuses.includes(status)) {
+        throw new Error(`Invalid status. Must be one of: ${validStatuses.join(', ')}`);
+      }
+    }
+
+    const updateData = {};
+    if (status) updateData.status = status;
+    if (region) updateData.region = region;
+    if (privateIp) updateData.privateIp = privateIp;
+
+    const params = {
+      body: updateData,
+    };
+
+    const result = await this.sdk._fetch(`/internal/servers/${id}`, 'PUT', params);
+    return result;
+  }
+
+  async delete(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/internal/servers/${id}`, 'DELETE');
+    return result;
+  }
+
+  async shutdownCheck(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/internal/servers/${id}/shutdownCheck`, 'GET');
+    return result;
+  }
+}
+
+export class AwsServersService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async assignElasticIp(assignmentData) {
+    this.sdk.validateParams(
+      { assignmentData },
+      {
+        assignmentData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: assignmentData,
+    };
+
+    const result = await this.sdk._fetch('/internal/servers/aws/assignElasticIp', 'POST', params);
+    return result;
+  }
+}

package/services/sip.js

@@ -0,0 +1,249 @@
+export class InternalSipService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async router(to, from, callId, auth, peerDirection) {
+    this.sdk.validateParams(
+      { to, from, callId, auth, peerDirection },
+      {
+        to: { type: 'string', required: true },
+        from: { type: 'string', required: false },
+        callId: { type: 'string', required: false },
+        auth: { type: 'object', required: false },
+        peerDirection: { type: 'string', required: false },
+      },
+    );
+
+    const options = {
+      body: { to, from, callId, auth, peerDirection },
+    };
+    const result = await this.sdk._fetch(
+      `/internal/sip/router/${to}?from=${from}&callId=${callId}`,
+      'POST',
+      options,
+      true,
+    );
+    return result;
+  }
+
+  async getServer(type, regionCode, callId) {
+    this.sdk.validateParams(
+      { type, regionCode, callId },
+      {
+        type: { type: 'string', required: true },
+        regionCode: { type: 'string', required: true },
+        callId: { type: 'string', required: false },
+      },
+    );
+
+    const options = {};
+    const result = await this.sdk._fetch(
+      `/internal/sip/server/${type}?regionCode=${regionCode}&callId=${callId}`,
+      'GET',
+      options,
+      true,
+    );
+    return result;
+  }
+
+  async log(params) {
+    const options = {
+      body: {
+        ...params,
+      },
+    };
+    const result = await this.sdk._fetch(
+      `/internal/sip/log`,
+      'POST',
+      options,
+      true,
+      false,
+    );
+    return result;
+  }
+
+  async register({
+    accountId,
+    serverId,
+    callId,
+    username,
+    userId,
+    clientIp,
+    isWebRtc = false,
+    connnectionId,
+    transport,
+    contact,
+    domain,
+    host,
+    port,
+    userAgent,
+    expiresAt,
+  }) {
+    this.sdk.validateParams(
+      {
+        accountId,
+        serverId,
+        callId,
+        username,
+        userId,
+        clientIp,
+        isWebRtc,
+        connnectionId,
+        transport,
+        contact,
+        domain,
+        host,
+        port,
+        userAgent,
+        expiresAt,
+      },
+      {
+        accountId: { type: 'string', required: true },
+        serverId: { type: 'string', required: true },
+        callId: { type: 'string', required: true },
+        username: { type: 'string', required: true },
+        userId: { type: 'string', required: false },
+        clientIp: { type: 'string', required: true },
+        isWebRtc: { type: 'boolean', required: true },
+        connnectionId: { type: 'string', required: false },
+        transport: { type: 'string', required: true },
+        contact: { type: 'string', required: true },
+        domain: { type: 'string', required: true },
+        port: { type: 'number', required: false },
+        userAgent: { type: 'string', required: true },
+        expiresAt: { type: 'number', required: true },
+      },
+    );
+
+    const options = {
+      body: {
+        accountId,
+        serverId,
+        callId,
+        username,
+        userId,
+        clientIp,
+        isWebRtc,
+        contact,
+        connnectionId,
+        transport,
+        host,
+        port,
+        userAgent,
+        expiresAt,
+      },
+    };
+
+    const result = await this.sdk._fetch(
+      `/internal/sip/register`,
+      'POST',
+      options,
+      true,
+      false,
+    );
+    return result;
+  }
+
+  async unregister(callId, username, accountId) {
+    this.sdk.validateParams(
+      { callId, username, accountId },
+      {
+        username: { type: 'string', required: true },
+        callId: { type: 'string', required: true },
+        accountId: { type: 'string', required: true },
+      },
+    );
+
+    const options = {
+      body: {
+        callId,
+        username,
+        accountId,
+      },
+    };
+    const result = await this.sdk._fetch(
+      `/internal/sip/register/`,
+      'DELETE',
+      options,
+      true,
+      false,
+    );
+    return result;
+  }
+
+  async validate({
+    method,
+    username,
+    realm,
+    uri,
+    nonce,
+    nc,
+    cnonce,
+    qop,
+    response,
+    authType,
+    ip,
+    peerDirection,
+    location,
+  }) {
+    this.sdk.validateParams(
+      {
+        method,
+        username,
+        realm,
+        uri,
+        nonce,
+        nc,
+        cnonce,
+        qop,
+        response,
+        authType,
+        ip,
+        peerDirection,
+        location,
+      },
+      {
+        method: { type: 'string', required: false },
+        username: { type: 'string', required: false },
+        realm: { type: 'string', required: false },
+        uri: { type: 'string', required: false },
+        nonce: { type: 'string', required: false },
+        nc: { type: 'string', required: false },
+        cnonce: { type: 'string', required: false },
+        qop: { type: 'string', required: false },
+        response: { type: 'string', required: false },
+        authType: { type: 'string', required: false },
+        ip: { type: 'string', required: false },
+        peerDirection: { type: 'string', required: false },
+        location: { type: 'string', required: false },
+      },
+    );
+
+    const options = {
+      body: {
+        method,
+        username,
+        realm,
+        uri,
+        nonce,
+        nc,
+        cnonce,
+        qop,
+        response,
+        authType,
+        ip,
+        peerDirection,
+        location,
+      },
+    };
+    const result = await this.sdk._fetch(
+      `/internal/sip/register/validate`,
+      'POST',
+      options,
+      false,
+      false,
+    );
+    return result;
+  }
+}

package/services/socket.js

@@ -0,0 +1,103 @@
+export class InternalSocketService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async createConnection({
+    userId,
+    sessionId,
+    socketId,
+    accountCode,
+    accountId,
+    tokenId,
+    serverId,
+    clientIp,
+    clientOs,
+    clientBrowser
+  }) {
+    this.sdk.validateParams(
+      { socketId, accountCode, accountId, serverId },
+      {
+        userId: { type: 'string', required: false },
+        sessionId: { type: 'string', required: false },
+        socketId: { type: 'string', required: true },
+        accountCode: { type: 'string', required: true },
+        accountId: { type: 'string', required: true },
+        tokenId: { type: 'string', required: false },
+        serverId: { type: 'string', required: true },
+        clientIp: { type: 'string', required: false },
+        clientOs: { type: 'string', required: false },
+        clientBrowser: { type: 'string', required: false },
+      },
+    );
+
+    const connectionData = { socketId, accountCode, accountId, serverId };
+    if (userId) connectionData.userId = userId;
+    if (sessionId) connectionData.sessionId = sessionId;
+    if (tokenId) connectionData.tokenId = tokenId;
+    if (clientIp) connectionData.clientIp = clientIp;
+    if (clientOs) connectionData.clientOs = clientOs;
+    if (clientBrowser) connectionData.clientBrowser = clientBrowser;
+
+    const params = {
+      body: connectionData,
+    };
+
+    const result = await this.sdk._fetch('/internal/socket/connection', 'POST', params);
+    return result;
+  }
+
+  async updateConnection(id, { rtt, clientIp, clientOs, clientBrowser }) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+        rtt: { type: 'number', required: false },
+        clientIp: { type: 'string', required: false },
+        clientOs: { type: 'string', required: false },
+        clientBrowser: { type: 'string', required: false },
+      },
+    );
+
+    const updateData = {};
+    if (rtt !== undefined) updateData.rtt = rtt;
+    if (clientIp) updateData.clientIp = clientIp;
+    if (clientOs) updateData.clientOs = clientOs;
+    if (clientBrowser) updateData.clientBrowser = clientBrowser;
+
+    const params = {
+      body: updateData,
+    };
+
+    const result = await this.sdk._fetch(`/internal/socket/connection/${id}`, 'PUT', params);
+    return result;
+  }
+
+  async deleteConnection(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/internal/socket/connection/${id}`, 'DELETE');
+    return result;
+  }
+
+  async deleteAllConnectionsByServer(serverId) {
+    this.sdk.validateParams(
+      { serverId },
+      {
+        serverId: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: { serverId },
+    };
+
+    const result = await this.sdk._fetch('/internal/socket/connection/byServerId', 'DELETE', params);
+    return result;
+  }
+}