@easemob-community/callkit-vue3 2.0.1

package/dist/modules/groupCall/components/CallKitIcon.vue.d.ts

@@ -0,0 +1,12 @@
+interface CallKitIconProps {
+    name: string;
+    width?: number | string;
+    height?: number | string;
+    color?: string;
+}
+declare const _default: import('vue').DefineComponent<CallKitIconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CallKitIconProps> & Readonly<{}>, {
+    width: number | string;
+    height: number | string;
+    color: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+export default _default;

package/dist/modules/groupCall/components/GroupCallShell.vue.d.ts

@@ -0,0 +1,34 @@
+import { RtcService } from '../../../services/RtcService';
+export interface GroupCallShellProps {
+    groupId: string;
+    groupName?: string;
+    currentUserId: string;
+    currentNickname?: string;
+    currentAvatarUrl?: string;
+    rtcService?: RtcService | null;
+    groupMembers?: Array<{
+        userId: string;
+        userName: string;
+        avatar?: string;
+    }>;
+}
+declare const _default: import('vue').DefineComponent<GroupCallShellProps, {
+    startSession: (payload: {
+        sessionId: string;
+        callType: "video" | "audio";
+    }) => void;
+    addRemoteParticipant: (userId: string, nickname: string, avatarUrl?: string) => void;
+    markRemoteAccepted: (userId: string) => void;
+    bindRtcService: (rtcService: RtcService) => void;
+    unbindRtcService: () => void;
+    sendInvite: (userIds: string[], groupId: string, message: string) => Promise<void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    hangup: () => any;
+    addParticipant: () => any;
+}, string, import('vue').PublicProps, Readonly<GroupCallShellProps> & Readonly<{
+    onHangup?: () => any;
+    onAddParticipant?: () => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    shellRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/modules/groupCall/components/MainVideoLayout.vue.d.ts

@@ -0,0 +1,32 @@
+import { PropType } from 'vue';
+import { Participant } from '../types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    participants: {
+        type: PropType<Participant[]>;
+        default: () => any[];
+    };
+    selectedId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (userId: string) => any;
+    exit: () => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    participants: {
+        type: PropType<Participant[]>;
+        default: () => any[];
+    };
+    selectedId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{
+    onSelect?: (userId: string) => any;
+    onExit?: () => any;
+}>, {
+    participants: Participant[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    scrollRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/modules/groupCall/components/ParticipantTile.vue.d.ts

@@ -0,0 +1,12 @@
+import { Participant } from '../types';
+interface ParticipantTileProps {
+    participant: Participant;
+}
+declare const _default: import('vue').DefineComponent<ParticipantTileProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (userId: string) => any;
+}, string, import('vue').PublicProps, Readonly<ParticipantTileProps> & Readonly<{
+    onClick?: (userId: string) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    videoEl: HTMLVideoElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/modules/groupCall/components/VideoGrid.vue.d.ts

@@ -0,0 +1,29 @@
+import { PropType } from 'vue';
+import { Participant } from '../types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    participants: {
+        type: PropType<Participant[]>;
+        default: () => any[];
+    };
+    selectedId: {
+        type: PropType<string | null>;
+        default: any;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (userId: string) => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    participants: {
+        type: PropType<Participant[]>;
+        default: () => any[];
+    };
+    selectedId: {
+        type: PropType<string | null>;
+        default: any;
+    };
+}>> & Readonly<{
+    onSelect?: (userId: string) => any;
+}>, {
+    participants: Participant[];
+    selectedId: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/modules/groupCall/components/iconRegistry.d.ts

@@ -0,0 +1,2 @@
+export declare const iconRegistry: Record<string, string>;
+export declare const iconNames: string[];

package/dist/modules/groupCall/index.d.ts

@@ -0,0 +1,7 @@
+export { useGroupCallStore } from './viewModel/GroupCallStore';
+export { useGroupCallViewModel } from './viewModel/useGroupCallViewModel';
+export type { UseGroupCallViewModelReturn } from './viewModel/useGroupCallViewModel';
+export { default as GroupCallShell } from './components/GroupCallShell.vue';
+export { default as ParticipantTile } from './components/ParticipantTile.vue';
+export { default as VideoGrid } from './components/VideoGrid.vue';
+export type { Participant, ParticipantState, GroupCallSessionState, UidResolution, } from './types';

package/dist/modules/groupCall/media/RtcMediaBridge.d.ts

@@ -0,0 +1,26 @@
+import { RtcService } from '../../../services/RtcService';
+/**
+ * RtcMediaBridge
+ * 职责：监听 Agora 事件，订阅远程流，并将 track 写入 GroupCallStore
+ * 不处理 UI，不处理信令，只做纯粹的 RTC -> Store 桥接
+ */
+export declare class RtcMediaBridge {
+    private rtcService;
+    private store;
+    private client;
+    constructor(rtcService: RtcService);
+    destroy(): void;
+    private bindEvents;
+    private unbindEvents;
+    private handleUserJoined;
+    private handleUserLeft;
+    private handleUserPublished;
+    private handleUserUnpublished;
+    private handleVolumeIndicator;
+    private migrateTempParticipant;
+    /**
+     * 用 GlobalCallStore 中的资料丰富参与者信息
+     */
+    private enrichParticipantProfile;
+    private fetchUserIdByUid;
+}

package/dist/modules/groupCall/signaling/GroupCallSignalingAdapter.d.ts

@@ -0,0 +1,29 @@
+import { CALL_TYPE } from '../../../types/callstate.types';
+/**
+ * GroupCallSignalingAdapter
+ * 基于 callkit-core 的群通话信令适配器
+ * 职责：将新模块的群组通话动作转换为 useCallKitCore API 调用
+ */
+export declare class GroupCallSignalingAdapter {
+    private core;
+    /**
+     * 发送邀请（通话中追加新成员）
+     * 复用 useCallKitCore.inviteMoreParticipants（不会创建新通话）
+     */
+    sendInvite(userIds: string[], groupId: string, message: string, callType?: CALL_TYPE): Promise<void>;
+    /**
+     * 接受邀请（被叫方）
+     * 通过 core.answerCall 发送接听信令
+     */
+    sendAnswer(userId: string, groupId: string): Promise<void>;
+    /**
+     * 挂断 / 离开通话 / 取消邀请
+     * 区分：有成员已加入时发 leaveCall，仅邀请阶段发 cancelCall
+     */
+    hangup(): Promise<void>;
+    /**
+     * 取消邀请（邀请超时或主动取消）
+     * 仅从本地会话移除该参与者，不发送全局 hangup
+     */
+    cancelInvitation(userId: string, groupId?: string): Promise<void>;
+}

package/dist/modules/groupCall/types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 群组通话新模块 - 核心类型定义
+ * 设计原则：单一事实源，UI 只做纯渲染，状态驱动媒体
+ */
+/** 参与者生命周期状态 */
+export type ParticipantState = 'invited' | 'accepted' | 'joinedRtc' | 'publishing' | 'left';
+/** 单个参与者（UI 和媒体层的唯一事实源） */
+export interface Participant {
+    userId: string;
+    nickname: string;
+    avatarUrl?: string;
+    state: ParticipantState;
+    isLocal: boolean;
+    videoTrack: any;
+    audioTrack: any;
+    localStream: MediaStream | null;
+    uid?: string;
+    isMuted: boolean;
+    isCameraOn: boolean;
+    isSpeaking: boolean;
+    invitedAt: number;
+    joinedAt?: number;
+}
+/** 群组通话整体状态 */
+export interface GroupCallSessionState {
+    sessionId: string;
+    groupId: string;
+    groupName?: string;
+    callType: 'video' | 'audio';
+    isActive: boolean;
+    startTime: number;
+}
+/** uid -> userId 解析结果 */
+export interface UidResolution {
+    userId: string | null;
+    confidence: 'certain' | 'inferred' | 'unknown';
+}

package/dist/modules/groupCall/viewModel/GroupCallStore.d.ts

@@ -0,0 +1,345 @@
+import { Participant, GroupCallSessionState, UidResolution } from '../types';
+/**
+ * GroupCallStore - 群组通话参与者与状态的单一事实源
+ * 替代旧架构中的 useParticipants + rtcChannelStore 分散逻辑
+ */
+export declare const useGroupCallStore: import('pinia').StoreDefinition<"groupCall", Pick<{
+    session: import('vue').Ref<{
+        sessionId: string;
+        groupId: string;
+        groupName?: string;
+        callType: "video" | "audio";
+        isActive: boolean;
+        startTime: number;
+    }, GroupCallSessionState | {
+        sessionId: string;
+        groupId: string;
+        groupName?: string;
+        callType: "video" | "audio";
+        isActive: boolean;
+        startTime: number;
+    }>;
+    participants: import('vue').Ref<Map<string, {
+        userId: string;
+        nickname: string;
+        avatarUrl?: string;
+        state: import('..').ParticipantState;
+        isLocal: boolean;
+        videoTrack: any;
+        audioTrack: any;
+        localStream: {
+            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;
+        };
+        uid?: string;
+        isMuted: boolean;
+        isCameraOn: boolean;
+        isSpeaking: boolean;
+        invitedAt: number;
+        joinedAt?: number;
+    }> & Omit<Map<string, Participant>, keyof Map<any, any>>, Map<string, Participant> | (Map<string, {
+        userId: string;
+        nickname: string;
+        avatarUrl?: string;
+        state: import('..').ParticipantState;
+        isLocal: boolean;
+        videoTrack: any;
+        audioTrack: any;
+        localStream: {
+            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;
+        };
+        uid?: string;
+        isMuted: boolean;
+        isCameraOn: boolean;
+        isSpeaking: boolean;
+        invitedAt: number;
+        joinedAt?: number;
+    }> & Omit<Map<string, Participant>, keyof Map<any, any>>)>;
+    uidToUserIdMap: import('vue').Ref<Map<string, string> & Omit<Map<string, string>, keyof Map<any, any>>, Map<string, string> | (Map<string, string> & Omit<Map<string, string>, keyof Map<any, any>>)>;
+    acceptedMembers: import('vue').Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+    participantList: import('vue').ComputedRef<Participant[]>;
+    localParticipant: import('vue').ComputedRef<Participant>;
+    activeParticipants: import('vue').ComputedRef<Participant[]>;
+    publishingParticipants: import('vue').ComputedRef<Participant[]>;
+    initSession: (payload: GroupCallSessionState) => void;
+    destroySession: () => void;
+    addParticipant: (participant: Omit<Participant, "invitedAt">) => void;
+    removeParticipant: (userId: string) => void;
+    setParticipantState: (userId: string, state: Participant["state"]) => void;
+    markAccepted: (userId: string) => void;
+    setUidMapping: (uid: string, userId: string) => void;
+    resolveUid: (uid: string) => UidResolution;
+    setVideoTrack: (userId: string, track: Participant["videoTrack"]) => void;
+    setAudioTrack: (userId: string, track: Participant["audioTrack"]) => void;
+    setLocalStream: (userId: string, stream: MediaStream | null) => void;
+    setMuteState: (userId: string, isMuted: boolean) => void;
+    setCameraState: (userId: string, isCameraOn: boolean) => void;
+    setSpeakingState: (userId: string, isSpeaking: boolean) => void;
+    updateParticipantProfile: (userId: string, profile: {
+        nickname?: string;
+        avatarUrl?: string;
+    }) => void;
+}, "participants" | "session" | "uidToUserIdMap" | "acceptedMembers">, Pick<{
+    session: import('vue').Ref<{
+        sessionId: string;
+        groupId: string;
+        groupName?: string;
+        callType: "video" | "audio";
+        isActive: boolean;
+        startTime: number;
+    }, GroupCallSessionState | {
+        sessionId: string;
+        groupId: string;
+        groupName?: string;
+        callType: "video" | "audio";
+        isActive: boolean;
+        startTime: number;
+    }>;
+    participants: import('vue').Ref<Map<string, {
+        userId: string;
+        nickname: string;
+        avatarUrl?: string;
+        state: import('..').ParticipantState;
+        isLocal: boolean;
+        videoTrack: any;
+        audioTrack: any;
+        localStream: {
+            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;
+        };
+        uid?: string;
+        isMuted: boolean;
+        isCameraOn: boolean;
+        isSpeaking: boolean;
+        invitedAt: number;
+        joinedAt?: number;
+    }> & Omit<Map<string, Participant>, keyof Map<any, any>>, Map<string, Participant> | (Map<string, {
+        userId: string;
+        nickname: string;
+        avatarUrl?: string;
+        state: import('..').ParticipantState;
+        isLocal: boolean;
+        videoTrack: any;
+        audioTrack: any;
+        localStream: {
+            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;
+        };
+        uid?: string;
+        isMuted: boolean;
+        isCameraOn: boolean;
+        isSpeaking: boolean;
+        invitedAt: number;
+        joinedAt?: number;
+    }> & Omit<Map<string, Participant>, keyof Map<any, any>>)>;
+    uidToUserIdMap: import('vue').Ref<Map<string, string> & Omit<Map<string, string>, keyof Map<any, any>>, Map<string, string> | (Map<string, string> & Omit<Map<string, string>, keyof Map<any, any>>)>;
+    acceptedMembers: import('vue').Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+    participantList: import('vue').ComputedRef<Participant[]>;
+    localParticipant: import('vue').ComputedRef<Participant>;
+    activeParticipants: import('vue').ComputedRef<Participant[]>;
+    publishingParticipants: import('vue').ComputedRef<Participant[]>;
+    initSession: (payload: GroupCallSessionState) => void;
+    destroySession: () => void;
+    addParticipant: (participant: Omit<Participant, "invitedAt">) => void;
+    removeParticipant: (userId: string) => void;
+    setParticipantState: (userId: string, state: Participant["state"]) => void;
+    markAccepted: (userId: string) => void;
+    setUidMapping: (uid: string, userId: string) => void;
+    resolveUid: (uid: string) => UidResolution;
+    setVideoTrack: (userId: string, track: Participant["videoTrack"]) => void;
+    setAudioTrack: (userId: string, track: Participant["audioTrack"]) => void;
+    setLocalStream: (userId: string, stream: MediaStream | null) => void;
+    setMuteState: (userId: string, isMuted: boolean) => void;
+    setCameraState: (userId: string, isCameraOn: boolean) => void;
+    setSpeakingState: (userId: string, isSpeaking: boolean) => void;
+    updateParticipantProfile: (userId: string, profile: {
+        nickname?: string;
+        avatarUrl?: string;
+    }) => void;
+}, "participantList" | "localParticipant" | "activeParticipants" | "publishingParticipants">, Pick<{
+    session: import('vue').Ref<{
+        sessionId: string;
+        groupId: string;
+        groupName?: string;
+        callType: "video" | "audio";
+        isActive: boolean;
+        startTime: number;
+    }, GroupCallSessionState | {
+        sessionId: string;
+        groupId: string;
+        groupName?: string;
+        callType: "video" | "audio";
+        isActive: boolean;
+        startTime: number;
+    }>;
+    participants: import('vue').Ref<Map<string, {
+        userId: string;
+        nickname: string;
+        avatarUrl?: string;
+        state: import('..').ParticipantState;
+        isLocal: boolean;
+        videoTrack: any;
+        audioTrack: any;
+        localStream: {
+            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;
+        };
+        uid?: string;
+        isMuted: boolean;
+        isCameraOn: boolean;
+        isSpeaking: boolean;
+        invitedAt: number;
+        joinedAt?: number;
+    }> & Omit<Map<string, Participant>, keyof Map<any, any>>, Map<string, Participant> | (Map<string, {
+        userId: string;
+        nickname: string;
+        avatarUrl?: string;
+        state: import('..').ParticipantState;
+        isLocal: boolean;
+        videoTrack: any;
+        audioTrack: any;
+        localStream: {
+            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;
+        };
+        uid?: string;
+        isMuted: boolean;
+        isCameraOn: boolean;
+        isSpeaking: boolean;
+        invitedAt: number;
+        joinedAt?: number;
+    }> & Omit<Map<string, Participant>, keyof Map<any, any>>)>;
+    uidToUserIdMap: import('vue').Ref<Map<string, string> & Omit<Map<string, string>, keyof Map<any, any>>, Map<string, string> | (Map<string, string> & Omit<Map<string, string>, keyof Map<any, any>>)>;
+    acceptedMembers: import('vue').Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+    participantList: import('vue').ComputedRef<Participant[]>;
+    localParticipant: import('vue').ComputedRef<Participant>;
+    activeParticipants: import('vue').ComputedRef<Participant[]>;
+    publishingParticipants: import('vue').ComputedRef<Participant[]>;
+    initSession: (payload: GroupCallSessionState) => void;
+    destroySession: () => void;
+    addParticipant: (participant: Omit<Participant, "invitedAt">) => void;
+    removeParticipant: (userId: string) => void;
+    setParticipantState: (userId: string, state: Participant["state"]) => void;
+    markAccepted: (userId: string) => void;
+    setUidMapping: (uid: string, userId: string) => void;
+    resolveUid: (uid: string) => UidResolution;
+    setVideoTrack: (userId: string, track: Participant["videoTrack"]) => void;
+    setAudioTrack: (userId: string, track: Participant["audioTrack"]) => void;
+    setLocalStream: (userId: string, stream: MediaStream | null) => void;
+    setMuteState: (userId: string, isMuted: boolean) => void;
+    setCameraState: (userId: string, isCameraOn: boolean) => void;
+    setSpeakingState: (userId: string, isSpeaking: boolean) => void;
+    updateParticipantProfile: (userId: string, profile: {
+        nickname?: string;
+        avatarUrl?: string;
+    }) => void;
+}, "setLocalStream" | "initSession" | "destroySession" | "addParticipant" | "removeParticipant" | "setParticipantState" | "markAccepted" | "setUidMapping" | "resolveUid" | "setVideoTrack" | "setAudioTrack" | "setMuteState" | "setCameraState" | "setSpeakingState" | "updateParticipantProfile">>;

package/dist/modules/groupCall/viewModel/useGroupCallViewModel.d.ts

@@ -0,0 +1,35 @@
+import { ComputedRef, Ref } from 'vue';
+import { RtcService } from '../../../services/RtcService';
+import { Participant } from '../types';
+export interface UseGroupCallViewModelReturn {
+    isActive: ComputedRef<boolean>;
+    participants: ComputedRef<Participant[]>;
+    localParticipant: ComputedRef<Participant | undefined>;
+    callDuration: Ref<number>;
+    selectedParticipantId: Ref<string | null>;
+    startSession: (payload: {
+        sessionId: string;
+        groupId: string;
+        callType: 'video' | 'audio';
+        localUserId: string;
+        localNickname: string;
+        localAvatarUrl?: string;
+    }) => void;
+    addRemoteParticipant: (userId: string, nickname: string, avatarUrl?: string) => void;
+    markRemoteAccepted: (userId: string) => void;
+    bindRtcService: (rtcService: RtcService) => void;
+    unbindRtcService: () => void;
+    sendInvite: (userIds: string[], groupId: string, message: string) => Promise<void>;
+    clearInvitationTimer: (userId: string) => void;
+    hangup: () => Promise<void>;
+    setLocalStream: (stream: MediaStream | null) => void;
+    setLocalMute: (isMuted: boolean) => void;
+    setLocalCamera: (isCameraOn: boolean) => void;
+    setLocalVideoTrack: (track: any) => void;
+    selectParticipant: (userId: string | null) => void;
+}
+/**
+ * useGroupCallViewModel
+ * 群组通话的顶层 ViewModel，连接 Store、MediaBridge、SignalingAdapter
+ */
+export declare function useGroupCallViewModel(): UseGroupCallViewModelReturn;

package/dist/services/CallService.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CallService - 纯资源清理服务
+ *
+ * 职责：通话结束时的 RTC 资源清理、计时器重置、小窗状态重置。
+ * 信令发送和状态机管理由 callkit-core 负责，此处不做任何信令操作。
+ */
+export declare class CallService {
+    private get rtcChannelStore();
+    /**
+     * 清理通话相关资源
+     * 由 useEndCall / useCallKit 在 core hangup 后调用，或 core 失败时回退调用
+     */
+    cleanup(): Promise<void>;
+}
+export declare const callService: CallService;

package/dist/services/RtcAdapter.d.ts

@@ -0,0 +1,11 @@
+import { RtcAdapter, CALL_TYPE } from '../../../../../callkit-core/src/index.ts';
+export interface CoreCallStateLike {
+    type: CALL_TYPE;
+    callerUserId: string;
+    calleeUserId: string;
+}
+export interface CreateRtcAdapterOptions {
+    getCoreCallState: () => CoreCallStateLike;
+    getCurrentUserId: () => string;
+}
+export declare function createRtcAdapter(options: CreateRtcAdapterOptions): RtcAdapter;