npm - vue-parley - Versions diffs - 4.0.0 - Mend

vue-parley 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (202) hide show

package/dist/types/app/stores/callStore.d.ts ADDED Viewed

@@ -0,0 +1,1626 @@
+import { CallHandlers } from '../types';
+export declare const useCallStore: import('pinia').StoreDefinition<"call-modal", Pick<{
+    session: import('vue').ShallowRef<{
+        channel: string;
+        start: () => Promise<void>;
+        end: () => void;
+        toggleScreenShare: () => Promise<void>;
+        switchCamera: (deviceId: string) => Promise<{
+            readonly active: boolean;
+            readonly id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null>;
+        signaling: {
+            listen: (on: import('../composables/call/signaling').SignalingHandlers) => Promise<void>;
+            stop: () => void;
+            join: () => Promise<void>;
+            trackTypes: (types: import('../composables/call/signaling').TrackTypes) => Promise<void>;
+            signal: (to: string, signal: import('../types').SignalData) => Promise<void>;
+            ring: (channel: string, avatar?: string) => Promise<void>;
+            hangup: (channel: string) => Promise<void>;
+        };
+        media: {
+            localStream: globalThis.Ref<{
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStream | {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            screenStream: globalThis.Ref<{
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStream | {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            trackTypes: globalThis.Ref<{
+                id: string;
+                type: import('../types').TrackType;
+            }[], import('../composables/call/signaling').TrackTypes | {
+                id: string;
+                type: import('../types').TrackType;
+            }[]>;
+            videoTrack: globalThis.Ref<{
+                contentHint: string;
+                enabled: boolean;
+                readonly id: string;
+                readonly kind: string;
+                readonly label: string;
+                readonly muted: boolean;
+                onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                readonly readyState: MediaStreamTrackState;
+                applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+                clone: () => MediaStreamTrack;
+                getCapabilities: () => MediaTrackCapabilities;
+                getConstraints: () => MediaTrackConstraints;
+                getSettings: () => MediaTrackSettings;
+                stop: () => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStreamTrack | {
+                contentHint: string;
+                enabled: boolean;
+                readonly id: string;
+                readonly kind: string;
+                readonly label: string;
+                readonly muted: boolean;
+                onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                readonly readyState: MediaStreamTrackState;
+                applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+                clone: () => MediaStreamTrack;
+                getCapabilities: () => MediaTrackCapabilities;
+                getConstraints: () => MediaTrackConstraints;
+                getSettings: () => MediaTrackSettings;
+                stop: () => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            cameras: globalThis.Ref<{
+                readonly deviceId: string;
+                readonly groupId: string;
+                readonly kind: MediaDeviceKind;
+                readonly label: string;
+                toJSON: () => any;
+            }[], MediaDeviceInfo[] | {
+                readonly deviceId: string;
+                readonly groupId: string;
+                readonly kind: MediaDeviceKind;
+                readonly label: string;
+                toJSON: () => any;
+            }[]>;
+            isAudioOn: globalThis.Ref<boolean, boolean>;
+            isVideoOn: globalThis.Ref<boolean, boolean>;
+            isScreenSharing: globalThis.Ref<boolean, boolean>;
+            isFlashlightOn: globalThis.Ref<boolean, boolean>;
+            isFlashlightSupported: globalThis.ComputedRef<boolean>;
+            checkPermissions: () => Promise<void>;
+            start: () => Promise<void>;
+            toggleAudio: () => void;
+            toggleVideo: () => void;
+            switchCamera: (deviceId: string) => Promise<MediaStreamTrack | null>;
+            startScreenShare: (onEnded: () => void) => Promise<MediaStream | null>;
+            stopScreenShare: () => {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null;
+            toggleFlashlight: () => Promise<void>;
+            stopAll: () => void;
+        };
+        peers: {
+            peers: globalThis.Ref<Record<string, {
+                signal(data: import('../types').SignalData): void;
+                addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                removeTrack(track: MediaStreamTrack): void;
+                replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                isSending(track: MediaStreamTrack): boolean;
+                destroy: () => void;
+            }>, Record<string, {
+                signal(data: import('../types').SignalData): void;
+                addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                removeTrack(track: MediaStreamTrack): void;
+                replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                isSending(track: MediaStreamTrack): boolean;
+                destroy: () => void;
+            }>>;
+            remoteVideos: globalThis.Ref<Record<string, import('../composables/call/peers').RemoteStream>, Record<string, import('../composables/call/peers').RemoteStream>>;
+            remoteScreens: globalThis.Ref<Record<string, import('../composables/call/peers').RemoteStream>, Record<string, import('../composables/call/peers').RemoteStream>>;
+            remoteStreamTypes: globalThis.Ref<Record<string, import('../composables/call/signaling').TrackTypes>, Record<string, import('../composables/call/signaling').TrackTypes>>;
+            isInitiator: (remoteId: string) => boolean;
+            has: (remoteId: string) => boolean;
+            add: (remoteId: string, name: string) => void;
+            remove: (remoteId: string) => void;
+            signal: (remoteId: string, name: string, data: import('../types').SignalData & {
+                sdp: string;
+            }) => void;
+            addTrackToAll: (track: MediaStreamTrack, stream: MediaStream) => void;
+            removeTrackFromAll: (track: MediaStreamTrack) => void;
+            replaceVideoTrack: (track: MediaStreamTrack, stream: MediaStream) => void;
+            destroyAll: () => void;
+        };
+        participantCount: globalThis.ComputedRef<number>;
+        tileCount: globalThis.ComputedRef<number>;
+    } | null, {
+        channel: string;
+        start: () => Promise<void>;
+        end: () => void;
+        toggleScreenShare: () => Promise<void>;
+        switchCamera: (deviceId: string) => Promise<{
+            readonly active: boolean;
+            readonly id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null>;
+        signaling: {
+            listen: (on: import('../composables/call/signaling').SignalingHandlers) => Promise<void>;
+            stop: () => void;
+            join: () => Promise<void>;
+            trackTypes: (types: import('../composables/call/signaling').TrackTypes) => Promise<void>;
+            signal: (to: string, signal: import('../types').SignalData) => Promise<void>;
+            ring: (channel: string, avatar?: string) => Promise<void>;
+            hangup: (channel: string) => Promise<void>;
+        };
+        media: {
+            localStream: globalThis.Ref<{
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStream | {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            screenStream: globalThis.Ref<{
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStream | {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            trackTypes: globalThis.Ref<{
+                id: string;
+                type: import('../types').TrackType;
+            }[], import('../composables/call/signaling').TrackTypes | {
+                id: string;
+                type: import('../types').TrackType;
+            }[]>;
+            videoTrack: globalThis.Ref<{
+                contentHint: string;
+                enabled: boolean;
+                readonly id: string;
+                readonly kind: string;
+                readonly label: string;
+                readonly muted: boolean;
+                onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                readonly readyState: MediaStreamTrackState;
+                applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+                clone: () => MediaStreamTrack;
+                getCapabilities: () => MediaTrackCapabilities;
+                getConstraints: () => MediaTrackConstraints;
+                getSettings: () => MediaTrackSettings;
+                stop: () => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStreamTrack | {
+                contentHint: string;
+                enabled: boolean;
+                readonly id: string;
+                readonly kind: string;
+                readonly label: string;
+                readonly muted: boolean;
+                onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                readonly readyState: MediaStreamTrackState;
+                applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+                clone: () => MediaStreamTrack;
+                getCapabilities: () => MediaTrackCapabilities;
+                getConstraints: () => MediaTrackConstraints;
+                getSettings: () => MediaTrackSettings;
+                stop: () => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            cameras: globalThis.Ref<{
+                readonly deviceId: string;
+                readonly groupId: string;
+                readonly kind: MediaDeviceKind;
+                readonly label: string;
+                toJSON: () => any;
+            }[], MediaDeviceInfo[] | {
+                readonly deviceId: string;
+                readonly groupId: string;
+                readonly kind: MediaDeviceKind;
+                readonly label: string;
+                toJSON: () => any;
+            }[]>;
+            isAudioOn: globalThis.Ref<boolean, boolean>;
+            isVideoOn: globalThis.Ref<boolean, boolean>;
+            isScreenSharing: globalThis.Ref<boolean, boolean>;
+            isFlashlightOn: globalThis.Ref<boolean, boolean>;
+            isFlashlightSupported: globalThis.ComputedRef<boolean>;
+            checkPermissions: () => Promise<void>;
+            start: () => Promise<void>;
+            toggleAudio: () => void;
+            toggleVideo: () => void;
+            switchCamera: (deviceId: string) => Promise<MediaStreamTrack | null>;
+            startScreenShare: (onEnded: () => void) => Promise<MediaStream | null>;
+            stopScreenShare: () => {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null;
+            toggleFlashlight: () => Promise<void>;
+            stopAll: () => void;
+        };
+        peers: {
+            peers: globalThis.Ref<Record<string, {
+                signal(data: import('../types').SignalData): void;
+                addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                removeTrack(track: MediaStreamTrack): void;
+                replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                isSending(track: MediaStreamTrack): boolean;
+                destroy: () => void;
+            }>, Record<string, {
+                signal(data: import('../types').SignalData): void;
+                addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                removeTrack(track: MediaStreamTrack): void;
+                replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                isSending(track: MediaStreamTrack): boolean;
+                destroy: () => void;
+            }>>;
+            remoteVideos: globalThis.Ref<Record<string, import('../composables/call/peers').RemoteStream>, Record<string, import('../composables/call/peers').RemoteStream>>;
+            remoteScreens: globalThis.Ref<Record<string, import('../composables/call/peers').RemoteStream>, Record<string, import('../composables/call/peers').RemoteStream>>;
+            remoteStreamTypes: globalThis.Ref<Record<string, import('../composables/call/signaling').TrackTypes>, Record<string, import('../composables/call/signaling').TrackTypes>>;
+            isInitiator: (remoteId: string) => boolean;
+            has: (remoteId: string) => boolean;
+            add: (remoteId: string, name: string) => void;
+            remove: (remoteId: string) => void;
+            signal: (remoteId: string, name: string, data: import('../types').SignalData & {
+                sdp: string;
+            }) => void;
+            addTrackToAll: (track: MediaStreamTrack, stream: MediaStream) => void;
+            removeTrackFromAll: (track: MediaStreamTrack) => void;
+            replaceVideoTrack: (track: MediaStreamTrack, stream: MediaStream) => void;
+            destroyAll: () => void;
+        };
+        participantCount: globalThis.ComputedRef<number>;
+        tileCount: globalThis.ComputedRef<number>;
+    } | null>;
+    isActive: globalThis.Ref<boolean, boolean>;
+    isMinimized: globalThis.Ref<boolean, boolean>;
+    elapsedTime: globalThis.Ref<number, number>;
+    channelId: globalThis.Ref<string | null, string | null>;
+    setHandlers: (val: CallHandlers) => void;
+    startCall: (id: string) => void;
+    endCall: () => void;
+    minimize: () => void;
+    maximize: () => void;
+}, "session" | "isActive" | "isMinimized" | "elapsedTime" | "channelId">, Pick<{
+    session: import('vue').ShallowRef<{
+        channel: string;
+        start: () => Promise<void>;
+        end: () => void;
+        toggleScreenShare: () => Promise<void>;
+        switchCamera: (deviceId: string) => Promise<{
+            readonly active: boolean;
+            readonly id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null>;
+        signaling: {
+            listen: (on: import('../composables/call/signaling').SignalingHandlers) => Promise<void>;
+            stop: () => void;
+            join: () => Promise<void>;
+            trackTypes: (types: import('../composables/call/signaling').TrackTypes) => Promise<void>;
+            signal: (to: string, signal: import('../types').SignalData) => Promise<void>;
+            ring: (channel: string, avatar?: string) => Promise<void>;
+            hangup: (channel: string) => Promise<void>;
+        };
+        media: {
+            localStream: globalThis.Ref<{
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStream | {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            screenStream: globalThis.Ref<{
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStream | {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            trackTypes: globalThis.Ref<{
+                id: string;
+                type: import('../types').TrackType;
+            }[], import('../composables/call/signaling').TrackTypes | {
+                id: string;
+                type: import('../types').TrackType;
+            }[]>;
+            videoTrack: globalThis.Ref<{
+                contentHint: string;
+                enabled: boolean;
+                readonly id: string;
+                readonly kind: string;
+                readonly label: string;
+                readonly muted: boolean;
+                onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                readonly readyState: MediaStreamTrackState;
+                applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+                clone: () => MediaStreamTrack;
+                getCapabilities: () => MediaTrackCapabilities;
+                getConstraints: () => MediaTrackConstraints;
+                getSettings: () => MediaTrackSettings;
+                stop: () => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStreamTrack | {
+                contentHint: string;
+                enabled: boolean;
+                readonly id: string;
+                readonly kind: string;
+                readonly label: string;
+                readonly muted: boolean;
+                onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                readonly readyState: MediaStreamTrackState;
+                applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+                clone: () => MediaStreamTrack;
+                getCapabilities: () => MediaTrackCapabilities;
+                getConstraints: () => MediaTrackConstraints;
+                getSettings: () => MediaTrackSettings;
+                stop: () => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            cameras: globalThis.Ref<{
+                readonly deviceId: string;
+                readonly groupId: string;
+                readonly kind: MediaDeviceKind;
+                readonly label: string;
+                toJSON: () => any;
+            }[], MediaDeviceInfo[] | {
+                readonly deviceId: string;
+                readonly groupId: string;
+                readonly kind: MediaDeviceKind;
+                readonly label: string;
+                toJSON: () => any;
+            }[]>;
+            isAudioOn: globalThis.Ref<boolean, boolean>;
+            isVideoOn: globalThis.Ref<boolean, boolean>;
+            isScreenSharing: globalThis.Ref<boolean, boolean>;
+            isFlashlightOn: globalThis.Ref<boolean, boolean>;
+            isFlashlightSupported: globalThis.ComputedRef<boolean>;
+            checkPermissions: () => Promise<void>;
+            start: () => Promise<void>;
+            toggleAudio: () => void;
+            toggleVideo: () => void;
+            switchCamera: (deviceId: string) => Promise<MediaStreamTrack | null>;
+            startScreenShare: (onEnded: () => void) => Promise<MediaStream | null>;
+            stopScreenShare: () => {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null;
+            toggleFlashlight: () => Promise<void>;
+            stopAll: () => void;
+        };
+        peers: {
+            peers: globalThis.Ref<Record<string, {
+                signal(data: import('../types').SignalData): void;
+                addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                removeTrack(track: MediaStreamTrack): void;
+                replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                isSending(track: MediaStreamTrack): boolean;
+                destroy: () => void;
+            }>, Record<string, {
+                signal(data: import('../types').SignalData): void;
+                addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                removeTrack(track: MediaStreamTrack): void;
+                replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                isSending(track: MediaStreamTrack): boolean;
+                destroy: () => void;
+            }>>;
+            remoteVideos: globalThis.Ref<Record<string, import('../composables/call/peers').RemoteStream>, Record<string, import('../composables/call/peers').RemoteStream>>;
+            remoteScreens: globalThis.Ref<Record<string, import('../composables/call/peers').RemoteStream>, Record<string, import('../composables/call/peers').RemoteStream>>;
+            remoteStreamTypes: globalThis.Ref<Record<string, import('../composables/call/signaling').TrackTypes>, Record<string, import('../composables/call/signaling').TrackTypes>>;
+            isInitiator: (remoteId: string) => boolean;
+            has: (remoteId: string) => boolean;
+            add: (remoteId: string, name: string) => void;
+            remove: (remoteId: string) => void;
+            signal: (remoteId: string, name: string, data: import('../types').SignalData & {
+                sdp: string;
+            }) => void;
+            addTrackToAll: (track: MediaStreamTrack, stream: MediaStream) => void;
+            removeTrackFromAll: (track: MediaStreamTrack) => void;
+            replaceVideoTrack: (track: MediaStreamTrack, stream: MediaStream) => void;
+            destroyAll: () => void;
+        };
+        participantCount: globalThis.ComputedRef<number>;
+        tileCount: globalThis.ComputedRef<number>;
+    } | null, {
+        channel: string;
+        start: () => Promise<void>;
+        end: () => void;
+        toggleScreenShare: () => Promise<void>;
+        switchCamera: (deviceId: string) => Promise<{
+            readonly active: boolean;
+            readonly id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null>;
+        signaling: {
+            listen: (on: import('../composables/call/signaling').SignalingHandlers) => Promise<void>;
+            stop: () => void;
+            join: () => Promise<void>;
+            trackTypes: (types: import('../composables/call/signaling').TrackTypes) => Promise<void>;
+            signal: (to: string, signal: import('../types').SignalData) => Promise<void>;
+            ring: (channel: string, avatar?: string) => Promise<void>;
+            hangup: (channel: string) => Promise<void>;
+        };
+        media: {
+            localStream: globalThis.Ref<{
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStream | {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            screenStream: globalThis.Ref<{
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStream | {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            trackTypes: globalThis.Ref<{
+                id: string;
+                type: import('../types').TrackType;
+            }[], import('../composables/call/signaling').TrackTypes | {
+                id: string;
+                type: import('../types').TrackType;
+            }[]>;
+            videoTrack: globalThis.Ref<{
+                contentHint: string;
+                enabled: boolean;
+                readonly id: string;
+                readonly kind: string;
+                readonly label: string;
+                readonly muted: boolean;
+                onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                readonly readyState: MediaStreamTrackState;
+                applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+                clone: () => MediaStreamTrack;
+                getCapabilities: () => MediaTrackCapabilities;
+                getConstraints: () => MediaTrackConstraints;
+                getSettings: () => MediaTrackSettings;
+                stop: () => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStreamTrack | {
+                contentHint: string;
+                enabled: boolean;
+                readonly id: string;
+                readonly kind: string;
+                readonly label: string;
+                readonly muted: boolean;
+                onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                readonly readyState: MediaStreamTrackState;
+                applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+                clone: () => MediaStreamTrack;
+                getCapabilities: () => MediaTrackCapabilities;
+                getConstraints: () => MediaTrackConstraints;
+                getSettings: () => MediaTrackSettings;
+                stop: () => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            cameras: globalThis.Ref<{
+                readonly deviceId: string;
+                readonly groupId: string;
+                readonly kind: MediaDeviceKind;
+                readonly label: string;
+                toJSON: () => any;
+            }[], MediaDeviceInfo[] | {
+                readonly deviceId: string;
+                readonly groupId: string;
+                readonly kind: MediaDeviceKind;
+                readonly label: string;
+                toJSON: () => any;
+            }[]>;
+            isAudioOn: globalThis.Ref<boolean, boolean>;
+            isVideoOn: globalThis.Ref<boolean, boolean>;
+            isScreenSharing: globalThis.Ref<boolean, boolean>;
+            isFlashlightOn: globalThis.Ref<boolean, boolean>;
+            isFlashlightSupported: globalThis.ComputedRef<boolean>;
+            checkPermissions: () => Promise<void>;
+            start: () => Promise<void>;
+            toggleAudio: () => void;
+            toggleVideo: () => void;
+            switchCamera: (deviceId: string) => Promise<MediaStreamTrack | null>;
+            startScreenShare: (onEnded: () => void) => Promise<MediaStream | null>;
+            stopScreenShare: () => {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null;
+            toggleFlashlight: () => Promise<void>;
+            stopAll: () => void;
+        };
+        peers: {
+            peers: globalThis.Ref<Record<string, {
+                signal(data: import('../types').SignalData): void;
+                addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                removeTrack(track: MediaStreamTrack): void;
+                replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                isSending(track: MediaStreamTrack): boolean;
+                destroy: () => void;
+            }>, Record<string, {
+                signal(data: import('../types').SignalData): void;
+                addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                removeTrack(track: MediaStreamTrack): void;
+                replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                isSending(track: MediaStreamTrack): boolean;
+                destroy: () => void;
+            }>>;
+            remoteVideos: globalThis.Ref<Record<string, import('../composables/call/peers').RemoteStream>, Record<string, import('../composables/call/peers').RemoteStream>>;
+            remoteScreens: globalThis.Ref<Record<string, import('../composables/call/peers').RemoteStream>, Record<string, import('../composables/call/peers').RemoteStream>>;
+            remoteStreamTypes: globalThis.Ref<Record<string, import('../composables/call/signaling').TrackTypes>, Record<string, import('../composables/call/signaling').TrackTypes>>;
+            isInitiator: (remoteId: string) => boolean;
+            has: (remoteId: string) => boolean;
+            add: (remoteId: string, name: string) => void;
+            remove: (remoteId: string) => void;
+            signal: (remoteId: string, name: string, data: import('../types').SignalData & {
+                sdp: string;
+            }) => void;
+            addTrackToAll: (track: MediaStreamTrack, stream: MediaStream) => void;
+            removeTrackFromAll: (track: MediaStreamTrack) => void;
+            replaceVideoTrack: (track: MediaStreamTrack, stream: MediaStream) => void;
+            destroyAll: () => void;
+        };
+        participantCount: globalThis.ComputedRef<number>;
+        tileCount: globalThis.ComputedRef<number>;
+    } | null>;
+    isActive: globalThis.Ref<boolean, boolean>;
+    isMinimized: globalThis.Ref<boolean, boolean>;
+    elapsedTime: globalThis.Ref<number, number>;
+    channelId: globalThis.Ref<string | null, string | null>;
+    setHandlers: (val: CallHandlers) => void;
+    startCall: (id: string) => void;
+    endCall: () => void;
+    minimize: () => void;
+    maximize: () => void;
+}, never>, Pick<{
+    session: import('vue').ShallowRef<{
+        channel: string;
+        start: () => Promise<void>;
+        end: () => void;
+        toggleScreenShare: () => Promise<void>;
+        switchCamera: (deviceId: string) => Promise<{
+            readonly active: boolean;
+            readonly id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null>;
+        signaling: {
+            listen: (on: import('../composables/call/signaling').SignalingHandlers) => Promise<void>;
+            stop: () => void;
+            join: () => Promise<void>;
+            trackTypes: (types: import('../composables/call/signaling').TrackTypes) => Promise<void>;
+            signal: (to: string, signal: import('../types').SignalData) => Promise<void>;
+            ring: (channel: string, avatar?: string) => Promise<void>;
+            hangup: (channel: string) => Promise<void>;
+        };
+        media: {
+            localStream: globalThis.Ref<{
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStream | {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            screenStream: globalThis.Ref<{
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStream | {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            trackTypes: globalThis.Ref<{
+                id: string;
+                type: import('../types').TrackType;
+            }[], import('../composables/call/signaling').TrackTypes | {
+                id: string;
+                type: import('../types').TrackType;
+            }[]>;
+            videoTrack: globalThis.Ref<{
+                contentHint: string;
+                enabled: boolean;
+                readonly id: string;
+                readonly kind: string;
+                readonly label: string;
+                readonly muted: boolean;
+                onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                readonly readyState: MediaStreamTrackState;
+                applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+                clone: () => MediaStreamTrack;
+                getCapabilities: () => MediaTrackCapabilities;
+                getConstraints: () => MediaTrackConstraints;
+                getSettings: () => MediaTrackSettings;
+                stop: () => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStreamTrack | {
+                contentHint: string;
+                enabled: boolean;
+                readonly id: string;
+                readonly kind: string;
+                readonly label: string;
+                readonly muted: boolean;
+                onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                readonly readyState: MediaStreamTrackState;
+                applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+                clone: () => MediaStreamTrack;
+                getCapabilities: () => MediaTrackCapabilities;
+                getConstraints: () => MediaTrackConstraints;
+                getSettings: () => MediaTrackSettings;
+                stop: () => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            cameras: globalThis.Ref<{
+                readonly deviceId: string;
+                readonly groupId: string;
+                readonly kind: MediaDeviceKind;
+                readonly label: string;
+                toJSON: () => any;
+            }[], MediaDeviceInfo[] | {
+                readonly deviceId: string;
+                readonly groupId: string;
+                readonly kind: MediaDeviceKind;
+                readonly label: string;
+                toJSON: () => any;
+            }[]>;
+            isAudioOn: globalThis.Ref<boolean, boolean>;
+            isVideoOn: globalThis.Ref<boolean, boolean>;
+            isScreenSharing: globalThis.Ref<boolean, boolean>;
+            isFlashlightOn: globalThis.Ref<boolean, boolean>;
+            isFlashlightSupported: globalThis.ComputedRef<boolean>;
+            checkPermissions: () => Promise<void>;
+            start: () => Promise<void>;
+            toggleAudio: () => void;
+            toggleVideo: () => void;
+            switchCamera: (deviceId: string) => Promise<MediaStreamTrack | null>;
+            startScreenShare: (onEnded: () => void) => Promise<MediaStream | null>;
+            stopScreenShare: () => {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null;
+            toggleFlashlight: () => Promise<void>;
+            stopAll: () => void;
+        };
+        peers: {
+            peers: globalThis.Ref<Record<string, {
+                signal(data: import('../types').SignalData): void;
+                addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                removeTrack(track: MediaStreamTrack): void;
+                replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                isSending(track: MediaStreamTrack): boolean;
+                destroy: () => void;
+            }>, Record<string, {
+                signal(data: import('../types').SignalData): void;
+                addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                removeTrack(track: MediaStreamTrack): void;
+                replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                isSending(track: MediaStreamTrack): boolean;
+                destroy: () => void;
+            }>>;
+            remoteVideos: globalThis.Ref<Record<string, import('../composables/call/peers').RemoteStream>, Record<string, import('../composables/call/peers').RemoteStream>>;
+            remoteScreens: globalThis.Ref<Record<string, import('../composables/call/peers').RemoteStream>, Record<string, import('../composables/call/peers').RemoteStream>>;
+            remoteStreamTypes: globalThis.Ref<Record<string, import('../composables/call/signaling').TrackTypes>, Record<string, import('../composables/call/signaling').TrackTypes>>;
+            isInitiator: (remoteId: string) => boolean;
+            has: (remoteId: string) => boolean;
+            add: (remoteId: string, name: string) => void;
+            remove: (remoteId: string) => void;
+            signal: (remoteId: string, name: string, data: import('../types').SignalData & {
+                sdp: string;
+            }) => void;
+            addTrackToAll: (track: MediaStreamTrack, stream: MediaStream) => void;
+            removeTrackFromAll: (track: MediaStreamTrack) => void;
+            replaceVideoTrack: (track: MediaStreamTrack, stream: MediaStream) => void;
+            destroyAll: () => void;
+        };
+        participantCount: globalThis.ComputedRef<number>;
+        tileCount: globalThis.ComputedRef<number>;
+    } | null, {
+        channel: string;
+        start: () => Promise<void>;
+        end: () => void;
+        toggleScreenShare: () => Promise<void>;
+        switchCamera: (deviceId: string) => Promise<{
+            readonly active: boolean;
+            readonly id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null>;
+        signaling: {
+            listen: (on: import('../composables/call/signaling').SignalingHandlers) => Promise<void>;
+            stop: () => void;
+            join: () => Promise<void>;
+            trackTypes: (types: import('../composables/call/signaling').TrackTypes) => Promise<void>;
+            signal: (to: string, signal: import('../types').SignalData) => Promise<void>;
+            ring: (channel: string, avatar?: string) => Promise<void>;
+            hangup: (channel: string) => Promise<void>;
+        };
+        media: {
+            localStream: globalThis.Ref<{
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStream | {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            screenStream: globalThis.Ref<{
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStream | {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            trackTypes: globalThis.Ref<{
+                id: string;
+                type: import('../types').TrackType;
+            }[], import('../composables/call/signaling').TrackTypes | {
+                id: string;
+                type: import('../types').TrackType;
+            }[]>;
+            videoTrack: globalThis.Ref<{
+                contentHint: string;
+                enabled: boolean;
+                readonly id: string;
+                readonly kind: string;
+                readonly label: string;
+                readonly muted: boolean;
+                onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                readonly readyState: MediaStreamTrackState;
+                applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+                clone: () => MediaStreamTrack;
+                getCapabilities: () => MediaTrackCapabilities;
+                getConstraints: () => MediaTrackConstraints;
+                getSettings: () => MediaTrackSettings;
+                stop: () => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null, MediaStreamTrack | {
+                contentHint: string;
+                enabled: boolean;
+                readonly id: string;
+                readonly kind: string;
+                readonly label: string;
+                readonly muted: boolean;
+                onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+                readonly readyState: MediaStreamTrackState;
+                applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+                clone: () => MediaStreamTrack;
+                getCapabilities: () => MediaTrackCapabilities;
+                getConstraints: () => MediaTrackConstraints;
+                getSettings: () => MediaTrackSettings;
+                stop: () => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null>;
+            cameras: globalThis.Ref<{
+                readonly deviceId: string;
+                readonly groupId: string;
+                readonly kind: MediaDeviceKind;
+                readonly label: string;
+                toJSON: () => any;
+            }[], MediaDeviceInfo[] | {
+                readonly deviceId: string;
+                readonly groupId: string;
+                readonly kind: MediaDeviceKind;
+                readonly label: string;
+                toJSON: () => any;
+            }[]>;
+            isAudioOn: globalThis.Ref<boolean, boolean>;
+            isVideoOn: globalThis.Ref<boolean, boolean>;
+            isScreenSharing: globalThis.Ref<boolean, boolean>;
+            isFlashlightOn: globalThis.Ref<boolean, boolean>;
+            isFlashlightSupported: globalThis.ComputedRef<boolean>;
+            checkPermissions: () => Promise<void>;
+            start: () => Promise<void>;
+            toggleAudio: () => void;
+            toggleVideo: () => void;
+            switchCamera: (deviceId: string) => Promise<MediaStreamTrack | null>;
+            startScreenShare: (onEnded: () => void) => Promise<MediaStream | null>;
+            stopScreenShare: () => {
+                readonly active: boolean;
+                readonly id: string;
+                onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+                addTrack: (track: MediaStreamTrack) => void;
+                clone: () => MediaStream;
+                getAudioTracks: () => MediaStreamTrack[];
+                getTrackById: (trackId: string) => MediaStreamTrack | null;
+                getTracks: () => MediaStreamTrack[];
+                getVideoTracks: () => MediaStreamTrack[];
+                removeTrack: (track: MediaStreamTrack) => void;
+                addEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            } | null;
+            toggleFlashlight: () => Promise<void>;
+            stopAll: () => void;
+        };
+        peers: {
+            peers: globalThis.Ref<Record<string, {
+                signal(data: import('../types').SignalData): void;
+                addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                removeTrack(track: MediaStreamTrack): void;
+                replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                isSending(track: MediaStreamTrack): boolean;
+                destroy: () => void;
+            }>, Record<string, {
+                signal(data: import('../types').SignalData): void;
+                addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                removeTrack(track: MediaStreamTrack): void;
+                replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+                isSending(track: MediaStreamTrack): boolean;
+                destroy: () => void;
+            }>>;
+            remoteVideos: globalThis.Ref<Record<string, import('../composables/call/peers').RemoteStream>, Record<string, import('../composables/call/peers').RemoteStream>>;
+            remoteScreens: globalThis.Ref<Record<string, import('../composables/call/peers').RemoteStream>, Record<string, import('../composables/call/peers').RemoteStream>>;
+            remoteStreamTypes: globalThis.Ref<Record<string, import('../composables/call/signaling').TrackTypes>, Record<string, import('../composables/call/signaling').TrackTypes>>;
+            isInitiator: (remoteId: string) => boolean;
+            has: (remoteId: string) => boolean;
+            add: (remoteId: string, name: string) => void;
+            remove: (remoteId: string) => void;
+            signal: (remoteId: string, name: string, data: import('../types').SignalData & {
+                sdp: string;
+            }) => void;
+            addTrackToAll: (track: MediaStreamTrack, stream: MediaStream) => void;
+            removeTrackFromAll: (track: MediaStreamTrack) => void;
+            replaceVideoTrack: (track: MediaStreamTrack, stream: MediaStream) => void;
+            destroyAll: () => void;
+        };
+        participantCount: globalThis.ComputedRef<number>;
+        tileCount: globalThis.ComputedRef<number>;
+    } | null>;
+    isActive: globalThis.Ref<boolean, boolean>;
+    isMinimized: globalThis.Ref<boolean, boolean>;
+    elapsedTime: globalThis.Ref<number, number>;
+    channelId: globalThis.Ref<string | null, string | null>;
+    setHandlers: (val: CallHandlers) => void;
+    startCall: (id: string) => void;
+    endCall: () => void;
+    minimize: () => void;
+    maximize: () => void;
+}, "setHandlers" | "startCall" | "endCall" | "minimize" | "maximize">>;
+//# sourceMappingURL=callStore.d.ts.map