@z-api/call 1.0.0-staging.0

package/README.md

@@ -0,0 +1,590 @@
+# @z-api/call
+
+SDK para integrar chamadas VoIP do WhatsApp em aplicações web. Fornece um widget pronto (webphone) com discador, lista de chamadas e tela de ligação ativa, além de uma API programática completa.
+
+## Instalação
+
+```bash
+npm install @z-api/call
+```
+
+### Via CDN (script tag)
+
+```html
+<script src="https://unpkg.com/@z-api/call/dist/z-api-call.global.js"></script>
+<script>
+  const client = ZAPICall.init({
+    instanceId: 'SUA_INSTANCE_ID',
+    getToken: async () => {
+      const res = await fetch('https://seu-backend.com/call-token');
+      const data = await res.json();
+      return data.token;
+    },
+  });
+</script>
+```
+
+## Quick Start
+
+```typescript
+import { init } from '@z-api/call';
+
+const client = init({
+  instanceId: 'SUA_INSTANCE_ID',
+  getToken: async () => {
+    // Chama SEU backend, que por sua vez chama a Z-API para obter o token efêmero
+    const res = await fetch('https://seu-backend.com/call-token');
+    const data = await res.json();
+    return data.token;
+  },
+});
+
+// Ouvir eventos
+client.on('call:incoming', (call) => {
+  console.log('Chamada recebida de', call.from);
+});
+
+client.on('connected', () => {
+  console.log('Conectado ao servidor');
+});
+```
+
+## Autenticação (getToken)
+
+A SDK utiliza tokens efêmeros para autenticação. Em vez de passar um token fixo, você fornece uma função `getToken` que é chamada sempre que a SDK precisa se conectar (inclusive em reconexões).
+
+### Fluxo de autenticação
+
+```
+┌──────────┐      getToken()      ┌───────────────┐     POST /call-token     ┌─────────────┐
+│   SDK    │ ──────────────────► │  Seu Backend  │ ──────────────────────► │   Z-API     │
+│ (browser)│                      │               │                         │             │
+│          │ ◄────────────────── │               │ ◄────────────────────── │             │
+│          │    token efêmero     │               │     token efêmero       │             │
+└──────────┘                      └───────────────┘                         └─────────────┘
+```
+
+1. A SDK chama a função `getToken` fornecida por você
+2. Sua função faz uma requisição ao **seu backend**
+3. Seu backend chama a API da Z-API para gerar o token efêmero:
+
+```
+POST https://api.z-api.io/instances/{ID_INSTANCE}/token/{TOKEN_INSTANCE}/call-token
+Header: client-token: SEU_CLIENT_TOKEN
+```
+
+4. A Z-API retorna o token efêmero
+5. Seu backend repassa o token para o frontend
+6. A SDK usa o token para conectar via WebSocket
+
+### Exemplo de backend (Node.js)
+
+```javascript
+app.get('/call-token', async (req, res) => {
+  const response = await fetch(
+    `https://api.z-api.io/instances/${ID_INSTANCE}/token/${TOKEN_INSTANCE}/call-token`,
+    {
+      method: 'POST',
+      headers: { 'client-token': SEU_CLIENT_TOKEN },
+    }
+  );
+  const data = await response.json();
+  res.json({ token: data.token });
+});
+```
+
+### Exemplo de getToken no frontend
+
+```typescript
+const client = init({
+  instanceId: 'SUA_INSTANCE_ID',
+  getToken: async () => {
+    const res = await fetch('https://seu-backend.com/call-token');
+    const { token } = await res.json();
+    return token;
+  },
+});
+```
+
+> **Importante:** Nunca exponha o `TOKEN_INSTANCE` ou `client-token` no frontend. A chamada à Z-API deve ser feita pelo seu backend.
+
+## Opções de Inicialização
+
+```typescript
+const client = init({
+  // --- Obrigatórios ---
+  instanceId: string,                    // ID da instância Z-API
+  getToken: () => Promise<string>,       // Função que retorna o token efêmero
+
+  // --- Opcionais ---
+  autoWidget: true,            // Criar widget automaticamente (default: true)
+  showVideoDialButton: false,  // Exibir botão de vídeo chamada no discador (default: false)
+  position: 'bottom-right',   // Posição do widget (ver abaixo)
+  theme: { ... },             // Personalização visual (ver Temas)
+
+  // --- Callbacks ---
+  onIncomingCall: (call) => {},      // Chamada recebida
+  onCallTerminated: (callId) => {},  // Chamada encerrada
+  onConnectionChange: (connected) => {}, // Conexão mudou
+  onMakeCall: (number) => {},        // Chamada de saída iniciada
+});
+```
+
+### Posições do Widget
+
+| Valor | Posição |
+|-------|---------|
+| `'bottom-right'` | Canto inferior direito (default) |
+| `'bottom-left'` | Canto inferior esquerdo |
+| `'top-right'` | Canto superior direito |
+| `'top-left'` | Canto superior esquerdo |
+
+## Temas
+
+### Dark / Light Mode
+
+```typescript
+// Tema escuro (default)
+const client = init({
+  instanceId: '...',
+  getToken: async () => { /* ... */ },
+  theme: { mode: 'dark' },
+});
+
+// Tema claro
+const client = init({
+  instanceId: '...',
+  getToken: async () => { /* ... */ },
+  theme: { mode: 'light' },
+});
+```
+
+### Personalização Completa
+
+Todas as propriedades são opcionais. Os valores default dependem do `mode`.
+
+```typescript
+theme: {
+  mode: 'dark',              // 'dark' | 'light'
+  primaryColor: '#00a884',   // Cor principal (botões, destaques)
+  dangerColor: '#f44336',    // Cor de perigo (rejeitar, encerrar)
+  backgroundColor: '#202c33',// Fundo dos cards e numpad
+  surfaceColor: '#111b21',   // Fundo do painel
+  textColor: '#e9edef',      // Cor do texto principal
+  textSecondaryColor: '#8696a0', // Cor do texto secundário
+  borderRadius: '16px',      // Raio de borda do painel
+  fontFamily: 'Inter, sans-serif', // Família de fontes
+}
+```
+
+**Defaults por modo:**
+
+| Propriedade | Dark | Light |
+|-------------|------|-------|
+| `backgroundColor` | `#202c33` | `#f0f2f5` |
+| `surfaceColor` | `#111b21` | `#ffffff` |
+| `textColor` | `#e9edef` | `#111b21` |
+| `textSecondaryColor` | `#8696a0` | `#667781` |
+
+## API do Cliente
+
+### Métodos
+
+#### `accept(callId: string): void`
+
+Aceita uma chamada recebida.
+
+```typescript
+client.on('call:incoming', (call) => {
+  client.accept(call.callId);
+});
+```
+
+#### `reject(callId: string): void`
+
+Rejeita ou encerra uma chamada.
+
+```typescript
+client.reject(callId);
+```
+
+#### `makeCall(number: string, isVideo?: boolean): void`
+
+Inicia uma chamada de saída (áudio ou vídeo).
+
+```typescript
+client.makeCall('5511999999999');        // chamada de áudio
+client.makeCall('5511999999999', true);  // chamada de vídeo
+```
+
+> **Nota:** Requer suporte no backend. A SDK envia o evento `call:make` via WebSocket.
+
+#### `setCamera(enabled: boolean): Promise<void>`
+
+Liga ou desliga a câmera durante uma chamada. Se a chamada for de áudio, automaticamente solicita upgrade para vídeo.
+
+```typescript
+await client.setCamera(true);  // ligar câmera
+await client.setCamera(false); // desligar câmera
+```
+
+#### `isCameraActive(): boolean`
+
+Retorna se a câmera está ativa.
+
+```typescript
+if (client.isCameraActive()) {
+  console.log('Câmera ligada');
+}
+```
+
+#### `mute(muted: boolean): void`
+
+Ativa/desativa o microfone.
+
+```typescript
+client.mute(true);  // mutar
+client.mute(false); // desmutar
+```
+
+#### `getCalls(): CallInfo[]`
+
+Retorna todas as chamadas ativas.
+
+```typescript
+const calls = client.getCalls();
+calls.forEach(c => console.log(c.callId, c.state));
+```
+
+#### `getActiveCall(): CallInfo | undefined`
+
+Retorna a chamada ativa (accepted/active) se houver.
+
+```typescript
+const call = client.getActiveCall();
+if (call) {
+  console.log('Em ligação com', call.from);
+}
+```
+
+#### `isConnected(): boolean`
+
+Verifica se está conectado ao servidor.
+
+```typescript
+if (client.isConnected()) {
+  console.log('Online');
+}
+```
+
+#### `destroy(): void`
+
+Destrói o cliente, fecha conexões e remove o widget do DOM.
+
+```typescript
+client.destroy();
+```
+
+### Eventos
+
+```typescript
+// Conexão estabelecida
+client.on('connected', () => { });
+
+// Conexão perdida
+client.on('disconnected', () => { });
+
+// Chamada recebida
+client.on('call:incoming', (call: CallInfo) => {
+  console.log(call.callId, call.from, call.isVideo);
+});
+
+// Estado da chamada mudou
+client.on('call:state', (callId: string, state: CallState) => {
+  // state: 'ringing' | 'preaccepted' | 'accepted' | 'active' | 'ended'
+});
+
+// Chamada encerrada
+client.on('call:terminated', (callId: string, reason?: string) => { });
+
+// Vídeo ativado/desativado durante a chamada (upgrade/downgrade)
+client.on('call:video-state', (callId: string, isVideo: boolean) => {
+  console.log(isVideo ? 'Chamada mudou para vídeo' : 'Chamada voltou para áudio');
+});
+
+// Chamada de saída iniciada
+client.on('call:outgoing', (call: CallInfo) => { });
+
+// Chamada de saída iniciada (número)
+client.on('call:make', (number: string) => { });
+
+// Nível de áudio (0 a 1)
+client.on('audio:level', (level: number) => {
+  console.log('Volume:', Math.round(level * 100) + '%');
+});
+
+// Erro
+client.on('error', (error: Error) => {
+  console.error(error.message);
+});
+```
+
+Para remover um listener:
+
+```typescript
+const handler = (call) => console.log(call);
+client.on('call:incoming', handler);
+client.off('call:incoming', handler);
+```
+
+## Widget
+
+O widget é criado automaticamente quando `autoWidget` está ativo (default). Ele renderiza dentro de um Shadow DOM isolado, sem conflitos de CSS com a aplicação host.
+
+### Estrutura
+
+O widget possui 3 views:
+
+**Discador** — Teclado numérico para digitar e iniciar chamadas.
+
+**Chamadas** — Lista de chamadas ativas com botões de aceitar/rejeitar/encerrar.
+
+**Ligação Ativa** — Tela fullscreen (no painel) com avatar, número, timer, barra de áudio e controles de mute/encerrar.
+
+### Comportamento Automático
+
+- Abre o painel automaticamente ao receber uma chamada
+- Muda para a view "Chamadas" quando tem chamada entrando
+- Muda para a view "Ligação Ativa" quando a chamada é aceita
+- Volta para "Discador" quando todas as chamadas encerram
+- Badge no bubble mostra número de chamadas ativas
+- Dot verde/vermelho indica status da conexão
+- Pulse animation no bubble quando tem chamada tocando
+
+### Modo Headless
+
+Para controlar tudo manualmente sem widget:
+
+```typescript
+const client = init({
+  instanceId: '...',
+  getToken: async () => { /* ... */ },
+  autoWidget: false,
+});
+
+// Gerencie chamadas via API
+client.on('call:incoming', (call) => {
+  // Sua UI customizada
+});
+```
+
+## Tipos
+
+```typescript
+interface CallInfo {
+  callId: string;     // ID único da chamada
+  from: string;       // Número de origem
+  isVideo: boolean;   // Se é vídeo chamada
+  isGroup: boolean;   // Se é chamada de grupo
+  state: CallState;   // Estado atual
+  timestamp: number;  // Timestamp de início
+}
+
+type CallState = 'ringing' | 'preaccepted' | 'accepted' | 'active' | 'ended';
+
+type WidgetPosition = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+
+type ThemeMode = 'dark' | 'light';
+
+interface AudioConfig {
+  sampleRate: number; // Taxa de amostragem (ex: 16000)
+  channels: number;   // Canais de áudio (1 = mono)
+}
+```
+
+## Protocolo WebSocket
+
+A SDK se conecta automaticamente ao servidor via WebSocket e gerencia reconexão com backoff exponencial. O token efêmero obtido via `getToken` é utilizado em cada conexão/reconexão.
+
+### URL de Conexão
+
+```
+wss://call.z-api.io/ws/call?instance=SUA_INSTANCE_ID&token=TOKEN_EFEMERO
+```
+
+### Mensagens Client -> Server
+
+| Tipo | Payload | Descrição |
+|------|---------|-----------|
+| `call:accept` | `{ callId }` | Aceitar chamada |
+| `call:reject` | `{ callId }` | Rejeitar/encerrar chamada |
+| `call:mute` | `{ muted }` | Mutar/desmutar mic |
+| `call:camera` | `{ enabled }` | Ligar/desligar câmera (upgrade para vídeo se necessário) |
+| `call:make` | `{ number, isVideo? }` | Iniciar chamada de saída (áudio ou vídeo) |
+| `ping` | `{}` | Keep-alive (automático, 25s) |
+| *binary 0x01* | `ArrayBuffer` | Áudio PCM Int16LE do microfone |
+| *binary 0x02* | `ArrayBuffer` | Frame de vídeo NV12 (width u16 + height u16 + data) |
+
+### Mensagens Server -> Client
+
+| Tipo | Payload | Descrição |
+|------|---------|-----------|
+| `connected` | `{ instanceId, sdkId, audioConfig }` | Conexão estabelecida |
+| `call:incoming` | `{ callId, from, isVideo, isGroup, state?, timestamp }` | Chamada recebida |
+| `call:outgoing` | `{ callId, to, isVideo }` | Chamada de saída iniciada |
+| `call:state` | `{ callId, state }` | Mudança de estado |
+| `call:video-state` | `{ callId, isVideo }` | Vídeo ativado/desativado durante chamada |
+| `call:terminated` | `{ callId, reason? }` | Chamada encerrada |
+| `call:claimed` | `{ callId }` | Chamada aceita por outro cliente |
+| `call:dismissed` | `{ callId }` | Chamada rejeitada por outro cliente |
+| `pong` | `{ ts }` | Resposta ao ping |
+| `error` | `{ command, message }` | Erro de processamento |
+| *binary 0x00* | `ArrayBuffer` | Áudio PCM Int16LE para playback |
+| *binary 0x01* | `ArrayBuffer` | Frame de vídeo (header 16 bytes + pixel data) |
+
+## Áudio
+
+A SDK gerencia captura e reprodução de áudio automaticamente:
+
+- **Formato:** PCM Int16LE, mono
+- **Sample rate:** Configurável pelo servidor (default: 16000 Hz)
+- **Captura:** Microfone com echo cancellation, noise suppression e auto gain
+- **Playback:** Web Audio API com scheduling otimizado
+- **Permissão:** O microfone é solicitado automaticamente ao aceitar uma chamada
+
+> **Importante:** Navegadores exigem interação do usuário antes de reproduzir áudio. A SDK chama `AudioContext.resume()` automaticamente quando o usuário clica no widget.
+
+## Vídeo
+
+A SDK suporta chamadas de vídeo e upgrade de áudio para vídeo durante a chamada:
+
+- **Formato de recepção:** NV12 com header (width, height, format, orientation, keyframe, timestamp)
+- **Formato de envio:** NV12 (RGBA capturado da câmera, convertido para NV12 no browser)
+- **Renderização:** WebCodecs API (hardware-accelerated) com fallback para software
+- **Câmera:** Captura a 320x240 @ 30fps (default)
+- **Orientação:** Suporte a rotação 0/90/180/270 graus
+
+### Fluxos suportados
+
+| Cenário | Comportamento |
+|---------|--------------|
+| Chamada inicia como vídeo | Câmera liga automaticamente ao aceitar |
+| Chamada inicia como áudio, peer muda para vídeo | Vídeo remoto é exibido, câmera liga pelo botão |
+| Chamada inicia como áudio, usuário muda para vídeo | Clica no botão de câmera, envia upgrade request ao peer |
+| Discador com botão de vídeo | Habilitado via `showVideoDialButton: true` |
+
+## Exemplos
+
+### Integração Básica
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Meu Webphone</title>
+</head>
+<body>
+  <h1>Minha Aplicação</h1>
+  <script src="https://unpkg.com/@z-api/call/dist/z-api-call.global.js"></script>
+  <script>
+    const client = ZAPICall.init({
+      instanceId: 'minha-instancia',
+      getToken: async () => {
+        const res = await fetch('https://seu-backend.com/call-token');
+        const data = await res.json();
+        return data.token;
+      },
+      theme: { mode: 'light' },
+    });
+  </script>
+</body>
+</html>
+```
+
+### React
+
+```tsx
+import { useEffect, useRef } from 'react';
+import { init, ZAPICallClient } from '@z-api/call';
+
+function App() {
+  const clientRef = useRef<ZAPICallClient | null>(null);
+
+  useEffect(() => {
+    const client = init({
+      instanceId: 'minha-instancia',
+      getToken: async () => {
+        const res = await fetch('/api/call-token');
+        const { token } = await res.json();
+        return token;
+      },
+      position: 'bottom-left',
+      theme: { mode: 'dark', primaryColor: '#7c3aed' },
+      onIncomingCall: (call) => {
+        console.log('Chamada de', call.from);
+      },
+    });
+
+    clientRef.current = client;
+    return () => client.destroy();
+  }, []);
+
+  return <div>Minha App</div>;
+}
+```
+
+### Headless com UI Customizada
+
+```typescript
+import { init } from '@z-api/call';
+
+const client = init({
+  instanceId: '...',
+  getToken: async () => {
+    const res = await fetch('/api/call-token');
+    const { token } = await res.json();
+    return token;
+  },
+  autoWidget: false,
+});
+
+client.on('connected', () => {
+  document.getElementById('status')!.textContent = 'Online';
+});
+
+client.on('call:incoming', (call) => {
+  const accept = confirm(`Chamada de ${call.from}. Aceitar?`);
+  if (accept) {
+    client.accept(call.callId);
+  } else {
+    client.reject(call.callId);
+  }
+});
+
+client.on('call:state', (callId, state) => {
+  document.getElementById('call-state')!.textContent = state;
+});
+
+client.on('audio:level', (level) => {
+  document.getElementById('meter')!.style.width = `${level * 100}%`;
+});
+```
+
+## Compatibilidade
+
+- Chrome 80+
+- Firefox 78+
+- Safari 14+
+- Edge 80+
+
+Requer suporte a:
+- WebSocket
+- Web Audio API
+- getUserMedia (para microfone e câmera)
+- Shadow DOM
+- Canvas 2D (para renderização de vídeo)
+- WebCodecs API (opcional, para renderização acelerada por hardware)
+
+## Licença
+
+Proprietary - Four Pixel IT

package/dist/core/AudioEngine.d.ts

@@ -0,0 +1,25 @@
+export type OnMicData = (pcmInt16: ArrayBuffer) => void;
+export type OnAudioLevel = (level: number) => void;
+export declare class AudioEngine {
+    private playbackCtx;
+    private micCtx;
+    private micStream;
+    private micProcessor;
+    private micSource;
+    private nextPlayTime;
+    private sampleRate;
+    private destroyed;
+    onMicData: OnMicData;
+    onAudioLevel: OnAudioLevel;
+    constructor(sampleRate?: number);
+    /** Play received PCM Int16LE audio */
+    private playLogCount;
+    playPcm(data: ArrayBuffer): void;
+    /** Start capturing microphone audio and sending as PCM Int16LE */
+    startMic(): Promise<void>;
+    stopMic(): void;
+    /** Resume AudioContext (must be called from user gesture for autoplay policy) */
+    resume(): void;
+    destroy(): void;
+}
+//# sourceMappingURL=AudioEngine.d.ts.map

package/dist/core/AudioEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioEngine.d.ts","sourceRoot":"","sources":["../../src/core/AudioEngine.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,SAAS,GAAG,CAAC,QAAQ,EAAE,WAAW,KAAK,IAAI,CAAC;AACxD,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;AAEnD,qBAAa,WAAW;IACtB,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,SAAS,CAA4B;IAC7C,OAAO,CAAC,YAAY,CAAoC;IACxD,OAAO,CAAC,SAAS,CAA2C;IAC5D,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,SAAS,CAAS;IAE1B,SAAS,EAAE,SAAS,CAAY;IAChC,YAAY,EAAE,YAAY,CAAY;gBAE1B,UAAU,SAAQ;IAI9B,sCAAsC;IACtC,OAAO,CAAC,YAAY,CAAK;IAEzB,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAgDhC,kEAAkE;IAC5D,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IA6B/B,OAAO,IAAI,IAAI;IAqBf,iFAAiF;IACjF,MAAM,IAAI,IAAI;IAUd,OAAO,IAAI,IAAI;CAQhB"}

package/dist/core/CallState.d.ts

@@ -0,0 +1,15 @@
+import type { CallInfo, CallState } from '../types';
+export declare class CallStateManager {
+    private calls;
+    addCall(call: CallInfo): void;
+    updateState(callId: string, state: CallState): void;
+    updateIsVideo(callId: string, isVideo: boolean): void;
+    removeCall(callId: string): void;
+    getCall(callId: string): CallInfo | undefined;
+    getActiveCall(): CallInfo | undefined;
+    getRingingCalls(): CallInfo[];
+    getAllCalls(): CallInfo[];
+    hasActiveCalls(): boolean;
+    clear(): void;
+}
+//# sourceMappingURL=CallState.d.ts.map

package/dist/core/CallState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CallState.d.ts","sourceRoot":"","sources":["../../src/core/CallState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAEpD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,KAAK,CAA+B;IAE5C,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAI7B,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI;IASnD,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAOrD,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAIhC,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAI7C,aAAa,IAAI,QAAQ,GAAG,SAAS;IASrC,eAAe,IAAI,QAAQ,EAAE;IAU7B,WAAW,IAAI,QAAQ,EAAE;IAIzB,cAAc,IAAI,OAAO;IAOzB,KAAK,IAAI,IAAI;CAGd"}

package/dist/core/CallWebSocket.d.ts

@@ -0,0 +1,29 @@
+import type { WsServerMessage } from '../types';
+export type OnJsonMessage = (msg: WsServerMessage) => void;
+export type OnBinaryMessage = (data: ArrayBuffer) => void;
+export type OnConnectionChange = (connected: boolean) => void;
+export declare class CallWebSocket {
+    private ws;
+    private baseUrl;
+    private instanceId;
+    private getToken;
+    private reconnectMs;
+    private reconnectTimer;
+    private pingTimer;
+    private destroyed;
+    onJson: OnJsonMessage;
+    onBinary: OnBinaryMessage;
+    onConnectionChange: OnConnectionChange;
+    constructor(baseUrl: string, instanceId: string, getToken: () => Promise<string>);
+    private buildUrl;
+    connect(): Promise<void>;
+    send(data: string | ArrayBuffer): void;
+    sendJson(msg: Record<string, unknown>): void;
+    isConnected(): boolean;
+    destroy(): void;
+    private cleanup;
+    private scheduleReconnect;
+    private startPing;
+    private stopPing;
+}
+//# sourceMappingURL=CallWebSocket.d.ts.map

package/dist/core/CallWebSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CallWebSocket.d.ts","sourceRoot":"","sources":["../../src/core/CallWebSocket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,eAAe,KAAK,IAAI,CAAC;AAC3D,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC;AAC1D,MAAM,MAAM,kBAAkB,GAAG,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;AAM9D,qBAAa,aAAa;IACxB,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,SAAS,CAA+C;IAChE,OAAO,CAAC,SAAS,CAAS;IAE1B,MAAM,EAAE,aAAa,CAAY;IACjC,QAAQ,EAAE,eAAe,CAAY;IACrC,kBAAkB,EAAE,kBAAkB,CAAY;gBAEtC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC;IAMhF,OAAO,CAAC,QAAQ;IASV,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAyD9B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAMtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI5C,WAAW,IAAI,OAAO;IAItB,OAAO,IAAI,IAAI;IASf,OAAO,CAAC,OAAO;IAcf,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,QAAQ;CAMjB"}

package/dist/core/EventEmitter.d.ts

@@ -0,0 +1,12 @@
+type Listener = (...args: any[]) => void;
+export declare class EventEmitter<Events extends {
+    [K in keyof Events]: Listener;
+}> {
+    private listeners;
+    on<K extends keyof Events>(event: K, listener: Events[K]): this;
+    off<K extends keyof Events>(event: K, listener: Events[K]): this;
+    protected emit<K extends keyof Events>(event: K, ...args: Parameters<Events[K]>): void;
+    removeAllListeners(): void;
+}
+export {};
+//# sourceMappingURL=EventEmitter.d.ts.map

package/dist/core/EventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmitter.d.ts","sourceRoot":"","sources":["../../src/core/EventEmitter.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;AAEzC,qBAAa,YAAY,CAAC,MAAM,SAAS;KAAG,CAAC,IAAI,MAAM,MAAM,GAAG,QAAQ;CAAE;IACxE,OAAO,CAAC,SAAS,CAA0C;IAE3D,EAAE,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI;IAQ/D,GAAG,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI;IAKhE,SAAS,CAAC,IAAI,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAYtF,kBAAkB,IAAI,IAAI;CAG3B"}