@yonus_amire01/chat 0.1.0

package/dist/types/stores/callStore.d.ts

@@ -0,0 +1,518 @@
+export declare const useCallStore: () => import('pinia').Store<"call", Pick<{
+    chatContact: import('vue').Ref<import('../types/call').CallMember, import('../types/call').CallMember>;
+    isActive: import('vue').Ref<boolean, boolean>;
+    localStream: import('vue').Ref<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }, MediaStream | {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }>;
+    startCall: (contact: import('../types/call').CallMember, conversationId: string, serviceType: import('..').CallKind) => Promise<void>;
+    remoteStream: import('vue').Ref<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }, MediaStream | {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }>;
+    elapsedTime: import('vue').Ref<number, number>;
+    callMembers: import('vue').ComputedRef<import('../types/call').CallMember[]>;
+    initCall: (withVideo: boolean) => Promise<void>;
+    stopCall: () => void;
+    setScreenStream: (stream: MediaStream) => void;
+    syncMediaSettings: (serviceType: string) => Promise<void>;
+    isMicMuted: import('vue').Ref<boolean, boolean>;
+    isCamDisabled: import('vue').Ref<boolean, boolean>;
+    isSoundMuted: import('vue').Ref<boolean, boolean>;
+    isPiP: import('vue').Ref<boolean, boolean>;
+    maximize: () => void;
+    minimize: () => void;
+    toggleMic: () => Promise<void>;
+    toggleCam: () => Promise<void>;
+    toggleSound: () => void;
+    stopScreenShare: () => void;
+    isSharingScreen: import('vue').Ref<boolean, boolean>;
+    screenStream: import('vue').Ref<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }, MediaStream | {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }>;
+    currentFacingMode: import('vue').Ref<"user" | "environment", "user" | "environment">;
+    isFlashOn: import('vue').Ref<boolean, boolean>;
+    toggleCamera: () => Promise<void>;
+    toggleFlash: () => Promise<void>;
+    boardPages: import('vue').Ref<{
+        data: any[];
+        history: any[];
+        redo: any[];
+    }[], {
+        data: any[];
+        history: any[];
+        redo: any[];
+    }[] | {
+        data: any[];
+        history: any[];
+        redo: any[];
+    }[]>;
+    boardSelectedPage: import('vue').Ref<number, number>;
+    boardSelectedColor: import('vue').Ref<string, string>;
+    boardBrushSize: import('vue').Ref<number, number>;
+    boardHistory: import('vue').Ref<any[], any[]>;
+    boardRedoHistory: import('vue').Ref<any[], any[]>;
+}, "isActive" | "chatContact" | "localStream" | "remoteStream" | "elapsedTime" | "isMicMuted" | "isCamDisabled" | "isSoundMuted" | "isPiP" | "isSharingScreen" | "screenStream" | "currentFacingMode" | "isFlashOn" | "boardPages" | "boardSelectedPage" | "boardSelectedColor" | "boardBrushSize" | "boardHistory" | "boardRedoHistory">, Pick<{
+    chatContact: import('vue').Ref<import('../types/call').CallMember, import('../types/call').CallMember>;
+    isActive: import('vue').Ref<boolean, boolean>;
+    localStream: import('vue').Ref<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }, MediaStream | {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }>;
+    startCall: (contact: import('../types/call').CallMember, conversationId: string, serviceType: import('..').CallKind) => Promise<void>;
+    remoteStream: import('vue').Ref<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }, MediaStream | {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }>;
+    elapsedTime: import('vue').Ref<number, number>;
+    callMembers: import('vue').ComputedRef<import('../types/call').CallMember[]>;
+    initCall: (withVideo: boolean) => Promise<void>;
+    stopCall: () => void;
+    setScreenStream: (stream: MediaStream) => void;
+    syncMediaSettings: (serviceType: string) => Promise<void>;
+    isMicMuted: import('vue').Ref<boolean, boolean>;
+    isCamDisabled: import('vue').Ref<boolean, boolean>;
+    isSoundMuted: import('vue').Ref<boolean, boolean>;
+    isPiP: import('vue').Ref<boolean, boolean>;
+    maximize: () => void;
+    minimize: () => void;
+    toggleMic: () => Promise<void>;
+    toggleCam: () => Promise<void>;
+    toggleSound: () => void;
+    stopScreenShare: () => void;
+    isSharingScreen: import('vue').Ref<boolean, boolean>;
+    screenStream: import('vue').Ref<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }, MediaStream | {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }>;
+    currentFacingMode: import('vue').Ref<"user" | "environment", "user" | "environment">;
+    isFlashOn: import('vue').Ref<boolean, boolean>;
+    toggleCamera: () => Promise<void>;
+    toggleFlash: () => Promise<void>;
+    boardPages: import('vue').Ref<{
+        data: any[];
+        history: any[];
+        redo: any[];
+    }[], {
+        data: any[];
+        history: any[];
+        redo: any[];
+    }[] | {
+        data: any[];
+        history: any[];
+        redo: any[];
+    }[]>;
+    boardSelectedPage: import('vue').Ref<number, number>;
+    boardSelectedColor: import('vue').Ref<string, string>;
+    boardBrushSize: import('vue').Ref<number, number>;
+    boardHistory: import('vue').Ref<any[], any[]>;
+    boardRedoHistory: import('vue').Ref<any[], any[]>;
+}, "callMembers">, Pick<{
+    chatContact: import('vue').Ref<import('../types/call').CallMember, import('../types/call').CallMember>;
+    isActive: import('vue').Ref<boolean, boolean>;
+    localStream: import('vue').Ref<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }, MediaStream | {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }>;
+    startCall: (contact: import('../types/call').CallMember, conversationId: string, serviceType: import('..').CallKind) => Promise<void>;
+    remoteStream: import('vue').Ref<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }, MediaStream | {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }>;
+    elapsedTime: import('vue').Ref<number, number>;
+    callMembers: import('vue').ComputedRef<import('../types/call').CallMember[]>;
+    initCall: (withVideo: boolean) => Promise<void>;
+    stopCall: () => void;
+    setScreenStream: (stream: MediaStream) => void;
+    syncMediaSettings: (serviceType: string) => Promise<void>;
+    isMicMuted: import('vue').Ref<boolean, boolean>;
+    isCamDisabled: import('vue').Ref<boolean, boolean>;
+    isSoundMuted: import('vue').Ref<boolean, boolean>;
+    isPiP: import('vue').Ref<boolean, boolean>;
+    maximize: () => void;
+    minimize: () => void;
+    toggleMic: () => Promise<void>;
+    toggleCam: () => Promise<void>;
+    toggleSound: () => void;
+    stopScreenShare: () => void;
+    isSharingScreen: import('vue').Ref<boolean, boolean>;
+    screenStream: import('vue').Ref<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }, MediaStream | {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        onremovetrack: (this: MediaStream, ev: MediaStreamTrackEvent) => any;
+        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;
+    }>;
+    currentFacingMode: import('vue').Ref<"user" | "environment", "user" | "environment">;
+    isFlashOn: import('vue').Ref<boolean, boolean>;
+    toggleCamera: () => Promise<void>;
+    toggleFlash: () => Promise<void>;
+    boardPages: import('vue').Ref<{
+        data: any[];
+        history: any[];
+        redo: any[];
+    }[], {
+        data: any[];
+        history: any[];
+        redo: any[];
+    }[] | {
+        data: any[];
+        history: any[];
+        redo: any[];
+    }[]>;
+    boardSelectedPage: import('vue').Ref<number, number>;
+    boardSelectedColor: import('vue').Ref<string, string>;
+    boardBrushSize: import('vue').Ref<number, number>;
+    boardHistory: import('vue').Ref<any[], any[]>;
+    boardRedoHistory: import('vue').Ref<any[], any[]>;
+}, "startCall" | "initCall" | "stopCall" | "setScreenStream" | "syncMediaSettings" | "maximize" | "minimize" | "toggleMic" | "toggleCam" | "toggleSound" | "stopScreenShare" | "toggleCamera" | "toggleFlash">>;
+//# sourceMappingURL=callStore.d.ts.map

package/dist/types/stores/callStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callStore.d.ts","sourceRoot":"","sources":["../../../app/stores/callStore.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+MAAyC,CAAC"}