mediasfu-angular 2.2.1 → 2.2.3

package/dist/lib/producers/producer-emits/join-local-room.service.d.ts

@@ -1,7 +1,5 @@
 import { Socket } from 'socket.io-client';
-import { ValidateAlphanumeric } from '../../methods/utils/validate-alphanumeric.service';
 import { ResponseJoinLocalRoom, PreJoinPageParameters } from '../../@types/types';
-import { CheckLimitsAndMakeRequest } from '../../methods/utils/check-limits-and-make-request.service';
 import { JoinRoomOnMediaSFU, JoinRoomOnMediaSFUType } from '../../methods/utils/join-room-on-media-sfu.service';
 import * as i0 from "@angular/core";
 export interface JoinLocalRoomOptions {
@@ -28,112 +26,11 @@ export interface CheckMediasfuURLOptions {
     localLink?: string;
 }
 export type CheckMediasfuURLType = (options: CheckMediasfuURLOptions) => Promise<void>;
-/**
- * Checks the MediaSFU URL and processes the necessary actions based on the URL's validity.
- *
- * @param {CheckMediasfuURLOptions} options - The options for checking and handling the MediaSFU URL.
- * @param {ResponseJoinLocalRoom} options.data - The data received from the room join response.
- * @param {string} options.member - The member identifier.
- * @param {string} options.roomName - The name of the room to join.
- * @param {string} options.islevel - The level of the user.
- * @param {Socket} options.socket - The socket instance to use for communication.
- * @param {PreJoinPageParameters} options.parameters - Additional parameters for pre-join page actions.
- * @param {JoinRoomOnMediaSFUType} options.joinMediaSFURoom - The function to join a room on MediaSFU.
- * @param {string} options.localLink - The local link to use for Community Edition.
- *
- * @returns {Promise<void>} A promise that resolves when the actions are complete.
- *
- * @example
- * ```typescript
- * const options = {
- *   data: {
- *     mediasfuURL: "https://example.com/meet/room123/secret",
- *     allowRecord: true,
- *     apiKey: "1234567890123456789012345678901234567890123456789012345678901234",
- *     apiUserName: "user123",
- *   },
- *   member: "user123",
- *   roomName: "s12345678",
- *   islevel: "1",
- *   socket: socketInstance,
- *   parameters: {
- *     someParameter: "value",
- *   },
- *   joinMediaSFURoom: joinRoomOnMediaSFU,
- *   localLink: "https://socketserver.example.com",
- * };
- *
- * try {
- *   await checkMediasfuURL(options);
- *   console.log("MediaSFU URL processed successfully.");
- * } catch (error) {
- *   console.error("Failed to process MediaSFU URL:", error);
- * }
- * ```
- */
 export declare class JoinLocalRoom {
-    private validateAlphanumericService;
-    private checkLimitsService;
     private joinRoomOnMediaSFU;
-    constructor(validateAlphanumericService: ValidateAlphanumeric, checkLimitsService: CheckLimitsAndMakeRequest, joinRoomOnMediaSFU: JoinRoomOnMediaSFU);
-    /**
-     * Checks the MediaSFU URL and processes the necessary actions based on the URL's validity.
-     *
-     * @param {CheckMediasfuURLOptions} options - The options for checking and handling the MediaSFU URL.
-     * @param {ResponseJoinLocalRoom} options.data - The data received from the room join response.
-     * @param {string} options.member - The member identifier.
-     * @param {string} options.roomName - The name of the room to join.
-     * @param {string} options.islevel - The level of the user.
-     * @param {Socket} options.socket - The socket instance to use for communication.
-     * @param {PreJoinPageParameters} options.parameters - Additional parameters for pre-join page actions.
-     * @param {JoinRoomOnMediaSFUType} options.joinMediaSFURoom - The function to join a room on MediaSFU.
-     * @param {string} options.localLink - The local link to use for Community Edition.
-     *
-     * @returns {Promise<void>} A promise that resolves when the actions are complete.
-     *
-     * @example
-     * ```typescript
-     * const options = {
-     *   data: {
-     *     mediasfuURL: "https://example.com/meet/room123/secret",
-     *     allowRecord: true,
-     *     apiKey: "1234567890123456789012345678901234567890123456789012345678901234",
-     *     apiUserName: "user123",
-     *   },
-     *   member: "user123",
-     *   roomName: "s12345678",
-     *   islevel: "1",
-     *   socket: socketInstance,
-     *   parameters: {
-     *     someParameter: "value",
-     *   },
-     *   joinMediaSFURoom: joinRoomOnMediaSFU,
-     *   localLink: "https://socketserver.example.com",
-     * };
-     *
-     * try {
-     *   await checkMediasfuURL(options);
-     *   console.log("MediaSFU URL processed successfully.");
-     * } catch (error) {
-     *   console.error("Failed to process MediaSFU URL:", error);
-     * }
-     * ```
-     */
-    joinLocalRoom(options: JoinLocalRoomOptions): Promise<ResponseJoinLocalRoom>;
-    /**
-     * Checks the MediaSFU URL and processes necessary actions based on its validity.
-     *
-     * @param {Object} options - Contains:
-     *   - `data`: Data received from the room join response.
-     *   - `member`: User identifier.
-     *   - `roomName`: Name of the room to join.
-     *   - `islevel`: User's level indicator.
-     *   - `socket`: Socket instance for communication.
-     *   - `parameters`: Additional parameters for pre-join page actions.
-     *   - `joinMediaSFURoom`: Function to join a room on MediaSFU.
-     *   - `localLink`: Local link to use for Community Edition.
-     */
-    private checkMediasfuURL;
+    constructor(joinRoomOnMediaSFU: JoinRoomOnMediaSFU);
+    checkMediasfuURL: CheckMediasfuURLType;
+    joinLocalRoom: JoinLocalRoomType;
     static ɵfac: i0.ɵɵFactoryDeclaration<JoinLocalRoom, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<JoinLocalRoom>;
 }

package/dist/lib/producers/producer-emits/join-room.service.d.ts

@@ -1,5 +1,4 @@
 import { Socket } from 'socket.io-client';
-import { ValidateAlphanumeric } from '../../methods/utils/validate-alphanumeric.service';
 import * as i0 from "@angular/core";
 export interface JoinRoomOptions {
     socket: Socket;
@@ -49,23 +48,6 @@ export type JoinRoomType = (socket: Socket, roomName: string, islevel: string, m
  * ```
  */
 export declare class JoinRoom {
-    private validateAlphanumeric;
-    constructor(validateAlphanumeric: ValidateAlphanumeric);
-    /**
-     * Joins a user to a specified room via a socket connection.
-     *
-     * @param {Object} options - The options for joining the room.
-     * @param {Socket} options.socket - The socket instance to use for communication.
-     * @param {string} options.roomName - The name of the room to join.
-     * @param {string} options.islevel - The level of the user.
-     * @param {string} options.member - The member identifier.
-     * @param {string} options.sec - The security token.
-     * @param {string} options.apiUserName - The API username of the user.
-     *
-     * @returns {Promise<object>} A promise that resolves with the data received from the 'joinRoom' event or rejects with a validation error.
-     *
-     * @throws {Error} Throws an error if the user is banned, suspended, or if the host has not joined the room yet.
-     */
     joinRoom({ socket, roomName, islevel, member, sec, apiUserName, }: JoinRoomOptions): Promise<object>;
     static ɵfac: i0.ɵɵFactoryDeclaration<JoinRoom, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<JoinRoom>;

package/dist/lib/producers/socket-receive-methods/added-as-panelist.service.d.ts

@@ -0,0 +1,15 @@
+import { ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface AddedAsPanelistData {
+    message: string;
+}
+export interface AddedAsPanelistOptions {
+    data: AddedAsPanelistData;
+    showAlert?: ShowAlert;
+}
+export type AddedAsPanelistType = (options: AddedAsPanelistOptions) => Promise<void>;
+export declare class AddedAsPanelist {
+    addedAsPanelist({ data, showAlert, }: AddedAsPanelistOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AddedAsPanelist, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AddedAsPanelist>;
+}

package/dist/lib/producers/socket-receive-methods/all-members-rest.service.d.ts

@@ -57,97 +57,8 @@ export interface AllMembersRestOptions {
     apiToken: string;
 }
 export type AllMembersRestType = (options: AllMembersRestOptions) => Promise<void>;
-/**
- * Manages participant settings and UI updates, including connecting IPs, reordering streams,
- * updating settings, and handling participant display based on various session parameters.
- *
- * @async
- * @param {AllMembersRestOptions} options - Parameters for managing members.
- * @param {Participant[]} options.members - The array of participant objects.
- * @param {Settings} options.settings - The session settings for audio, video, screenshare, and chat.
- * @param {string} [options.coHoste] - The current co-host name.
- * @param {CoHostResponsibility[]} [options.coHostRes] - The responsibilities assigned to the co-host.
- * @param {AllMembersRestParameters} options.parameters - Additional parameters for managing members and UI updates.
- * @param {ConsumeSocket[]} options.consume_sockets - Array of sockets for participant communication.
- * @param {string} options.apiUserName - API username for authentication.
- * @param {string} options.apiKey - API key for authentication.
- * @param {string} options.apiToken - API token for authentication.
- *
- * @returns {Promise<void>} A promise that resolves when updates and changes for members are completed.
- *
- * @example
- * ```typescript
- * const allMembersRestService = new AllMembersRest();
- * await allMembersRestService.allMembersRest({
- *   members: [{ name: 'John', isBanned: false, isSuspended: false, audioID: '123', videoID: '456' }],
- *   settings: ['enabled', 'HD', 'allowed', 'public'],
- *   coHoste: 'Jane',
- *   coHostRes: ['manage-chat'],
- *   parameters: {
- *     participantsAll: [],
- *     participants: [],
- *     dispActiveNames: ['John'],
- *     requestList: [],
- *     coHost: '',
- *     coHostResponsibility: [],
- *     lock_screen: false,
- *     firstAll: false,
- *     membersReceived: false,
- *     roomRecvIPs: [],
- *     deferScreenReceived: false,
- *     screenId: null,
- *     shareScreenStarted: false,
- *     meetingDisplayType: 'grid',
- *     audioSetting: '',
- *     videoSetting: '',
- *     screenshareSetting: '',
- *     chatSetting: '',
- *     socket: mySocket,
- *     updateParticipantsAll: (participantsAll) => console.log(participantsAll),
- *     updateParticipants: (participants) => console.log(participants),
- *     updateRequestList: (requestList) => console.log(requestList),
- *     updateCoHost: (coHost) => console.log(coHost),
- *     updateCoHostResponsibility: (coHostRes) => console.log(coHostRes),
- *     updateFirstAll: (firstAll) => console.log(firstAll),
- *     updateMembersReceived: (membersReceived) => console.log(membersReceived),
- *     updateDeferScreenReceived: (deferScreenReceived) => console.log(deferScreenReceived),
- *     updateShareScreenStarted: (shareScreenStarted) => console.log(shareScreenStarted),
- *     updateAudioSetting: (audioSetting) => console.log(audioSetting),
- *     updateVideoSetting: (videoSetting) => console.log(videoSetting),
- *     updateScreenshareSetting: (screenshareSetting) => console.log(screenshareSetting),
- *     updateChatSetting: (chatSetting) => console.log(chatSetting),
- *     updateConsume_sockets: (sockets) => console.log(sockets),
- *     updateRoomRecvIPs: (ips) => console.log(ips),
- *     updateIsLoadingModalVisible: (visible) => console.log(visible),
- *     onScreenChanges: (params) => console.log('onScreenChanges called with', params),
- *     connectIps: async (params) => [['socket1'], ['ip1']],
- *     connectLocalIps: async (params) => [['socket1'], ['ip1']],
- *     sleep: async ({ ms }) => new Promise((resolve) => setTimeout(resolve, ms)),
- *     reorderStreams: async (params) => console.log('reorderStreams called with', params),
- *   },
- *   consume_sockets: [{ socketId: 'abc123' }],
- *   apiUserName: 'testUser',
- *   apiKey: 'apiKeyExample',
- *   apiToken: 'apiTokenExample',
- * });
- * ```
- */
 export declare class AllMembersRest {
-    /**
-     * Handles various tasks related to participant management and UI updates.
-     * @param {Object} params - The parameters passed to the allMembersRest method.
-     * @param {Array} params.members - The array of participant members.
-     * @param {Array} params.settings - The array of settings.
-     * @param {boolean} params.coHoste - The co-host state.
-     * @param {boolean} params.coHostRes - The co-host responsibility state.
-     * @param {Object} params.parameters - The object containing parameters for the allMembersRest method.
-     * @param {Array} params.consume_sockets - The array of consume sockets.
-     * @param {string} params.apiUserName - The API username.
-     * @param {string} params.apiKey - The API key.
-     * @param {string} params.apiToken - The API token.
-     * @returns {void} - No return value.
-     */
-    allMembersRest({ members, settings, coHoste, coHostRes, parameters, consume_sockets, apiUserName, apiKey, apiToken, }: AllMembersRestOptions): Promise<void>;
+    allMembersRest(options: AllMembersRestOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AllMembersRest, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AllMembersRest>;
 }

package/dist/lib/producers/socket-receive-methods/all-members.service.d.ts

@@ -54,95 +54,8 @@ export interface AllMembersOptions {
     apiToken: string;
 }
 export type AllMembersType = (options: AllMembersOptions) => Promise<void>;
-/**
- * Manages participant-related operations, including updates for participant lists, requests, co-host settings,
- * and other session details. This method filters out banned and suspended participants, reorders streams,
- * connects IPs, and updates the UI.
- *
- * @async
- * @param {AllMembersOptions} options - Parameters for managing all members.
- * @param {Participant[]} options.members - The array of participant objects.
- * @param {Request[]} options.requestss - The list of requests from participants.
- * @param {string} options.coHoste - The current co-host name.
- * @param {CoHostResponsibility[]} options.coHostRes - The responsibilities assigned to the co-host.
- * @param {AllMembersParameters} options.parameters - Additional parameters for member management and UI updates.
- * @param {ConsumeSocket[]} options.consume_sockets - Array of sockets for participant communication.
- * @param {string} options.apiUserName - API username for authentication.
- * @param {string} options.apiKey - API key for authentication.
- * @param {string} options.apiToken - API token for authentication.
- *
- * @returns {Promise<void>} A promise that resolves when all members have been processed and updates are complete.
- *
- * @example
- * ```typescript
- * const allMembersService = new AllMembers();
- * await allMembersService.allMembers({
- *   members: [{ name: 'John', isBanned: false, isSuspended: false, audioID: '123', videoID: '456' }],
- *   requestss: [{ id: '1', name: 'Jane', type: 'fa-microphone' }],
- *   coHoste: 'Jane',
- *   coHostRes: ['manage-chat'],
- *   parameters: {
- *     participantsAll: [],
- *     participants: [],
- *     dispActiveNames: ['John'],
- *     requestList: [],
- *     coHost: '',
- *     coHostResponsibility: [],
- *     lock_screen: false,
- *     firstAll: false,
- *     membersReceived: false,
- *     roomRecvIPs: [],
- *     deferScreenReceived: false,
- *     screenId: null,
- *     shareScreenStarted: false,
- *     meetingDisplayType: 'grid',
- *     hostFirstSwitch: false,
- *     waitingRoomList: [],
- *     islevel: '1',
- *     socket: socket,
- *     updateParticipantsAll: (participantsAll) => console.log(participantsAll),
- *     updateParticipants: (participants) => console.log(participants),
- *     updateRequestList: (requestList) => console.log(requestList),
- *     updateCoHost: (coHost) => console.log(coHost),
- *     updateCoHostResponsibility: (coHostRes) => console.log(coHostRes),
- *     updateFirstAll: (firstAll) => console.log(firstAll),
- *     updateMembersReceived: (membersReceived) => console.log(membersReceived),
- *     updateDeferScreenReceived: (deferScreenReceived) => console.log(deferScreenReceived),
- *     updateShareScreenStarted: (shareScreenStarted) => console.log(shareScreenStarted),
- *     updateHostFirstSwitch: (hostFirstSwitch) => console.log(hostFirstSwitch),
- *     updateConsume_sockets: (sockets) => console.log(sockets),
- *     updateRoomRecvIPs: (ips) => console.log(ips),
- *     updateIsLoadingModalVisible: (visible) => console.log(visible),
- *     updateTotalReqWait: (total) => console.log(total),
- *     onScreenChanges: (params) => console.log('onScreenChanges called with', params),
- *     connectIps: async (params) => [['socket1'], ['ip1']],
- *     connectLocalIps: async (params) => [['socket1'], ['ip1']],
- *     sleep: async ({ ms }) => new Promise((resolve) => setTimeout(resolve, ms)),
- *     reorderStreams: async (params) => console.log('reorderStreams called with', params),
- *   },
- *   consume_sockets: [{ socketId: 'abc123' }],
- *   apiUserName: 'testUser',
- *   apiKey: 'apiKeyExample',
- *   apiToken: 'apiTokenExample',
- * });
- * ```
- */
 export declare class AllMembers {
-    /**
-     * allMembers - A method for handling various tasks related to participant management and UI updates.
-     * @param {Object} params - The parameters passed to the allMembers method.
-     * @param {Array} params.members - The array of participant members.
-     * @param {Array} params.requestss - The array of requests.
-     * @param {boolean} params.coHoste - The co-host state.
-     * @param {boolean} params.coHostRes - The co-host responsibility state.
-     * @param {Object} params.parameters - The object containing parameters for the allMembers method.
-     * @param {Array} params.consume_sockets - The array of consume sockets.
-     * @param {string} params.apiUserName - The API username.
-     * @param {string} params.apiKey - The API key.
-     * @param {string} params.apiToken - The API token.
-     * @returns {void} - No return value.
-     */
-    allMembers: ({ members, requestss, coHoste, coHostRes, parameters, consume_sockets, apiUserName, apiKey, apiToken, }: AllMembersOptions) => Promise<void>;
+    allMembers: (options: AllMembersOptions) => Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AllMembers, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AllMembers>;
 }

package/dist/lib/producers/socket-receive-methods/control-media-host.service.d.ts

@@ -25,73 +25,8 @@ export interface ControlMediaHostOptions {
     parameters: ControlMediaHostParameters;
 }
 export type ControlMediaHostType = (options: ControlMediaHostOptions) => Promise<void>;
-/**
- * Service for controlling participant media in a session, with options to manage audio, video, screenshare, and chat functionalities.
- *
- * @class
- * @name ControlMediaHost
- * @description This service provides the host with control over a participant's media (audio, video, screenshare, chat), with options to enable or disable these functionalities individually or all at once.
- *
- * @method
- * controlMediaHost
- * @async
- * @param {ControlMediaHostOptions} options - Options to specify which media type to control and provide necessary parameters.
- * @param {string} options.type - The media type to control ('audio', 'video', 'screenshare', 'chat', 'all').
- * @param {ControlMediaHostParameters} options.parameters - Additional parameters, functions, and media streams necessary to perform the media control operations.
- *
- * @returns {Promise<void>} - A promise that resolves when the media control operation is complete.
- *
- * @example
- * ```typescript
- * const controlMediaHostService = new ControlMediaHost();
- * await controlMediaHostService.controlMediaHost({
- *   type: 'audio',
- *   parameters: {
- *     updateAdminRestrictSetting: (value) => console.log(value),
- *     localStream: myLocalStream,
- *     updateLocalStream: (stream) => console.log(stream),
- *     updateAudioAlreadyOn: (value) => console.log(value),
- *     onScreenChanges: async () => { },
- *     disconnectSendTransportAudio: async () => { },
- *     getUpdatedAllParams: () => ({ }),
- *   }
- * });
- * ```
- *
- * @remarks
- * - This function handles the control of audio, video, screenshare, or chat for a participant based on the specified type.
- * - For `all` type, it sequentially controls each media type to ensure all are turned off.
- */
 export declare class ControlMediaHost {
-    /**
-     * Controls the media (audio, video, screenshare, chat) of a participant as a host.
-     *
-     * @param {object} options - The function parameters.
-     * @param {string} options.type - The type of media to control ('audio', 'video', 'screenshare', 'chat', 'all').
-     * @param {object} options.parameters - Additional parameters needed for the function.
-     * @param {boolean} options.parameters.adminRestrictSetting - The setting to restrict host control.
-     * @param {function} options.parameters.updateAdminRestrictSetting - Function to update the adminRestrictSetting.
-     * @param {MediaStream} options.parameters.localStream - The local audio and video stream.
-     * @param {function} options.parameters.updateLocalStream - Function to update the local audio and video stream.
-     * @param {boolean} options.parameters.audioAlreadyOn - Indicates whether audio is currently on.
-     * @param {function} options.parameters.updateAudioAlreadyOn - Function to update the audioAlreadyOn status.
-     * @param {MediaStream} options.parameters.localStreamScreen - The local screenshare stream.
-     * @param {function} options.parameters.updateLocalStreamScreen - Function to update the local screenshare stream.
-     * @param {MediaStream} options.parameters.localStreamVideo - The local video stream.
-     * @param {function} options.parameters.updateLocalStreamVideo - Function to update the local video stream.
-     * @param {boolean} options.parameters.screenAlreadyOn - Indicates whether screenshare is currently on.
-     * @param {function} options.parameters.updateScreenAlreadyOn - Function to update the screenAlreadyOn status.
-     * @param {boolean} options.parameters.videoAlreadyOn - Indicates whether video is currently on.
-     * @param {function} options.parameters.updateVideoAlreadyOn - Function to update the videoAlreadyOn status.
-     * @param {boolean} options.parameters.chatAlreadyOn - Indicates whether chat is currently on.
-     * @param {function} options.parameters.updateChatAlreadyOn - Function to update the chatAlreadyOn status.
-     * @param {function} options.parameters.onScreenChanges - Function to handle changes in screen status.
-     * @param {function} options.parameters.stopShareScreen - Function to stop sharing the screen.
-     * @param {function} options.parameters.disconnectSendTransportVideo - Function to disconnect video send transport.
-     * @param {function} options.parameters.disconnectSendTransportAudio - Function to disconnect audio send transport.
-     * @param {function} options.parameters.disconnectSendTransportScreen - Function to disconnect screenshare send transport.
-     */
-    controlMediaHost: ({ type, parameters }: ControlMediaHostOptions) => Promise<void>;
+    controlMediaHost: (options: ControlMediaHostOptions) => Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ControlMediaHost, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ControlMediaHost>;
 }

package/dist/lib/producers/socket-receive-methods/get-domains.service.d.ts

@@ -1,6 +1,7 @@
 import { ConnectIpsType, ConnectIpsParameters, AltDomains, ConsumeSocket } from '../../@types/types';
-import { RtpCapabilities } from 'mediasoup-client/lib/types';
+import { types } from 'mediasoup-client';
 import * as i0 from "@angular/core";
+type RtpCapabilities = types.RtpCapabilities;
 export interface GetDomainsParameters extends ConnectIpsParameters {
     roomRecvIPs: string[];
     rtpCapabilities: RtpCapabilities | null;
@@ -61,3 +62,4 @@ export declare class GetDomains {
     static ɵfac: i0.ɵɵFactoryDeclaration<GetDomains, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<GetDomains>;
 }
+export {};

package/dist/lib/producers/socket-receive-methods/meeting-still-there.service.d.ts

@@ -34,7 +34,7 @@ export declare class MeetingStillThere {
      * @param {Function} options.updateIsConfirmHereModalVisible - Function to update the visibility of the "still there?" modal.
      * @returns {Promise<void>} A promise that resolves when the modal visibility is updated.
      */
-    meetingStillThere: ({ updateIsConfirmHereModalVisible }: MeetingStillThereOptions) => void;
+    meetingStillThere: ({ updateIsConfirmHereModalVisible }: MeetingStillThereOptions) => Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<MeetingStillThere, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MeetingStillThere>;
 }

package/dist/lib/producers/socket-receive-methods/panelist-focus-changed.service.d.ts

@@ -0,0 +1,25 @@
+import { Participant } from '../../@types/types';
+import { PanelistData } from './panelists-updated.service';
+import * as i0 from "@angular/core";
+export interface PanelistFocusChangedData {
+    focusEnabled: boolean;
+    panelists: PanelistData[];
+    muteOthersMic: boolean;
+    muteOthersCamera: boolean;
+}
+export interface PanelistFocusChangedOptions {
+    data: PanelistFocusChangedData;
+    updatePanelistsFocused?: (focused: boolean) => void;
+    updateMuteOthersMic?: (mute: boolean) => void;
+    updateMuteOthersCamera?: (mute: boolean) => void;
+    updatePanelists?: (panelists: Participant[]) => void;
+    currentPanelistsFocused?: boolean;
+    currentPanelists?: Participant[];
+    onScreenChanges?: () => Promise<void>;
+}
+export type PanelistFocusChangedType = (options: PanelistFocusChangedOptions) => Promise<void>;
+export declare class PanelistFocusChanged {
+    panelistFocusChanged({ data, updatePanelistsFocused, updateMuteOthersMic, updateMuteOthersCamera, updatePanelists, currentPanelistsFocused, currentPanelists, onScreenChanges, }: PanelistFocusChangedOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PanelistFocusChanged, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PanelistFocusChanged>;
+}

package/dist/lib/producers/socket-receive-methods/panelists-updated.service.d.ts

@@ -0,0 +1,19 @@
+import { Participant } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface PanelistData {
+    id: string;
+    name: string;
+}
+export interface PanelistsUpdatedData {
+    panelists: PanelistData[];
+}
+export interface PanelistsUpdatedOptions {
+    data: PanelistsUpdatedData;
+    updatePanelists?: (panelists: Participant[]) => void;
+}
+export type PanelistsUpdatedType = (options: PanelistsUpdatedOptions) => Promise<void>;
+export declare class PanelistsUpdated {
+    panelistsUpdated({ data, updatePanelists, }: PanelistsUpdatedOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PanelistsUpdated, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PanelistsUpdated>;
+}

package/dist/lib/producers/socket-receive-methods/permission-config-updated.service.d.ts

@@ -0,0 +1,15 @@
+import { PermissionConfig } from '../../methods/permissions-methods/update-permission-config.service';
+import * as i0 from "@angular/core";
+export interface PermissionConfigUpdatedData {
+    config: PermissionConfig;
+}
+export interface PermissionConfigUpdatedOptions {
+    data: PermissionConfigUpdatedData;
+    updatePermissionConfig?: (config: PermissionConfig) => void;
+}
+export type PermissionConfigUpdatedType = (options: PermissionConfigUpdatedOptions) => Promise<void>;
+export declare class PermissionConfigUpdated {
+    permissionConfigUpdated({ data, updatePermissionConfig, }: PermissionConfigUpdatedOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionConfigUpdated, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PermissionConfigUpdated>;
+}

package/dist/lib/producers/socket-receive-methods/permission-updated.service.d.ts

@@ -0,0 +1,17 @@
+import { ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface PermissionUpdatedData {
+    newLevel: string;
+    message?: string;
+}
+export interface PermissionUpdatedOptions {
+    data: PermissionUpdatedData;
+    showAlert?: ShowAlert;
+    updateIslevel?: (level: string) => void;
+}
+export type PermissionUpdatedType = (options: PermissionUpdatedOptions) => Promise<void>;
+export declare class PermissionUpdated {
+    permissionUpdated({ data, showAlert, updateIslevel, }: PermissionUpdatedOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionUpdated, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PermissionUpdated>;
+}

package/dist/lib/producers/socket-receive-methods/person-joined.service.d.ts

@@ -39,7 +39,7 @@ export declare class PersonJoined {
      * @param {Function} options.showAlert - A function to display an alert/notification.
      * @returns {Promise<void>} A promise that resolves when the alert has been shown.
      */
-    personJoined: ({ name, showAlert }: PersonJoinedOptions) => void;
+    personJoined: ({ name, showAlert }: PersonJoinedOptions) => Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<PersonJoined, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PersonJoined>;
 }

package/dist/lib/producers/socket-receive-methods/producer-media-paused.service.d.ts

@@ -26,87 +26,7 @@ export interface ProducerMediaPausedOptions {
     parameters: ProducerMediaPausedParameters;
 }
 export type ProducerMediaPausedType = (options: ProducerMediaPausedOptions) => Promise<void>;
-/**
- * Service to handle the paused state of media for a producer.
- *
- * @class
- * @name ProducerMediaPaused
- * @description
- * Handles the actions required when media is paused for a specified producer, including UI updates, participant state handling, and managing meeting display optimizations.
- *
- * @method
- * producerMediaPaused
- *
- * @param {ProducerMediaPausedOptions} options - Options to specify the producer and event details:
- *   - `producerId` {string}: The ID of the paused producer.
- *   - `kind` {string}: The type of media paused (e.g., "audio", "video").
- *   - `name` {string}: Name of the producer whose media is paused.
- *   - `parameters` {ProducerMediaPausedParameters}: Configuration and state parameters for the meeting.
- *      - `activeSounds` {string[]}: Active audio streams currently displayed.
- *      - `meetingDisplayType` {string}: Current meeting layout type (e.g., "media", "video").
- *      - `meetingVideoOptimized` {boolean}: Indicates if video is optimized.
- *      - `participants` {Participant[]}: List of all meeting participants.
- *      - `oldSoundIds` {string[]}: List of previously active audio stream IDs.
- *      - `shared` {boolean}: Indicates if the screen is currently shared.
- *      - `shareScreenStarted` {boolean}: Indicates if screen sharing has started.
- *      - `updateMainWindow` {boolean}: Specifies if the main display window should update.
- *      - `hostLabel` {string}: The label representing the host participant.
- *      - `islevel` {string}: The access level of the participant.
- *      - `updateActiveSounds` {Function}: Updates the list of active audio streams.
- *      - `updateUpdateMainWindow` {Function}: Updates the status of the main display window.
- *      - `reorderStreams` {Function}: Reorders media streams for optimized display.
- *      - `prepopulateUserMedia` {Function}: Preloads user media based on display needs.
- *      - `reUpdateInter` {Function}: Refreshes participant interactions on the UI.
- *
- * @returns {Promise<void>} Resolves when media pause handling is complete.
- *
- * @example
- * const options = {
- *   producerId: '12345',
- *   kind: 'audio',
- *   name: 'Participant A',
- *   parameters: {
- *     activeSounds: ['Participant B'],
- *     meetingDisplayType: 'video',
- *     meetingVideoOptimized: false,
- *     participants: [...],
- *     oldSoundIds: ['Participant A'],
- *     shared: false,
- *     shareScreenStarted: false,
- *     updateMainWindow: true,
- *     hostLabel: 'Host',
- *     islevel: '1',
- *     updateActiveSounds: (sounds) => { ... },
- *     updateUpdateMainWindow: (status) => { ... },
- *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },
- *     prepopulateUserMedia: ({ name, parameters }) => { ... },
- *     reUpdateInter: ({ name, add, force, parameters }) => { ... }
- *   }
- * };
- *
- * producerMediaPausedService.producerMediaPaused(options)
- *   .then(() => console.log('Media pause handled'))
- *   .catch(error => console.error('Error:', error));
- */
 export declare class ProducerMediaPaused {
-    /**
-     * Handles the event when media is paused for a producer.
-     *
-     * @param {ProducerMediaPausedOptions} options - The options for the producer media paused event.
-     * @param {string} options.producerId - The ID of the producer.
-     * @param {string} options.kind - The kind of media (e.g., "audio", "video").
-     * @param {string} options.name - The name of the producer.
-     * @param {Parameters} options.parameters - The parameters for the event.
-     *
-     * @returns {Promise<void>} A promise that resolves when the media paused handling is complete.
-     *
-     * @description
-     * This function handles the event when media is paused for a producer. It performs the following tasks:
-     * - Updates the parameters.
-     * - Iterates through participants and updates the UI based on their muted status and other conditions.
-     * - Handles meeting display type and optimizes the UI accordingly.
-     * - Manages audio media by updating the relevant participant's state.
-     */
     producerMediaPaused: ({ producerId, kind, name, parameters, }: ProducerMediaPausedOptions) => Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProducerMediaPaused, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ProducerMediaPaused>;

package/dist/lib/producers/socket-receive-methods/producer-media-resumed.service.d.ts

@@ -83,7 +83,7 @@ export declare class ProducerMediaResumed {
      *
      * @returns {Promise<void>} A promise that resolves when the media has been resumed.
      */
-    producerMediaResumed: ({ name, parameters, }: ProducerMediaResumedOptions) => Promise<void>;
+    producerMediaResumed: ({ name, kind, parameters, }: ProducerMediaResumedOptions) => Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProducerMediaResumed, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ProducerMediaResumed>;
 }