@signalwire/js 3.28.0 → 3.28.1

package/src/fabric/interfaces/capabilities.ts

@@ -0,0 +1,30 @@
+
+export interface CapabilityOnOffStateContract {
+  on: boolean
+  off: boolean
+}
+
+export interface MemberCapabilityContract {
+  muteAudio: CapabilityOnOffStateContract
+  muteVideo: CapabilityOnOffStateContract
+  microphoneVolume: boolean
+  microphoneSensitivity: boolean
+  speakerVolume: boolean
+  deaf: CapabilityOnOffStateContract
+  raisehand: CapabilityOnOffStateContract
+  position: boolean
+  meta: boolean
+  remove: boolean
+}
+
+export interface CallCapabilitiesContract {
+  self: MemberCapabilityContract
+  member: MemberCapabilityContract
+  end: boolean
+  setLayout: boolean
+  sendDigit: boolean
+  vmutedHide: CapabilityOnOffStateContract
+  lock: CapabilityOnOffStateContract
+  device: boolean
+  screenshare: boolean
+}

package/src/fabric/interfaces/conversation.ts

@@ -49,20 +49,21 @@ export type GetConversationsResponse = PaginatedResponse<ConversationResponse>
 
 export type GetConversationsResult = PaginatedResult<ConversationContract>
 
-export type CoversationSubscribeCallback = (
+export type ConversationSubscribeCallback = (
   event: ConversationEventParams
 ) => unknown
 
-export interface CoversationSubscribeResult {
+export interface ConversationSubscribeResult {
   unsubscribe: () => void
 }
 
 export interface ConversationChatMessagesSubscribeParams {
   addressId: string
-  onMessage: CoversationSubscribeCallback
+  onMessage: ConversationSubscribeCallback
 }
 
-export type ConversationChatMessagesSubscribeResult = CoversationSubscribeResult
+export type ConversationChatMessagesSubscribeResult =
+  ConversationSubscribeResult
 
 export interface JoinConversationParams {
   addressId: string

package/src/fabric/interfaces/index.ts

@@ -76,6 +76,7 @@ export type GetSubscriberInfoResult = GetSubscriberInfoResponse
 
 // #endregion Subscriber info
 
+export * from './capabilities'
 export * from './address'
 export * from './conversation'
 export * from './device'
@@ -90,4 +91,4 @@ export type {
   ConversationMessageEvent,
   ConversationEvent,
   ConversationEventParams,
-} from '@signalwire/core'
+} from '@signalwire/core'

package/src/fabric/interfaces/wsClient.ts

@@ -85,11 +85,11 @@ export interface CallParams {
   disableUdpIceServers?: boolean
   /** Audio constraints to use when joining the room. Default: `true`. */
   audio?: MediaStreamConstraints['audio']
-  /** Video constraints to use when joining the room. Default: `true`. */
+  /** Video constraints to use when joining the room. Default: `true` for "video" channel. */
   video?: MediaStreamConstraints['video']
   /** Negotiate the incoming audio from the RTC. Default: `true`. */
   negotiateAudio?: boolean
-  /** Negotiate the incoming video from the RTC. Default: `true`. */
+  /** Negotiate the incoming video from the RTC. Default: `true` for "video" channel. */
   negotiateVideo?: boolean
   /** User & UserAgent metadata */
   userVariables?: WSClientOptions['userVariables']

package/src/fabric/utils/capabilitiesHelpers.test.ts

@@ -0,0 +1,201 @@
+import { stripNamespacePrefix } from "@signalwire/core"
+import { mapCapabilityPayload } from "./capabilitiesHelpers"
+
+describe('eventUtils', () => {
+  describe('stripNamespacePrefix', () => {
+    it('should strip first word before dot', () => {
+      const event1 = 'random.event.foo'
+      const event2 = 'random.event.bar'
+      expect(stripNamespacePrefix(event1)).toBe('event.foo')
+      expect(stripNamespacePrefix(event2)).toBe('event.bar')
+    })
+
+    it('should not strip if there is no dot', () => {
+      const event1 = 'randomeventfoo'
+      const event2 = 'randomeventbar'
+      expect(stripNamespacePrefix(event1)).toBe('randomeventfoo')
+      expect(stripNamespacePrefix(event2)).toBe('randomeventbar')
+    })
+
+    it('should strip the namespace if passed', () => {
+      const event1 = 'video.event.foo'
+      const event2 = 'voice.event.bar'
+      expect(stripNamespacePrefix(event1, 'video')).toBe('event.foo')
+      expect(stripNamespacePrefix(event2, 'voice')).toBe('event.bar')
+    })
+  })
+
+  describe('mapCapabilitiesPayload', () => {
+    it('should have all capabilities', () => {
+      const callCapabilities = mapCapabilityPayload([
+        'self',
+        'member',
+        'device',
+        'screenshare',
+        'lock',
+        'end',
+        'vmuted',
+        'layout',
+        'digit',
+        'lock',
+      ])
+      expect(callCapabilities.member?.deaf?.on).toEqual(true)
+      expect(callCapabilities.member?.deaf?.off).toEqual(true)
+      expect(callCapabilities.member?.raisehand?.on).toEqual(true)
+      expect(callCapabilities.member?.raisehand?.off).toEqual(true)
+      expect(callCapabilities.member?.muteVideo?.on).toEqual(true)
+      expect(callCapabilities.member?.muteVideo?.off).toEqual(true)
+      expect(callCapabilities.member?.muteAudio?.on).toEqual(true)
+      expect(callCapabilities.member?.muteAudio?.off).toEqual(true)
+      expect(callCapabilities.member?.meta).toEqual(true)
+      expect(callCapabilities.member?.position).toEqual(true)
+      expect(callCapabilities.member?.remove).toEqual(true)
+      expect(callCapabilities.member?.microphoneSensitivity).toEqual(true)
+      expect(callCapabilities.member?.microphoneVolume).toEqual(true)
+      expect(callCapabilities.member?.speakerVolume).toEqual(true)
+
+      expect(callCapabilities.self?.deaf?.on).toEqual(true)
+      expect(callCapabilities.self?.deaf?.off).toEqual(true)
+      expect(callCapabilities.self?.raisehand?.on).toEqual(true)
+      expect(callCapabilities.self?.raisehand?.off).toEqual(true)
+      expect(callCapabilities.self?.muteVideo?.on).toEqual(true)
+      expect(callCapabilities.self?.muteVideo?.off).toEqual(true)
+      expect(callCapabilities.self?.muteAudio?.on).toEqual(true)
+      expect(callCapabilities.self?.muteAudio?.off).toEqual(true)
+      expect(callCapabilities.self?.meta).toEqual(true)
+      expect(callCapabilities.self?.position).toEqual(true)
+      expect(callCapabilities.self?.remove).toEqual(true)
+      expect(callCapabilities.self?.microphoneSensitivity).toEqual(true)
+      expect(callCapabilities.self?.microphoneVolume).toEqual(true)
+      expect(callCapabilities.self?.speakerVolume).toEqual(true)
+
+      expect(callCapabilities.device).toEqual(true)
+      expect(callCapabilities.screenshare).toEqual(true)
+      expect(callCapabilities.sendDigit).toEqual(true)
+      expect(callCapabilities.setLayout).toEqual(true)
+      expect(callCapabilities.end).toEqual(true)
+      expect(callCapabilities.lock?.on).toEqual(true)
+      expect(callCapabilities.lock?.off).toEqual(true)
+      expect(callCapabilities.vmutedHide?.on).toEqual(true)
+      expect(callCapabilities.vmutedHide?.off).toEqual(true)
+    })
+
+    it('should have some self capabilities and others member capabilities', () => {
+      const callCapabilities = mapCapabilityPayload([
+        'member.deaf',
+        'member.mute.video',
+        'member.mute.audio.on',
+        'self.remove',
+        'self.microphone',
+      ])
+      expect(callCapabilities.member?.deaf?.on).toEqual(true)
+      expect(callCapabilities.member?.deaf?.off).toEqual(true)
+      expect(callCapabilities.member?.raisehand?.on).toEqual(true)
+      expect(callCapabilities.member?.raisehand?.off).toEqual(true)
+      expect(callCapabilities.member?.muteVideo?.on).toEqual(true)
+      expect(callCapabilities.member?.muteVideo?.off).toEqual(true)
+      expect(callCapabilities.member?.muteAudio?.on).toEqual(true)
+      expect(callCapabilities.member?.muteAudio?.off).toBeFalsy()
+      expect(callCapabilities.member?.meta).toBeFalsy()
+      expect(callCapabilities.member?.position).toBeFalsy()
+      expect(callCapabilities.member?.remove).toBeFalsy()
+      expect(callCapabilities.member?.microphoneSensitivity).toBeFalsy()
+      expect(callCapabilities.member?.microphoneVolume).toBeFalsy()
+      expect(callCapabilities.member?.speakerVolume).toBeFalsy()
+
+      expect(callCapabilities.self?.deaf?.on).toBeFalsy()
+      expect(callCapabilities.self?.deaf?.off).toBeFalsy()
+      expect(callCapabilities.self?.raisehand?.on).toEqual(true)
+      expect(callCapabilities.self?.raisehand?.off).toEqual(true)
+      expect(callCapabilities.self?.muteVideo?.on).toBeFalsy()
+      expect(callCapabilities.self?.muteVideo?.off).toBeFalsy()
+      expect(callCapabilities.self?.muteAudio?.on).toBeFalsy()
+      expect(callCapabilities.self?.muteAudio?.off).toBeFalsy()
+      expect(callCapabilities.self?.meta).toBeFalsy()
+      expect(callCapabilities.self?.position).toBeFalsy()
+      expect(callCapabilities.self?.remove).toEqual(true)
+      expect(callCapabilities.self?.microphoneSensitivity).toEqual(true)
+      expect(callCapabilities.self?.microphoneVolume).toEqual(true)
+      expect(callCapabilities.self?.speakerVolume).toBeFalsy()
+
+      expect(callCapabilities.device).toBeFalsy()
+      expect(callCapabilities.screenshare).toBeFalsy()
+      expect(callCapabilities.sendDigit).toBeFalsy()
+      expect(callCapabilities.setLayout).toBeFalsy()
+      expect(callCapabilities.end).toBeFalsy()
+      expect(callCapabilities.lock?.on).toBeFalsy()
+      expect(callCapabilities.lock?.off).toBeFalsy()
+      expect(callCapabilities.vmutedHide?.on).toBeFalsy()
+      expect(callCapabilities.vmutedHide?.off).toBeFalsy()
+    })
+
+    it('should have some both on and off', () => {
+      const callCapabilities = mapCapabilityPayload([
+        'member.mute.video',
+        'member.mute.audio.on',
+        'member.mute.audio.off',
+      ])
+      expect(callCapabilities.member?.muteVideo?.on).toEqual(true)
+      expect(callCapabilities.member?.muteVideo?.off).toEqual(true)
+      expect(callCapabilities.member?.muteAudio?.on).toEqual(true)
+      expect(callCapabilities.member?.muteAudio?.off).toEqual(true)
+    })
+  })
+
+  it('should not break if the server send redundant capability', () => {
+    const callCapabilities = mapCapabilityPayload([
+      'self',
+      'self.deaf',
+      'self.mute.audio',
+      'self.mute.audio.on',
+      'member',
+      'device',
+      'screenshare',
+      'lock',
+      'end',
+      'vmuted',
+      'layout',
+      'digit',
+      'lock',
+    ])
+    expect(callCapabilities.member?.deaf?.on).toEqual(true)
+    expect(callCapabilities.member?.deaf?.off).toEqual(true)
+    expect(callCapabilities.member?.raisehand?.on).toEqual(true)
+    expect(callCapabilities.member?.raisehand?.off).toEqual(true)
+    expect(callCapabilities.member?.muteVideo?.on).toEqual(true)
+    expect(callCapabilities.member?.muteVideo?.off).toEqual(true)
+    expect(callCapabilities.member?.muteAudio?.on).toEqual(true)
+    expect(callCapabilities.member?.muteAudio?.off).toEqual(true)
+    expect(callCapabilities.member?.meta).toEqual(true)
+    expect(callCapabilities.member?.position).toEqual(true)
+    expect(callCapabilities.member?.remove).toEqual(true)
+    expect(callCapabilities.member?.microphoneSensitivity).toEqual(true)
+    expect(callCapabilities.member?.microphoneVolume).toEqual(true)
+    expect(callCapabilities.member?.speakerVolume).toEqual(true)
+
+    expect(callCapabilities.self?.deaf?.on).toEqual(true)
+    expect(callCapabilities.self?.deaf?.off).toEqual(true)
+    expect(callCapabilities.self?.raisehand?.on).toEqual(true)
+    expect(callCapabilities.self?.raisehand?.off).toEqual(true)
+    expect(callCapabilities.self?.muteVideo?.on).toEqual(true)
+    expect(callCapabilities.self?.muteVideo?.off).toEqual(true)
+    expect(callCapabilities.self?.muteAudio?.on).toEqual(true)
+    expect(callCapabilities.self?.muteAudio?.off).toEqual(true)
+    expect(callCapabilities.self?.meta).toEqual(true)
+    expect(callCapabilities.self?.position).toEqual(true)
+    expect(callCapabilities.self?.remove).toEqual(true)
+    expect(callCapabilities.self?.microphoneSensitivity).toEqual(true)
+    expect(callCapabilities.self?.microphoneVolume).toEqual(true)
+    expect(callCapabilities.self?.speakerVolume).toEqual(true)
+
+    expect(callCapabilities.device).toEqual(true)
+    expect(callCapabilities.screenshare).toEqual(true)
+    expect(callCapabilities.sendDigit).toEqual(true)
+    expect(callCapabilities.setLayout).toEqual(true)
+    expect(callCapabilities.end).toEqual(true)
+    expect(callCapabilities.lock?.on).toEqual(true)
+    expect(callCapabilities.lock?.off).toEqual(true)
+    expect(callCapabilities.vmutedHide?.on).toEqual(true)
+    expect(callCapabilities.vmutedHide?.off).toEqual(true)
+  })
+})

package/src/fabric/utils/capabilitiesHelpers.ts

@@ -0,0 +1,190 @@
+import { CallCapabilitiesContract, CapabilityOnOffStateContract, MemberCapabilityContract } from "../interfaces/capabilities"
+
+class CapabilityOnOffState implements CapabilityOnOffStateContract {
+  constructor(private _flags: string[]) { }
+
+  get on() {
+    return this._flags.some((flag) => !flag.endsWith('.off'))
+  }
+
+  get off() {
+    return this._flags.some((flag) => !flag.endsWith('.on'))
+  }
+}
+
+class MemberCapability implements MemberCapabilityContract {
+  private _muteAudio?: CapabilityOnOffState
+  private _muteVideo?: CapabilityOnOffState
+  private _deaf?: CapabilityOnOffState
+  
+  constructor(
+    private _flags: string[],
+    private _memberType: 'self' | 'member'
+  ) { }
+
+  get muteAudio() {
+    this._muteAudio =
+      this._muteAudio ??
+      new CapabilityOnOffState(
+        this._flags.filter(
+          (flag) => flag === this._memberType ||
+            flag === `${this._memberType}.mute` ||
+            flag.startsWith(`${this._memberType}.mute.audio`)
+        )
+      )
+    return this._muteAudio
+  }
+
+  get muteVideo() {
+    this._muteVideo =
+      this._muteVideo ??
+      new CapabilityOnOffState(
+        this._flags.filter(
+          (flag) => flag === this._memberType ||
+            flag === `${this._memberType}.mute` ||
+            flag.startsWith(`${this._memberType}.mute.video`)
+        )
+      )
+    return this._muteVideo
+  }
+
+  get microphoneVolume() {
+    return this._flags.some(
+      (flag) => flag === this._memberType ||
+        flag === `${this._memberType}.microphone` ||
+        flag.startsWith(`${this._memberType}.microphone.volume`)
+    )
+  }
+
+  get microphoneSensitivity() {
+    return this._flags.some(
+      (flag) => flag === this._memberType ||
+        flag === `${this._memberType}.microphone` ||
+        flag.startsWith(`${this._memberType}.microphone.sensitivity`)
+    )
+  }
+
+  get speakerVolume() {
+    return this._flags.some(
+      (flag) => flag === this._memberType ||
+        flag === `${this._memberType}.speaker` ||
+        flag.startsWith(`${this._memberType}.speaker.volume`)
+    )
+  }
+
+  get deaf() {
+    this._deaf =
+      this._deaf ??
+      new CapabilityOnOffState(
+        this._flags.filter(
+          (flag) => flag === this._memberType ||
+            flag.startsWith(`${this._memberType}.deaf`)
+        )
+      )
+    return this._deaf
+  }
+
+  get raisehand() {
+    return {
+      on: true,
+      off: true
+    }
+    // TODO: uncomment once the server add this capability 
+    // this._raisehand =
+    //   this._raisehand ??
+    //   new CapabilityOnOffState(
+    //     this._flags.filter(
+    //       (flag) => flag === this._memberType ||
+    //         flag.startsWith(`${this._memberType}.raisehand`)
+    //     )
+    //   )
+    // return this._raisehand
+  }
+
+  get position() {
+    return this._flags.some(
+      (flag) => flag === this._memberType ||
+        flag.startsWith(`${this._memberType}.position`)
+    )
+  }
+
+  get meta() {
+    return this._flags.some(
+      (flag) => flag === this._memberType || flag.startsWith(`${this._memberType}.meta`)
+    )
+  }
+
+  get remove() {
+    return this._flags.some(
+      (flag) => flag === this._memberType ||
+        flag.startsWith(`${this._memberType}.remove`)
+    )
+  }
+}
+
+export class CallCapabilities implements CallCapabilitiesContract {
+  private _self?: MemberCapabilityContract
+  private _member?: MemberCapabilityContract
+  private _vmutedHide?: CapabilityOnOffState
+  private _lock?: CapabilityOnOffState
+
+  constructor(private _flags: string[]) { }
+
+  private _buildMemberCapability(memberType: 'self' | 'member') {
+    return new MemberCapability(
+      this._flags.filter((flag) => flag.startsWith(memberType)),
+      memberType
+    )
+  }
+
+  get self() {
+    this._self = this._self ?? this._buildMemberCapability('self')
+    return this._self
+  }
+
+  get member() {
+    this._member = this._member ?? this._buildMemberCapability('member')
+    return this._member
+  }
+
+  get end() {
+    return this._flags.some((capability) => capability === 'end')
+  }
+
+  get setLayout() {
+    return this._flags.some((capability) => capability.startsWith('layout'))
+  }
+
+  get sendDigit() {
+    return this._flags.some((capability) => capability.startsWith('digit'))
+  }
+
+  get vmutedHide() {
+    this._vmutedHide =
+      this._vmutedHide ??
+      new CapabilityOnOffState(
+        this._flags.filter((flag) => flag.startsWith('vmuted'))
+      )
+    return this._vmutedHide
+  }
+
+  get lock() {
+    this._lock =
+      this._lock ??
+      new CapabilityOnOffState(
+        this._flags.filter((flag) => flag.startsWith('lock'))
+      )
+    return this._lock
+  }
+
+  get device() {
+    return this._flags.some((capability) => capability === 'device')
+  }
+
+  get screenshare() {
+    return this._flags.some((capability) => capability === 'screenshare')
+  }
+}
+
+export const mapCapabilityPayload = (capabilities: string[]) =>
+    new CallCapabilities(capabilities)

package/src/fabric/workers/callJoinWorker.ts

@@ -4,7 +4,6 @@ import {
   CallJoinedEvent,
   sagaEffects,
   MemberPosition,
-  mapCapabilityPayload,
   stripNamespacePrefix,
 } from '@signalwire/core'
 import {
@@ -14,6 +13,7 @@ import {
 import { FabricWorkerParams } from './fabricWorker'
 import { fabricMemberWorker } from './fabricMemberWorker'
 import { mapCallJoinedToRoomSubscribedEventParams } from '../utils/helpers'
+import { mapCapabilityPayload } from '../utils/capabilitiesHelpers'
 
 export const callJoinWorker = function* (
   options: FabricWorkerParams<CallJoinedEvent>
@@ -74,14 +74,15 @@ export const callJoinWorker = function* (
   })
 
   cfRoomSession.member = get<FabricRoomSessionMember>(payload.member_id)
-  cfRoomSession.capabilities = mapCapabilityPayload(payload.capabilities || [])
+  // the server send the capabilities payload as an array of string
+  cfRoomSession.capabilities = mapCapabilityPayload(payload.capabilities)
 
-  // FIXME: Capabilities type is incompatible.
-  // @ts-expect-error
-  cfRoomSession.emit('call.joined', {
+  const fabricEvent = {
     ...payload,
     capabilities: cfRoomSession.capabilities,
-  })
+  }
+
+  cfRoomSession.emit('call.joined', fabricEvent)
 
   getLogger().trace('callJoinWorker ended')
 }

package/src/fabric/workers/wsClientWorker.ts

@@ -21,23 +21,46 @@ export type WSClientWorkerHooks = SDKWorkerHooks<
 export const wsClientWorker: SDKWorker<WSClient, WSClientWorkerHooks> =
   function* (options): SagaIterator {
     getLogger().debug('wsClientWorker started')
-    const { channels, initialState } = options
+    const { channels, initialState, instance: client } = options
     const { swEventChannel } = channels
     const { handleIncomingInvite } = initialState
 
+    function* fireHoseWorker(action: SDKActions) {
+      // @ts-expect-error Emit all events - This is for internal usage
+      client.emit(action.type, action.payload)
+    }
+
+    function* vertoInviteWorker(action: MapToPubSubShape<WebRTCMessageParams>) {
+      // Invoke WSClient function to build and answer the invite
+      handleIncomingInvite(action.payload.params)
+    }
+
+    const isVertoInvite = (action: SDKActions) => {
+      if (action.type === 'webrtc.message') {
+        return action.payload.method === 'verto.invite'
+      }
+      return false
+    }
+
     try {
       while (true) {
-        const action: MapToPubSubShape<WebRTCMessageParams> =
-          yield sagaEffects.take(swEventChannel, (action: SDKActions) => {
-            if (action.type === 'webrtc.message') {
-              return action.payload.method === 'verto.invite'
-            }
-            return false
-          })
-        getLogger().debug('Receiving a new call over WebSocket', action)
-
-        // Invoke WSClient function to build and answer the invite
-        handleIncomingInvite(action.payload.params)
+        // Take all actions from the channel
+        const action: SDKActions = yield sagaEffects.take(
+          swEventChannel,
+          () => true
+        )
+
+        // Fire all the events with fireHoseWorker
+        yield sagaEffects.fork(fireHoseWorker, action)
+
+        // If the event is verto.invite, handle that with vertoInviteWorker
+        if (isVertoInvite(action)) {
+          getLogger().debug('Receiving a call over WebSocket', action)
+          yield sagaEffects.fork(
+            vertoInviteWorker,
+            action as MapToPubSubShape<WebRTCMessageParams>
+          )
+        }
       }
     } finally {
       getLogger().trace('wsClientWorker ended')

package/src/index.ts

@@ -108,7 +108,6 @@ export type {
   /**
    * Call Fabric types
    */
-  CallJoinedEventParams,
   CallUpdatedEventParams,
   CallLeftEventParams,
   CallStateEventParams,
@@ -136,6 +135,7 @@ export type {
 } from '@signalwire/webrtc'
 
 export type {
+  CallJoinedEventParams,
   RoomSessionObjectEventsHandlerMap,
   RoomSessionObjectEvents,
   // Just to keep backwards compatibility.

package/src/utils/interfaces/fabric.ts

@@ -14,7 +14,7 @@ import {
   VideoRoomDeviceDisconnectedEventNames,
   VideoRoomDeviceUpdatedEventNames,
   CallJoined,
-  CallJoinedEventParams,
+  CallJoinedEventParams as InternalCallJoinedEventParams,
   CallState,
   CallStateEventParams,
   CallUpdated,
@@ -41,7 +41,7 @@ import {
   CallRoomEventParams,
 } from '@signalwire/core'
 import { MediaEventNames } from '@signalwire/webrtc'
-import { FabricRoomSession } from '../../fabric'
+import { CallCapabilitiesContract, FabricRoomSession } from '../../fabric'
 
 export interface ExecuteActionParams {
   method: JSONRPCMethod
@@ -73,6 +73,10 @@ export type FabricMemberListUpdatedParams = {
   members: InternalFabricMemberEntity[]
 }
 
+export type CallJoinedEventParams = {
+  capabilities: CallCapabilitiesContract
+} & Omit<InternalCallJoinedEventParams, 'capabilities'>
+
 export type FabricRoomSessionEventsHandlerMap = Record<
   VideoRoomDeviceUpdatedEventNames,
   (params: DeviceUpdatedEventParams) => void
@@ -91,7 +95,10 @@ export type FabricRoomSessionEventsHandlerMap = Record<
   Record<CallPlay, (stream: CallPlayEventParams) => void> &
   Record<CallConnect, (stream: CallConnectEventParams) => void> &
   Record<CallRoom, (stream: CallRoomEventParams) => void> &
-  Record<RoomJoined | RoomSubscribed, (params: CallJoinedEventParams) => void> &
+  Record<
+    RoomJoined | RoomSubscribed,
+    (params: InternalCallJoinedEventParams) => void
+  > &
   Record<RoomUpdated, (params: CallUpdatedEventParams) => void> &
   Record<RoomLeft, (params?: CallLeftEventParams) => void> &
   Record<MemberJoined, (params: FabricMemberJoinedEventParams) => void> &

package/dist/core/src/utils/eventUtils.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=eventUtils.test.d.ts.map

package/dist/core/src/utils/eventUtils.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eventUtils.test.d.ts","sourceRoot":"","sources":["../../../../../core/src/utils/eventUtils.test.ts"],"names":[],"mappings":""}