mediasfu-angular 1.0.0

package/dist/lib/methods/waiting-methods/respond-to-waiting.service.d.ts

@@ -0,0 +1,31 @@
+import { Socket } from 'socket.io-client';
+import { WaitingRoomParticipant } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface RespondToWaitingOptions {
+    participantId: string;
+    participantName: string;
+    updateWaitingList: (waitingList: WaitingRoomParticipant[]) => void;
+    waitingList: WaitingRoomParticipant[];
+    type: string | boolean;
+    roomName: string;
+    socket: Socket;
+}
+export type RespondToWaitingType = (options: RespondToWaitingOptions) => Promise<void>;
+export declare class RespondToWaiting {
+    /**
+     * Responds to a participant waiting to join a room by either allowing or denying their entry.
+     *
+     * @param {Object} options - The options for responding to the waiting participant.
+     * @param {string} options.participantId - The ID of the participant.
+     * @param {string} options.participantName - The name of the participant.
+     * @param {Function} options.updateWaitingList - The function to update the waiting list.
+     * @param {Array} options.waitingList - The current waiting list of participants.
+     * @param {boolean | string} options.type - The type of response, either "true" or "false".
+     * @param {string} options.roomName - The name of the room.
+     * @param {Object} options.socket - The socket instance to emit events.
+     * @returns {Promise<void>} - A promise that resolves when the response has been processed.
+     */
+    respondToWaiting({ participantId, participantName, updateWaitingList, waitingList, type, roomName, socket, }: RespondToWaitingOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RespondToWaiting, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RespondToWaiting>;
+}

package/dist/lib/methods/whiteboard-methods/capture-canvas-stream.service.d.ts

@@ -0,0 +1,33 @@
+import { Producer } from 'mediasoup-client/lib/types';
+import { ConnectSendTransportScreenType, CreateSendTransportType, DisconnectSendTransportScreenType, SleepType, CreateSendTransportParameters, DisconnectSendTransportScreenParameters, ConnectSendTransportScreenParameters } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface CaptureCanvasStreamParameters extends CreateSendTransportParameters, DisconnectSendTransportScreenParameters, ConnectSendTransportScreenParameters {
+    canvasWhiteboard: HTMLCanvasElement | null;
+    canvasStream: MediaStream | null;
+    updateCanvasStream: (stream: MediaStream | null) => void;
+    screenProducer: Producer | null;
+    transportCreated: boolean;
+    updateScreenProducer: (producer: Producer | null) => void;
+    sleep: SleepType;
+    createSendTransport: CreateSendTransportType;
+    connectSendTransportScreen: ConnectSendTransportScreenType;
+    disconnectSendTransportScreen: DisconnectSendTransportScreenType;
+    getUpdatedAllParams: () => CaptureCanvasStreamParameters;
+    [key: string]: any;
+}
+export interface CaptureCanvasStreamOptions {
+    parameters: CaptureCanvasStreamParameters;
+    start?: boolean;
+}
+export type CaptureCanvasStreamType = (options: CaptureCanvasStreamOptions) => Promise<void>;
+export declare class CaptureCanvasStream {
+    /**
+     * Capture the canvas stream.
+     * @param {Object} parameters - The parameters object.
+     * @param {boolean} [start=true] - Indicates whether to start capturing the stream.
+     * @returns {Promise<void>} - A promise that resolves when the canvas stream is captured.
+     */
+    captureCanvasStream: ({ parameters, start, }: CaptureCanvasStreamOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CaptureCanvasStream, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CaptureCanvasStream>;
+}

package/dist/lib/methods/whiteboard-methods/launch-configure-whiteboard.service.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+export interface LaunchConfigureWhiteboardOptions {
+    updateIsConfigureWhiteboardModalVisible: (visible: boolean) => void;
+    isConfigureWhiteboardModalVisible: boolean;
+}
+export type LaunchConfigureWhiteboardType = (options: LaunchConfigureWhiteboardOptions) => void;
+export declare class LaunchConfigureWhiteboard {
+    /**
+     * Toggles the visibility of the configure whiteboard modal.
+     *
+     * @param updateIsConfigureWhiteboardModalVisible - Function to update the visibility state of the configure whiteboard modal.
+     * @param isConfigureWhiteboardModalVisible - Current visibility state of the configure whiteboard modal.
+     */
+    launchConfigureWhiteboard({ updateIsConfigureWhiteboardModalVisible, isConfigureWhiteboardModalVisible, }: LaunchConfigureWhiteboardOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaunchConfigureWhiteboard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaunchConfigureWhiteboard>;
+}

package/dist/lib/producer-client/producer-client-emits/create-device-client.service.d.ts

@@ -0,0 +1,20 @@
+import { RtpCapabilities, Device } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export interface CreateDeviceClientOptions {
+    rtpCapabilities: RtpCapabilities | null;
+}
+export type CreateDeviceClientType = (options: CreateDeviceClientOptions) => Promise<Device | null>;
+export declare class CreateDeviceClient {
+    /**
+     * Creates a mediasoup client device with the provided RTP capabilities.
+     *
+     * @param {CreateDeviceClientOptions} options - The options for creating the device client.
+     * @param {RTPCapabilities} options.rtpCapabilities - The RTP capabilities required for the device.
+     * @returns {Promise<Device | null>} A promise that resolves to the created Device or null if creation fails.
+     * @throws {Error} Throws an error if the required parameters are not provided or if device creation is not supported.
+     *
+     */
+    createDeviceClient({ rtpCapabilities }: CreateDeviceClientOptions): Promise<Device | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateDeviceClient, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateDeviceClient>;
+}

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

@@ -0,0 +1,36 @@
+import { JoinRoom } from '../../producers/producer-emits/join-room.service';
+import { JoinConRoom } from '../../producers/producer-emits/join-con-room.service';
+import { Socket } from 'socket.io-client';
+import * as i0 from "@angular/core";
+export interface JoinRoomClientOptions {
+    socket: Socket;
+    roomName: string;
+    islevel: string;
+    member: string;
+    sec: string;
+    apiUserName: string;
+    consume?: boolean;
+}
+export type JoinRoomClientType = (params: JoinRoomClientOptions) => Promise<any>;
+export declare class JoinRoomClient {
+    private JoinRoomService;
+    private JoinConRoomService;
+    constructor(JoinRoomService: JoinRoom, JoinConRoomService: JoinConRoom);
+    /**
+     * Joins a room by emitting the `joinRoom` event to the server using the provided socket.
+     *
+     * @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 {boolean} options.islevel - The level indicator for the room.
+     * @param {string} options.member - The member identifier.
+     * @param {string} options.sec - The security token or identifier.
+     * @param {string} options.apiUserName - The API username for authentication.
+     * @param {boolean} [options.consume=false] - Flag to determine which join function to use.
+     * @returns {Promise<any>} A promise that resolves with the data returned from the server.
+     * @throws {Error} Throws an error if the room joining process fails.
+     */
+    joinRoomClient({ socket, roomName, islevel, member, sec, apiUserName, consume, }: JoinRoomClientOptions): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JoinRoomClient, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JoinRoomClient>;
+}

package/dist/lib/producer-client/producer-client-emits/update-room-parameters-client.service.d.ts

@@ -0,0 +1,104 @@
+import { VideoCaptureConstraints } from '../../methods/utils/producer/video-capture-constraints.service';
+import { HParams, HParamsType } from '../../methods/utils/producer/h-params.service';
+import { VParams, VParamsType } from '../../methods/utils/producer/v-params.service';
+import { ScreenParams } from '../../methods/utils/producer/screen-params.service';
+import { AParams } from '../../methods/utils/producer/a-params.service';
+import { RtpCapabilities } from 'mediasoup-client/lib/types';
+import { EventType, ShowAlert, ResponseJoinRoom, ScreenParamsType, AParamsType, MeetingRoomParams } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface UpdateRoomParametersClientParameters {
+    rtpCapabilities: RtpCapabilities | null;
+    roomRecvIPs: string[];
+    meetingRoomParams: MeetingRoomParams | null;
+    itemPageLimit: number;
+    audioOnlyRoom: boolean;
+    addForBasic: boolean;
+    screenPageLimit: number;
+    shareScreenStarted: boolean;
+    shared: boolean;
+    targetOrientation: string;
+    vidCons: any;
+    recordingVideoSupport: boolean;
+    frameRate: number;
+    adminPasscode: string;
+    eventType: EventType;
+    youAreCoHost: boolean;
+    autoWave: boolean;
+    forceFullDisplay: boolean;
+    chatSetting: string;
+    meetingDisplayType: string;
+    audioSetting: string;
+    videoSetting: string;
+    screenshareSetting: string;
+    hParams: HParamsType;
+    vParams: VParamsType;
+    screenParams: ScreenParamsType;
+    aParams: AParamsType;
+    islevel: string;
+    showAlert?: ShowAlert;
+    data: ResponseJoinRoom;
+    updateRtpCapabilities: (rtpCapabilities: RtpCapabilities | null) => void;
+    updateRoomRecvIPs: (roomRecvIPs: string[]) => void;
+    updateMeetingRoomParams: (params: MeetingRoomParams | null) => void;
+    updateItemPageLimit: (limit: number) => void;
+    updateAudioOnlyRoom: (isAudioOnly: boolean) => void;
+    updateAddForBasic: (addForBasic: boolean) => void;
+    updateScreenPageLimit: (limit: number) => void;
+    updateVidCons: (cons: any) => void;
+    updateFrameRate: (frameRate: number) => void;
+    updateAdminPasscode: (passcode: string) => void;
+    updateEventType: (eventType: EventType) => void;
+    updateYouAreCoHost: (coHost: boolean) => void;
+    updateAutoWave: (autoWave: boolean) => void;
+    updateForceFullDisplay: (forceFull: boolean) => void;
+    updateChatSetting: (setting: string) => void;
+    updateMeetingDisplayType: (type: string) => void;
+    updateAudioSetting: (setting: string) => void;
+    updateVideoSetting: (setting: string) => void;
+    updateScreenshareSetting: (setting: string) => void;
+    updateHParams: (params: HParamsType) => void;
+    updateVParams: (params: VParamsType) => void;
+    updateScreenParams: (params: ScreenParamsType) => void;
+    updateAParams: (params: AParamsType) => void;
+    updateMainHeightWidth: (heightWidth: number) => void;
+    updateTargetResolution: (resolution: string) => void;
+    updateTargetResolutionHost: (resolution: string) => void;
+    updateRecordingAudioPausesLimit: (limit: number) => void;
+    updateRecordingAudioPausesCount: (count: number) => void;
+    updateRecordingAudioSupport: (support: boolean) => void;
+    updateRecordingAudioPeopleLimit: (limit: number) => void;
+    updateRecordingAudioParticipantsTimeLimit: (limit: number) => void;
+    updateRecordingVideoPausesCount: (count: number) => void;
+    updateRecordingVideoPausesLimit: (limit: number) => void;
+    updateRecordingVideoSupport: (support: boolean) => void;
+    updateRecordingVideoPeopleLimit: (limit: number) => void;
+    updateRecordingVideoParticipantsTimeLimit: (limit: number) => void;
+    updateRecordingAllParticipantsSupport: (support: boolean) => void;
+    updateRecordingVideoParticipantsSupport: (support: boolean) => void;
+    updateRecordingAllParticipantsFullRoomSupport: (support: boolean) => void;
+    updateRecordingVideoParticipantsFullRoomSupport: (support: boolean) => void;
+    updateRecordingPreferredOrientation: (orientation: string) => void;
+    updateRecordingSupportForOtherOrientation: (support: boolean) => void;
+    updateRecordingMultiFormatsSupport: (support: boolean) => void;
+    updateRecordingVideoOptions: (options: string) => void;
+    updateRecordingAudioOptions: (options: string) => void;
+}
+export type UpdateRoomParametersClientOptions = {
+    parameters: UpdateRoomParametersClientParameters;
+};
+export type UpdateRoomParametersClientType = (options: UpdateRoomParametersClientOptions) => void;
+export declare class UpdateRoomParametersClient {
+    private videoCaptureConstraints;
+    private hParams;
+    private vParams;
+    private screenParams;
+    private aParams;
+    constructor(videoCaptureConstraints: VideoCaptureConstraints, hParams: HParams, vParams: VParams, screenParams: ScreenParams, aParams: AParams);
+    /**
+     * Update Room Parameters Client after the user has joined the room and the room parameters have been received from the server.
+     * @param {Object} parameters - An object containing various parameters and update functions.
+     */
+    updateRoomParametersClient: ({ parameters }: UpdateRoomParametersClientOptions) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateRoomParametersClient, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UpdateRoomParametersClient>;
+}

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

@@ -0,0 +1,44 @@
+import { Socket } from 'socket.io-client';
+import { ValidateAlphanumeric } from '../../methods/utils/validate-alphanumeric.service';
+import { RtpCapabilities } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export interface JoinConRoomOptions {
+    socket: Socket;
+    roomName: string;
+    islevel: string;
+    member: string;
+    sec: string;
+    apiUserName: string;
+}
+export interface JoinConRoomResponse {
+    success: boolean;
+    rtpCapabilities: RtpCapabilities | null;
+    reason?: string;
+    banned?: boolean;
+    suspended?: boolean;
+    noAdmin?: boolean;
+    [key: string]: any;
+}
+export type JoinConRoomType = (options: JoinConRoomOptions) => Promise<JoinConRoomResponse>;
+export declare class JoinConRoom {
+    private validateAlphanumeric;
+    constructor(validateAlphanumeric: ValidateAlphanumeric);
+    /**
+     * Joins a conference room using the provided options.
+     *
+     * @param {JoinConRoomOptions} options - The options for joining the conference 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.
+     * @returns {Promise<JoinConRoomResponse>} A promise that resolves with the response of the join operation.
+     *
+     * @throws {Error} If any of the required parameters are missing or invalid.
+     * @throws {Error} If the user is banned, suspended, or if the host has not joined the room yet.
+     */
+    joinConRoom({ socket, roomName, islevel, member, sec, apiUserName, }: JoinConRoomOptions): Promise<object>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JoinConRoom, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JoinConRoom>;
+}

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

@@ -0,0 +1,34 @@
+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;
+    roomName: string;
+    islevel: string;
+    member: string;
+    sec: string;
+    apiUserName: string;
+}
+export type JoinRoomType = (socket: Socket, roomName: string, islevel: string, member: string, sec: string, apiUserName: string) => Promise<object>;
+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/all-members-rest.service.d.ts

@@ -0,0 +1,75 @@
+import { Participant, CoHostResponsibility, OnScreenChangesType, OnScreenChangesParameters, Request, ConnectIpsParameters, ReorderStreamsParameters, ConnectIpsType, SleepType, ReorderStreamsType, Settings, ConsumeSocket } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface AllMembersRestParameters extends OnScreenChangesParameters, ConnectIpsParameters, ReorderStreamsParameters {
+    participantsAll: Participant[];
+    participants: Participant[];
+    dispActiveNames: string[];
+    requestList: Request[];
+    coHost: string;
+    coHostResponsibility: CoHostResponsibility[];
+    lock_screen: boolean;
+    firstAll: boolean;
+    membersReceived: boolean;
+    roomRecvIPs: string[];
+    deferScreenReceived: boolean;
+    screenId?: string;
+    shareScreenStarted: boolean;
+    meetingDisplayType: string;
+    audioSetting: string;
+    videoSetting: string;
+    screenshareSetting: string;
+    chatSetting: string;
+    updateParticipantsAll: (participantsAll: Participant[]) => void;
+    updateParticipants: (participants: Participant[]) => void;
+    updateRequestList: (requestList: Request[]) => void;
+    updateCoHost: (coHost: string) => void;
+    updateCoHostResponsibility: (coHostResponsibility: CoHostResponsibility[]) => void;
+    updateFirstAll: (firstAll: boolean) => void;
+    updateMembersReceived: (membersReceived: boolean) => void;
+    updateDeferScreenReceived: (deferScreenReceived: boolean) => void;
+    updateShareScreenStarted: (shareScreenStarted: boolean) => void;
+    updateAudioSetting: (audioSetting: string) => void;
+    updateVideoSetting: (videoSetting: string) => void;
+    updateScreenshareSetting: (screenshareSetting: string) => void;
+    updateChatSetting: (chatSetting: string) => void;
+    updateConsume_sockets: (consume_sockets: ConsumeSocket[]) => void;
+    updateRoomRecvIPs: (ips: string[]) => void;
+    updateIsLoadingModalVisible: (visible: boolean) => void;
+    onScreenChanges: OnScreenChangesType;
+    connectIps: ConnectIpsType;
+    sleep: SleepType;
+    reorderStreams: ReorderStreamsType;
+    getUpdatedAllParams: () => AllMembersRestParameters;
+    [key: string]: any;
+}
+export interface AllMembersRestOptions {
+    members: Participant[];
+    settings: Settings;
+    coHoste?: string;
+    coHostRes?: CoHostResponsibility[];
+    parameters: AllMembersRestParameters;
+    consume_sockets: ConsumeSocket[];
+    apiUserName: string;
+    apiKey: string;
+    apiToken: string;
+}
+export type AllMembersRestType = (options: AllMembersRestOptions) => Promise<void>;
+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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AllMembersRest, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AllMembersRest>;
+}

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

@@ -0,0 +1,72 @@
+import { Participant, Request, ReorderStreamsType, ReorderStreamsParameters, SleepType, ConnectIpsParameters, OnScreenChangesParameters, OnScreenChangesType, ConnectIpsType, ConsumeSocket, CoHostResponsibility, WaitingRoomParticipant } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface AllMembersParameters extends ReorderStreamsParameters, ConnectIpsParameters, OnScreenChangesParameters {
+    participantsAll: Participant[];
+    participants: Participant[];
+    dispActiveNames: string[];
+    requestList: Request[];
+    coHost: string;
+    coHostResponsibility: CoHostResponsibility[];
+    lock_screen: boolean;
+    firstAll: boolean;
+    membersReceived: boolean;
+    roomRecvIPs: string[];
+    deferScreenReceived: boolean;
+    screenId?: string;
+    shareScreenStarted: boolean;
+    meetingDisplayType: string;
+    hostFirstSwitch: boolean;
+    waitingRoomList: WaitingRoomParticipant[];
+    islevel: string;
+    updateParticipantsAll: (participantsAll: Participant[]) => void;
+    updateParticipants: (participants: Participant[]) => void;
+    updateRequestList: (requestList: Request[]) => void;
+    updateCoHost: (coHost: string) => void;
+    updateCoHostResponsibility: (coHostRes: CoHostResponsibility[]) => void;
+    updateFirstAll: (firstAll: boolean) => void;
+    updateMembersReceived: (membersReceived: boolean) => void;
+    updateDeferScreenReceived: (deferScreenReceived: boolean) => void;
+    updateShareScreenStarted: (shareScreenStarted: boolean) => void;
+    updateHostFirstSwitch: (hostFirstSwitch: boolean) => void;
+    updateConsume_sockets: (sockets: ConsumeSocket[]) => void;
+    updateRoomRecvIPs: (ips: string[]) => void;
+    updateIsLoadingModalVisible: (visible: boolean) => void;
+    updateTotalReqWait: (total: number) => void;
+    onScreenChanges: OnScreenChangesType;
+    connectIps: ConnectIpsType;
+    sleep: SleepType;
+    reorderStreams: ReorderStreamsType;
+    getUpdatedAllParams: () => AllMembersParameters;
+    [key: string]: any;
+}
+export interface AllMembersOptions {
+    members: Participant[];
+    requestss: Request[];
+    coHoste: string;
+    coHostRes: CoHostResponsibility[];
+    parameters: AllMembersParameters;
+    consume_sockets: ConsumeSocket[];
+    apiUserName: string;
+    apiKey: string;
+    apiToken: string;
+}
+export type AllMembersType = (options: AllMembersOptions) => Promise<void>;
+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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AllMembers, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AllMembers>;
+}

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

@@ -0,0 +1,22 @@
+import { WaitingRoomParticipant } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface AllWaitingRoomMembersOptions {
+    waitingParticipants: WaitingRoomParticipant[];
+    updateWaitingRoomList: (participants: WaitingRoomParticipant[]) => void;
+    updateTotalReqWait: (totalReqs: number) => void;
+}
+export type AllWaitingRoomMembersType = (options: AllWaitingRoomMembersOptions) => Promise<void>;
+export declare class AllWaitingRoomMembers {
+    /**
+     * Updates the waiting room participants list and the total count of waiting room participants.
+     *
+     * @param {Object} options - The options object.
+     * @param {Array} options.waitingParticipants - An array of participants currently in the waiting room.
+     * @param {Function} options.updateWaitingRoomList - A function to update the waiting room participants list.
+     * @param {Function} options.updateTotalReqWait - A function to update the total count of waiting room participants.
+     * @returns {Promise<void>} A promise that resolves when the updates are complete.
+     */
+    allWaitingRoomMembers: ({ waitingParticipants, updateWaitingRoomList, updateTotalReqWait, }: AllWaitingRoomMembersOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AllWaitingRoomMembers, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AllWaitingRoomMembers>;
+}

package/dist/lib/producers/socket-receive-methods/ban-participant.service.d.ts

@@ -0,0 +1,35 @@
+import { Participant, ReorderStreamsType, ReorderStreamsParameters } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface BanParticipantParameters extends ReorderStreamsParameters {
+    activeNames: string[];
+    dispActiveNames: string[];
+    participants: Participant[];
+    updateParticipants: (participants: Participant[]) => void;
+    reorderStreams: ReorderStreamsType;
+    [key: string]: any;
+}
+export interface BanParticipantOptions {
+    name: string;
+    parameters: BanParticipantParameters;
+}
+export type BanParticipantType = (options: BanParticipantOptions) => Promise<void>;
+export declare class BanParticipant {
+    /**
+     * Bans a participant from the session by removing them from the active and display names arrays,
+     * updating the participants list, and reordering the streams.
+     *
+     * @param {BanParticipantOptions} options - The options for banning a participant.
+     * @param {string} options.name - The name of the participant to be banned.
+     * @param {Object} options.parameters - The parameters required for banning the participant.
+     * @param {string[]} options.parameters.activeNames - The array of active participant names.
+     * @param {string[]} options.parameters.dispActiveNames - The array of display participant names.
+     * @param {Object[]} options.parameters.participants - The array of participant objects.
+     * @param {Function} options.parameters.updateParticipants - The function to update the participants array.
+     * @param {Function} options.parameters.reorderStreams - The function to reorder the streams.
+     *
+     * @returns {Promise<void>} A promise that resolves when the participant has been banned and streams reordered.
+     */
+    banParticipant: ({ name, parameters }: BanParticipantOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BanParticipant, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BanParticipant>;
+}

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

@@ -0,0 +1,60 @@
+import { OnScreenChangesType, StopShareScreenType, DisconnectSendTransportVideoType, DisconnectSendTransportAudioType, DisconnectSendTransportScreenType, OnScreenChangesParameters, StopShareScreenParameters, DisconnectSendTransportVideoParameters, DisconnectSendTransportAudioParameters, DisconnectSendTransportScreenParameters } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface ControlMediaHostParameters extends OnScreenChangesParameters, StopShareScreenParameters, DisconnectSendTransportVideoParameters, DisconnectSendTransportAudioParameters, DisconnectSendTransportScreenParameters {
+    updateAdminRestrictSetting: (value: boolean) => void;
+    localStream: MediaStream | null;
+    updateLocalStream: (stream: MediaStream | null) => void;
+    updateAudioAlreadyOn: (value: boolean) => void;
+    localStreamScreen: MediaStream | null;
+    updateLocalStreamScreen: (stream: MediaStream | null) => void;
+    localStreamVideo: MediaStream | null;
+    updateLocalStreamVideo: (stream: MediaStream | null) => void;
+    updateScreenAlreadyOn: (value: boolean) => void;
+    updateVideoAlreadyOn: (value: boolean) => void;
+    updateChatAlreadyOn: (value: boolean) => void;
+    onScreenChanges: OnScreenChangesType;
+    stopShareScreen: StopShareScreenType;
+    disconnectSendTransportVideo: DisconnectSendTransportVideoType;
+    disconnectSendTransportAudio: DisconnectSendTransportAudioType;
+    disconnectSendTransportScreen: DisconnectSendTransportScreenType;
+    getUpdatedAllParams: () => ControlMediaHostParameters;
+    [key: string]: any;
+}
+export interface ControlMediaHostOptions {
+    type: 'audio' | 'video' | 'screenshare' | 'chat' | 'all';
+    parameters: ControlMediaHostParameters;
+}
+export type ControlMediaHostType = (options: ControlMediaHostOptions) => Promise<void>;
+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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ControlMediaHost, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ControlMediaHost>;
+}

package/dist/lib/producers/socket-receive-methods/disconnect-user-self.service.d.ts

@@ -0,0 +1,22 @@
+import { Socket } from 'socket.io-client';
+import * as i0 from "@angular/core";
+export interface DisconnectUserSelfOptions {
+    member: string;
+    roomName: string;
+    socket: Socket;
+}
+export type DisconnectUserSelfType = (options: DisconnectUserSelfOptions) => Promise<void>;
+export declare class DisconnectUserSelf {
+    /**
+     * Disconnects the user from the specified room and bans them.
+     *
+     * @param {DisconnectUserSelfOptions} options - The options for disconnecting the user.
+     * @param {Object} options.member - The member object representing the user to disconnect.
+     * @param {string} options.roomName - The name of the room from which the user will be disconnected.
+     * @param {Socket} options.socket - The socket instance used to emit the disconnection request.
+     * @returns {Promise<void>} A promise that resolves when the disconnection request has been emitted.
+     */
+    disconnectUserSelf: ({ member, roomName, socket, }: DisconnectUserSelfOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisconnectUserSelf, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DisconnectUserSelf>;
+}

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

@@ -0,0 +1,23 @@
+import { ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface DisconnectOptions {
+    showAlert?: ShowAlert;
+    redirectURL?: string;
+    onWeb: boolean;
+    updateValidated?: (isValidated: boolean) => void;
+}
+export type DisconnectType = (options: DisconnectOptions) => Promise<void>;
+export declare class Disconnect {
+    /**
+     * Handles the disconnection logic by either redirecting to a specified URL or showing an alert.
+     *
+     * @param {DisconnectOptions} options - The options for handling disconnection.
+     * @param {Function} options.showAlert - Function to display an alert message.
+     * @param {string} options.redirectURL - URL to redirect to if on the web.
+     * @param {boolean} options.onWeb - Flag indicating if the operation is on the web.
+     * @returns {Promise<void>} A promise that resolves when the disconnection handling is complete.
+     */
+    disconnect: ({ showAlert, redirectURL, onWeb }: DisconnectOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Disconnect, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Disconnect>;
+}