Events

1
import { RelayClient, CallStateEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleState = (event: CallStateEvent) => {
11
    console.log(`Call state: ${event.callState}`);
12
  };
13
14
  call.on('calling.call.state', handleState);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayEvent } from '@signalwire/sdk';
2
3
const event = RelayEvent.fromPayload({
4
  event_type: 'calling.call.state',
5
  params: { call_state: 'answered' },
6
});
7
console.log(event.eventType); // "calling.call.state"

1
import { parseEvent, PlayEvent } from '@signalwire/sdk';
2
3
const event = parseEvent({
4
  event_type: 'calling.call.play',
5
  params: { control_id: 'abc-123', state: 'playing' },
6
});
7
// Returns a PlayEvent instance — narrow the type to access subclass properties
8
if (event instanceof PlayEvent) {
9
  console.log(event.state); // "playing"
10
}

1
import { RelayClient, CallStateEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleState = (event: CallStateEvent) => {
11
    console.log(`State: ${event.callState}, reason: ${event.endReason}`);
12
  };
13
14
  call.on('calling.call.state', handleState);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, PlayEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handlePlay = (event: PlayEvent) => {
11
    console.log(`Playback: ${event.state}`);
12
  };
13
14
  call.on('calling.call.play', handlePlay);
15
  await call.answer();
16
  await call.play([{ type: 'tts', text: 'Hello!' }]);
17
});
18
19
await client.run();

1
import { RelayClient, RecordEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleRecord = (event: RecordEvent) => {
11
    console.log(`Recording ${event.state}: ${event.url}`);
12
  };
13
14
  call.on('calling.call.record', handleRecord);
15
  await call.answer();
16
  await call.record({ direction: 'both' });
17
});
18
19
await client.run();

1
import { RelayClient, CollectEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleCollect = (event: CollectEvent) => {
11
    console.log(`Collected: ${JSON.stringify(event.result)}`);
12
  };
13
14
  call.on('calling.call.collect', handleCollect);
15
  await call.answer();
16
  await call.playAndCollect(
17
    [{ type: 'tts', text: 'Press 1 or 2.' }],
18
    { digits: { max: 1 } }
19
  );
20
});
21
22
await client.run();

1
import { RelayClient, ConnectEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleConnect = (event: ConnectEvent) => {
11
    console.log(`Connection: ${event.connectState}`);
12
  };
13
14
  call.on('calling.call.connect', handleConnect);
15
  await call.answer();
16
  await call.connect(
17
    [[{ type: 'phone', params: { to_number: '+15559876543', from_number: '+15551234567' } }]]
18
  );
19
});
20
21
await client.run();

1
import { RelayClient, DetectEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleDetect = (event: DetectEvent) => {
11
    console.log(`Detected: ${JSON.stringify(event.detect)}`);
12
  };
13
14
  call.on('calling.call.detect', handleDetect);
15
  await call.answer();
16
  await call.detect({ type: 'machine', params: { initial_timeout: 5.0 } });
17
});
18
19
await client.run();

1
import { RelayClient, FaxEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleFax = (event: FaxEvent) => {
11
    console.log(`Fax: ${JSON.stringify(event.fax)}`);
12
  };
13
14
  call.on('calling.call.fax', handleFax);
15
  await call.answer();
16
  await call.sendFax('https://example.com/invoice.pdf');
17
});
18
19
await client.run();

1
import { RelayClient, TapEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleTap = (event: TapEvent) => {
11
    console.log(`Tap ${event.state}: ${JSON.stringify(event.tap)}`);
12
  };
13
14
  call.on('calling.call.tap', handleTap);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, StreamEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleStream = (event: StreamEvent) => {
11
    console.log(`Stream ${event.state}: ${event.url}`);
12
  };
13
14
  call.on('calling.call.stream', handleStream);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, SendDigitsEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleDigits = (event: SendDigitsEvent) => {
11
    console.log(`Send digits: ${event.state}`);
12
  };
13
14
  call.on('calling.call.send_digits', handleDigits);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, ReferEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleRefer = (event: ReferEvent) => {
11
    console.log(`Refer to ${event.sipReferTo}: ${event.state}`);
12
  };
13
14
  call.on('calling.call.refer', handleRefer);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, HoldEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleHold = (event: HoldEvent) => {
11
    console.log(`Hold: ${event.state}`);
12
  };
13
14
  call.on('calling.call.hold', handleHold);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, DenoiseEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleDenoise = (event: DenoiseEvent) => {
11
    console.log(`Denoise active: ${event.denoised}`);
12
  };
13
14
  call.on('calling.call.denoise', handleDenoise);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, PayEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handlePay = (event: PayEvent) => {
11
    console.log(`Payment: ${event.state}`);
12
  };
13
14
  call.on('calling.call.pay', handlePay);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, EchoEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleEcho = (event: EchoEvent) => {
11
    console.log(`Echo: ${event.state}`);
12
  };
13
14
  call.on('calling.call.echo', handleEcho);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, QueueEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleQueue = (event: QueueEvent) => {
11
    console.log(`Queue ${event.queueName}: position ${event.position}/${event.size}`);
12
  };
13
14
  call.on('calling.call.queue', handleQueue);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, ConferenceEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleConference = (event: ConferenceEvent) => {
11
    console.log(`Conference ${event.name}: ${event.status}`);
12
  };
13
14
  call.on('calling.conference', handleConference);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, TranscribeEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleTranscribe = (event: TranscribeEvent) => {
11
    console.log(`Transcription ${event.state}: ${event.url}`);
12
  };
13
14
  call.on('calling.call.transcribe', handleTranscribe);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, CallingErrorEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onCall(async (call) => {
10
  const handleError = (event: CallingErrorEvent) => {
11
    console.log(`Error ${event.code}: ${event.message}`);
12
  };
13
14
  call.on('calling.error', handleError);
15
  await call.answer();
16
});
17
18
await client.run();

1
import { RelayClient, MessageStateEvent } from '@signalwire/sdk';
2
3
const client = new RelayClient({
4
  project: process.env.SIGNALWIRE_PROJECT_ID!,
5
  token: process.env.SIGNALWIRE_API_TOKEN!,
6
  contexts: ['default']
7
});
8
9
client.onMessage(async (message) => {
10
  const handleState = (event: MessageStateEvent) => {
11
    console.log(`Message ${event.messageId}: ${event.messageState}`);
12
  };
13
14
  message.on(handleState);
15
});
16
17
await client.run();