mediasfu-angular 1.0.1 → 2.0.0

package/dist/lib/consumers/connect-local-ips.service.d.ts

@@ -0,0 +1,81 @@
+import { NewPipeProducer } from './socket-receive-methods/new-pipe-producer.service';
+import { ProducerClosed } from './socket-receive-methods/producer-closed.service';
+import { ReorderStreamsParameters, ReorderStreamsType, NewPipeProducerParameters, NewPipeProducerType, ProducerClosedType, ProducerClosedParameters, ReceiveAllPipedTransportsType, ReceiveAllPipedTransportsParameters } from '../@types/types';
+import { Socket } from 'socket.io-client';
+import * as i0 from "@angular/core";
+export interface ConnectLocalIpsParameters extends ReorderStreamsParameters, ProducerClosedParameters, NewPipeProducerParameters, ReceiveAllPipedTransportsParameters {
+    socket: Socket;
+    reorderStreams: ReorderStreamsType;
+    receiveAllPipedTransports: ReceiveAllPipedTransportsType;
+    getUpdatedAllParams: () => ConnectLocalIpsParameters;
+    [key: string]: any;
+}
+export interface ConnectLocalIpsOptions {
+    socket: Socket;
+    newProducerMethod?: NewPipeProducerType;
+    closedProducerMethod?: ProducerClosedType;
+    parameters: ConnectLocalIpsParameters;
+}
+export type ConnectLocalIpsType = (options: ConnectLocalIpsOptions) => Promise<void>;
+/**
+ * Connects to remote IPs and manages socket connections.
+ *
+ * This method establishes connections to remote IPs for media streaming, handles new pipe producer events,
+ * and manages producer closure events. It updates the necessary state in the application to reflect
+ * the current connections and stream configurations.
+ *
+ * @param {ConnectLocalIpsOptions} options - The options for connecting IPs.
+ * @param {Socket} options.socket - The socket connection to use for communication.
+ * @param {Function} [options.newProducerMethod] - The method to handle new pipe producer events (default: newPipeProducer).
+ * @param {Function} [options.closedProducerMethod] - The method to handle producer closed events (default: producerClosed).
+ * @param {ConnectLocalIpsParameters} options.parameters - Additional parameters for the operation.
+ *
+ * @returns {Promise<void>} A promise that resolves when the connection is established.
+ *
+ * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.
+ *
+ * @example
+ * ```typescript
+ * const result = await connectLocalIps({
+*     socket,
+*     newProducerMethod: newPipeProducer,
+*     closedProducerMethod: producerClosed,
+*     parameters,
+*   });
+* ```
+*/
+export declare class ConnectLocalIps {
+    private newPipeProducerService;
+    private producerClosedService;
+    constructor(newPipeProducerService: NewPipeProducer, producerClosedService: ProducerClosed);
+    /**
+     * Connects to remote IPs and manages socket connections.
+     *
+     * This method establishes connections to remote IPs for media streaming, handles new pipe producer events,
+     * and manages producer closure events. It updates the necessary state in the application to reflect
+     * the current connections and stream configurations.
+     *
+     * @param {ConnectLocalIpsOptions} options - The options for connecting IPs.
+     * @param {Socket} options.socket - The socket connection to use for communication.
+     * @param {Function} [options.newProducerMethod] - The method to handle new pipe producer events (default: newPipeProducer).
+     * @param {Function} [options.closedProducerMethod] - The method to handle producer closed events (default: producerClosed).
+     * @param {ConnectLocalIpsParameters} options.parameters - Additional parameters for the operation.
+     *
+     * @returns {Promise<void>} A promise that resolves when the connection is established.
+     *
+     * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.
+     *
+     * @example
+     * ```typescript
+     * const result = await connectLocalIps({
+    *     socket,
+    *     newProducerMethod: newPipeProducer,
+    *     closedProducerMethod: producerClosed,
+    *     parameters,
+    *   });
+    * ```
+    */
+    connectLocalIps: ({ socket, newProducerMethod, closedProducerMethod, parameters, }: ConnectLocalIpsOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectLocalIps, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectLocalIps>;
+}

package/dist/lib/consumers/connect-recv-transport.service.d.ts

@@ -18,6 +18,39 @@ export interface ConnectRecvTransportOptions {
     parameters: ConnectRecvTransportParameters;
 }
 export type ConnectRecvTransportType = (options: ConnectRecvTransportOptions) => Promise<void>;
+/**
+ * Connects the receiving transport to consume media from a remote producer.
+ *
+ * @param {ConnectRecvTransportOptions} options - The options for connecting the receiving transport.
+ * @param {Transport} options.consumerTransport - The transport used for consuming media.
+ * @param {string} options.remoteProducerId - The ID of the remote producer.
+ * @param {string} options.serverConsumerTransportId - The ID of the server consumer transport.
+ * @param {Socket} options.nsock - The socket used for communication.
+ * @param {ConnectRecvTransportParameters} options.parameters - The parameters for the connection.
+ *
+ * @returns {Promise<void>} A promise that resolves when the connection is established.
+ *
+ * @throws Will throw an error if the connection or consumption fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   consumerTransport,
+ *   remoteProducerId: 'producer-id',
+ *   serverConsumerTransportId: 'transport-id',
+ *   nsock: socket,
+ *   parameters: connectRecvTransportOptions,
+ * };
+ *
+ * connectRecvTransport(options)
+ *   .then(() => {
+ *     console.log('Transport connected and consuming media');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting transport:', error);
+ *   });
+ * ```
+ */
 export declare class ConnectRecvTransport {
     /**
      * Connects the receiving transport to consume media from a remote producer.

package/dist/lib/consumers/connect-send-transport-audio.service.d.ts

@@ -3,31 +3,101 @@ import * as i0 from "@angular/core";
 export interface ConnectSendTransportAudioParameters {
     audioProducer: Producer | null;
     producerTransport: Transport | null;
+    localAudioProducer?: Producer | null;
+    localProducerTransport?: Transport | null;
     updateAudioProducer: (producer: Producer | null) => void;
     updateProducerTransport: (transport: Transport | null) => void;
+    updateLocalAudioProducer?: (localProducer: Producer | null) => void;
+    updateLocalProducerTransport?: (localTransport: Transport | null) => void;
 }
 export interface ConnectSendTransportAudioOptions {
     audioParams: ProducerOptions;
     parameters: ConnectSendTransportAudioParameters;
+    targetOption?: 'all' | 'local' | 'remote';
 }
 export type ConnectSendTransportAudioType = (options: ConnectSendTransportAudioOptions) => Promise<void>;
+export declare const connectLocalSendTransportAudio: ({ parameters, audioParams }: ConnectSendTransportAudioOptions) => Promise<void>;
+/**
+ * Connects the send transport for audio by producing audio data and updating the audio producer and producer transport objects.
+ *
+ * @param {ConnectSendTransportAudioOptions} options - The parameters for connecting the send transport.
+ * @param {ProducerOptions} options.audioParams - The options for the audio producer.
+ * @param {ConnectSendTransportAudioParameters} options.parameters - The parameters containing the audio producer, producer transport, and update functions.
+ * @param {Producer} options.parameters.audioProducer - The current audio producer.
+ * @param {Transport} options.parameters.producerTransport - The transport used to produce audio data.
+ * @param {Function} options.parameters.updateAudioProducer - Function to update the audio producer.
+ * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the audio transport is successfully connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * ```typescript
+ * const audioParams: ProducerOptions = {
+ *   codec: 'opus',
+ *   // other options
+ * };
+ *
+ * const parameters = {
+ *   audioProducer: null,
+ *   producerTransport: transport,
+ *   updateAudioProducer: (producer) => { console.log(updated) },
+  *   updateProducerTransport: (transport) => { console.log(updated) },
+  * };
+  *
+  * connectSendTransportAudio({ audioParams, parameters })
+  *   .then(() => {
+  *     console.log('Audio transport connected successfully');
+  *   })
+  *   .catch((error) => {
+  *     console.error('Error connecting audio transport:', error);
+  *   });
+  * ```
+  */
 export declare class ConnectSendTransportAudio {
     /**
      * Connects the send transport for audio by producing audio data and updating the audio producer and producer transport objects.
      *
-     * @param {Object} params - The parameters for connecting the send transport.
-     * @param {ProducerOptions} params.audioParams - The options for the audio producer.
-     * @param {ConnectSendTransportAudioParameters} params.parameters - The parameters containing the audio producer, producer transport, and update functions.
-     * @param {Producer} params.parameters.audioProducer - The current audio producer.
-     * @param {Transport} params.parameters.producerTransport - The transport used to produce audio data.
-     * @param {Function} params.parameters.updateAudioProducer - Function to update the audio producer.
-     * @param {Function} params.parameters.updateProducerTransport - Function to update the producer transport.
-     *
-     * @returns {Promise<void>} A promise that resolves when the audio transport is successfully connected.
+     * @param {ConnectSendTransportAudioOptions} options - The options for connecting the send transport.
+     * @param {ProducerOptions} options.audioParams - The audio parameters.
+     * @param {ConnectSendTransportAudioParameters} options.parameters - The parameters required for connecting the transport.
+     * @param {Producer | null} options.parameters.audioProducer - The audio producer object.
+     * @param {Transport | null} options.parameters.producerTransport - The producer transport object.
+     * @param {Producer | null} [options.parameters.localAudioProducer] - The local audio producer object.
+     * @param {Transport | null} [options.parameters.localProducerTransport] - The local producer transport object.
+     * @param {(producer: Producer | null) => void} options.parameters.updateAudioProducer - The function to update the audio producer object.
+     * @param {(transport: Transport | null) => void} options.parameters.updateProducerTransport - The function to update the producer transport object.
+     * @param {(localProducer: Producer | null) => void} [options.parameters.updateLocalAudioProducer] - The function to update the local audio producer object.
+     * @returns {Promise<void>} A promise that resolves when the connection is established.
      *
      * @throws Will throw an error if the connection fails.
-     */
-    connectSendTransportAudio({ audioParams, parameters, }: ConnectSendTransportAudioOptions): Promise<void>;
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *  audioParams: { codec: 'opus' },
+     * parameters: {
+     * audioProducer: null,
+     * producerTransport: transport,
+     * updateAudioProducer: (producer) => { console.log(updated) },
+     * updateProducerTransport: (transport) => { console.log(updated) },
+     * updateLocalAudioProducer: (localProducer) => { console.log(updated) },
+     * updateLocalProducerTransport: (localTransport) => { console.log(updated) },
+     * },
+     * };
+     *
+     * connectSendTransportAudio(options)
+     * .then(() => {
+     * console.log('Audio transport connected successfully');
+     * })
+     * .catch((error) => {
+     * console.error('Error connecting audio transport:', error);
+     * });
+     * ```
+     *
+    */
+    connectSendTransportAudio({ targetOption, audioParams, parameters, }: ConnectSendTransportAudioOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConnectSendTransportAudio, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConnectSendTransportAudio>;
 }

package/dist/lib/consumers/connect-send-transport-screen.service.d.ts

@@ -2,41 +2,122 @@ import { Transport, Producer, Device, ProducerOptions } from 'mediasoup-client/l
 import * as i0 from "@angular/core";
 export interface ConnectSendTransportScreenParameters {
     screenProducer: Producer | null;
+    localScreenProducer?: Producer | null;
     device: Device | null;
     screenParams: ProducerOptions;
     producerTransport: Transport | null;
+    localProducerTransport?: Transport | null;
     params: ProducerOptions;
     updateScreenProducer: (producer: Producer | null) => void;
+    updateLocalScreenProducer?: (localProducer: Producer | null) => void;
     updateProducerTransport: (transport: Transport | null) => void;
+    updateLocalProducerTransport?: (localTransport: Transport | null) => void;
     getUpdatedAllParams: () => ConnectSendTransportScreenParameters;
     [key: string]: any;
 }
 export interface ConnectSendTransportScreenOptions {
     stream: MediaStream | null;
     parameters: ConnectSendTransportScreenParameters;
+    targetOption?: "all" | "local" | "remote";
 }
 export type ConnectSendTransportScreenType = (options: ConnectSendTransportScreenOptions) => Promise<void>;
+export declare const connectLocalSendTransportScreen: ({ stream, parameters, }: ConnectSendTransportScreenOptions) => Promise<void>;
+/**
+ * Sets up and connects a screen sharing transport for sending video streams.
+ *
+ * This function supports both a primary and a local screen producer, delegating local handling to a separate function.
+ *
+ * @param {ConnectSendTransportScreenOptions} options - The configuration options for setting up the screen transport.
+ * @param {"all" | "local" | "remote"} [options.targetOption] - The target option for connecting the transport.
+ * @param {MediaStream} options.stream - The screen stream to be shared.
+ * @param {ConnectSendTransportScreenParameters} options.parameters - The parameters required for setting up the screen transport.
+ * @param {Producer | null} options.parameters.screenProducer - The screen producer object to be updated.
+ * @param {Device | null} options.parameters.device - The device object for media capabilities.
+ * @param {ProducerOptions} options.parameters.screenParams - The parameters for the screen producer.
+ * @param {Transport | null} options.parameters.producerTransport - The producer transport object.
+ * @param {ProducerOptions} options.parameters.params - The parameters for the producer.
+ * @param {Function} options.parameters.updateScreenProducer - The function to update the screen producer object.
+ * @param {Function} options.parameters.updateProducerTransport - The function to update the producer transport object.
+ * @param {Function} [options.parameters.updateLocalScreenProducer] - The function to update the local screen producer object.
+ * @param {Function} [options.parameters.updateLocalProducerTransport] - The function to update the local producer transport object.
+ * @param {Function} options.parameters.getUpdatedAllParams - The function to get updated parameters.
+ * @param {Object} [options.parameters.*] - Additional parameters for future use.
+ *
+ * @returns {Promise<void>} - A promise that resolves once the screen transport is successfully connected and set up.
+ *
+ * @throws Will throw an error if there is an issue with the connection or setup process.
+ *
+ * @example
+ * ```typescript
+ * await connectSendTransportScreen({
+ *   stream: screenStream,
+ *   targetOption: "all",
+ *   parameters: {
+ *     screenProducer: null,
+ *     localScreenProducer: null,
+ *     device: mediaDevice,
+ *     screenParams: { encodings: [{ maxBitrate: 1500000 }] },
+ *     producerTransport: sendTransport,
+ *     localProducerTransport: localSendTransport,
+ *     params: { track: screenStream.getVideoTracks()[0] },
+ *     updateScreenProducer: setScreenProducer,
+ *     updateLocalScreenProducer: setLocalScreenProducer,
+ *     updateProducerTransport: setProducerTransport,
+ *     updateLocalProducerTransport: setLocalProducerTransport,
+ *     getUpdatedAllParams: getParams,
+ *   },
+ * });
+ * ```
+ */
 export declare class ConnectSendTransportScreen {
     /**
-     * Connects and sets up the screen sharing transport for sending video streams.
+     * Sets up and connects a screen sharing transport for sending video streams.
      *
-     * @param {Object} options - The options for connecting the screen transport.
-     * @param {MediaStream} options.stream - The media stream containing the screen video track.
-     * @param {ConnectSendTransportScreenOptions} options.parameters - The parameters required for setting up the transport.
-     * @param {Producer} options.parameters.screenProducer - The screen producer object.
-     * @param {Device} options.parameters.device - The device object containing RTP capabilities.
-     * @param {Promise<ScreenParams>} options.parameters.screenParams - A promise resolving to screen share parameters.
-     * @param {Transport} options.parameters.producerTransport - The transport object used for producing the screen share.
-     * @param {Params} options.parameters.params - The parameters for producing the screen share.
-     * @param {Function} options.parameters.updateScreenProducer - Function to update the screen producer object.
-     * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport object.
-     * @param {Function} options.parameters.getUpdatedAllParams - Function to fetch updated device information.
+     * This function supports both a primary and a local screen producer, delegating local handling to a separate function.
      *
-     * @returns {Promise<void>} A promise that resolves when the screen transport is successfully connected and set up.
+     * @param {ConnectSendTransportScreenOptions} options - The configuration options for setting up the screen transport.
+     * @param {"all" | "local" | "remote"} [options.targetOption] - The target option for connecting the transport.
+     * @param {MediaStream} options.stream - The screen stream to be shared.
+     * @param {ConnectSendTransportScreenParameters} options.parameters - The parameters required for setting up the screen transport.
+     * @param {Producer | null} options.parameters.screenProducer - The screen producer object to be updated.
+     * @param {Device | null} options.parameters.device - The device object for media capabilities.
+     * @param {ProducerOptions} options.parameters.screenParams - The parameters for the screen producer.
+     * @param {Transport | null} options.parameters.producerTransport - The producer transport object.
+     * @param {ProducerOptions} options.parameters.params - The parameters for the producer.
+     * @param {Function} options.parameters.updateScreenProducer - The function to update the screen producer object.
+     * @param {Function} options.parameters.updateProducerTransport - The function to update the producer transport object.
+     * @param {Function} [options.parameters.updateLocalScreenProducer] - The function to update the local screen producer object.
+     * @param {Function} [options.parameters.updateLocalProducerTransport] - The function to update the local producer transport object.
+     * @param {Function} options.parameters.getUpdatedAllParams - The function to get updated parameters.
+     * @param {Object} [options.parameters.*] - Additional parameters for future use.
      *
-     * @throws Will throw an error if the connection or setup process fails.
+     * @returns {Promise<void>} - A promise that resolves once the screen transport is successfully connected and set up.
+     *
+     * @throws Will throw an error if there is an issue with the connection or setup process.
+     *
+     * @example
+     * ```typescript
+     * await connectSendTransportScreen({
+     *   stream: screenStream,
+     *   targetOption: "all",
+     *   parameters: {
+     *     screenProducer: null,
+     *     localScreenProducer: null,
+     *     device: mediaDevice,
+     *     screenParams: { encodings: [{ maxBitrate: 1500000 }] },
+     *     producerTransport: sendTransport,
+     *     localProducerTransport: localSendTransport,
+     *     params: { track: screenStream.getVideoTracks()[0] },
+     *     updateScreenProducer: setScreenProducer,
+     *     updateLocalScreenProducer: setLocalScreenProducer,
+     *     updateProducerTransport: setProducerTransport,
+     *     updateLocalProducerTransport: setLocalProducerTransport,
+     *     getUpdatedAllParams: getParams,
+     *   },
+     * });
+     * ```
      */
-    connectSendTransportScreen({ stream, parameters, }: ConnectSendTransportScreenOptions): Promise<void>;
+    connectSendTransportScreen({ stream, parameters, targetOption, }: ConnectSendTransportScreenOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConnectSendTransportScreen, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConnectSendTransportScreen>;
 }

package/dist/lib/consumers/connect-send-transport-video.service.d.ts

@@ -2,40 +2,130 @@ import { Device, Producer, ProducerOptions, Transport } from 'mediasoup-client/l
 import * as i0 from "@angular/core";
 export interface ConnectSendTransportVideoParameters {
     videoProducer: Producer | null;
+    localVideoProducer?: Producer | null;
     device: Device | null;
     producerTransport: Transport | null;
+    localProducerTransport?: Transport | null;
     islevel: string;
     updateMainWindow: boolean;
     updateVideoProducer: (producer: Producer | null) => void;
+    updateLocalVideoProducer?: (localProducer: Producer | null) => void;
     updateProducerTransport: (transport: Transport | null) => void;
+    updateLocalProducerTransport?: (localTransport: Transport | null) => void;
     updateUpdateMainWindow: (state: boolean) => void;
     [key: string]: any;
 }
 export interface ConnectSendTransportVideoOptions {
     videoParams: ProducerOptions;
     parameters: ConnectSendTransportVideoParameters;
+    targetOption?: "all" | "local" | "remote";
 }
 export type ConnectSendTransportVideoType = (options: ConnectSendTransportVideoOptions) => Promise<void>;
+export declare const connectLocalSendTransportVideo: ({ videoParams, parameters, }: ConnectSendTransportVideoOptions) => Promise<void>;
+/**
+ * Connects the send transport for video by producing video data and updates the relevant states.
+ *
+ * This function supports both a primary and a local video producer, delegating local handling to a separate function.
+ *
+ * @param {ConnectSendTransportVideoOptions} options - The options for connecting the send transport for video.
+ * @param {ProducerOptions} options.videoParams - The parameters for the video producer.
+ * @param {"all" | "local" | "remote"} [options.targetOption] - The target option for the video transport connection.
+ * @param {ConnectSendTransportVideoParameters} options.parameters - The parameters for the video transport connection.
+ * @param {Producer | null} options.parameters.videoProducer - The primary video producer.
+ * @param {Producer | null} [options.parameters.localVideoProducer] - The local video producer.
+ * @param {Device | null} options.parameters.device - The device information.
+ * @param {Transport | null} options.parameters.producerTransport - The primary producer transport.
+ * @param {Transport | null} [options.parameters.localProducerTransport] - The local producer transport.
+ * @param {string} options.parameters.islevel - The connection level for the video transport.
+ * @param {boolean} options.parameters.updateMainWindow - The flag to update the main window state.
+ * @param {(producer: Producer | null) => void} options.parameters.updateVideoProducer - The function to update the video producer state.
+ * @param {(localProducer: Producer | null) => void} [options.parameters.updateLocalVideoProducer] - The function to update the local video producer state.
+ * @param {(transport: Transport | null) => void} options.parameters.updateProducerTransport - The function to update the producer transport state.
+ * @param {(localTransport: Transport | null) => void} [options.parameters.updateLocalProducerTransport] - The function to update the local producer transport state.
+ * @param {(state: boolean) => void} options.parameters.updateUpdateMainWindow - The function to update the main window state.
+ * @param {any} [options.parameters] - Additional parameters for future use.
+ * @returns {Promise<void>} A promise that resolves when the send transport for video is connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * const options = {
+ *   videoParams: {
+ *     // video producer options (e.g., codec, bitrate)
+ *   },
+ *   targetOption: "all",
+ *   parameters: {
+ *     videoProducer: null,
+ *     localVideoProducer: null,
+ *     producerTransport: transport,
+ *     localProducerTransport: localTransport,
+ *     islevel: '2',
+ *     updateMainWindow: false,
+ *     updateVideoProducer: (producer) => console.log("Updated producer"),
+ *     updateLocalVideoProducer: (localProducer) => console.log("Updated local producer"),
+ *     updateProducerTransport: (transport) => console.log("Updated transport"),
+ *     updateLocalProducerTransport: (localTransport) => console.log("Updated local transport"),
+ *     updateUpdateMainWindow: (state) => console.log("Updated main window:", state),
+ *   },
+ * };
+ *
+ * connectSendTransportVideo(options)
+ *   .then(() => console.log("Video transport connected successfully"))
+ *   .catch((error) => console.error("Error connecting video transport:", error));
+ */
 export declare class ConnectSendTransportVideo {
     /**
      * Connects the send transport for video by producing video data and updates the relevant states.
      *
-     * @param {ConnectSendTransportVideoOptions} options - The options for connecting the send transport for video.
-     * @param {Object} options.videoParams - The parameters for producing video data.
-     * @param {Object} options.parameters - The parameters for updating the state.
-     * @param {Producer} options.parameters.videoProducer - The video producer instance.
-     * @param {Transport} options.parameters.producerTransport - The transport instance used for producing video.
-     * @param {string} options.parameters.islevel - The connection level.
-     * @param {boolean} options.parameters.updateMainWindow - The state of the main window update.
-     * @param {Function} options.parameters.updateVideoProducer - Function to update the video producer.
-     * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport.
-     * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.
+     * This function supports both a primary and a local video producer, delegating local handling to a separate function.
      *
+     * @param {ConnectSendTransportVideoOptions} options - The options for connecting the send transport for video.
+     * @param {ProducerOptions} options.videoParams - The parameters for the video producer.
+     * @param {"all" | "local" | "remote"} [options.targetOption] - The target option for the video transport connection.
+     * @param {ConnectSendTransportVideoParameters} options.parameters - The parameters for the video transport connection.
+     * @param {Producer | null} options.parameters.videoProducer - The primary video producer.
+     * @param {Producer | null} [options.parameters.localVideoProducer] - The local video producer.
+     * @param {Device | null} options.parameters.device - The device information.
+     * @param {Transport | null} options.parameters.producerTransport - The primary producer transport.
+     * @param {Transport | null} [options.parameters.localProducerTransport] - The local producer transport.
+     * @param {string} options.parameters.islevel - The connection level for the video transport.
+     * @param {boolean} options.parameters.updateMainWindow - The flag to update the main window state.
+     * @param {(producer: Producer | null) => void} options.parameters.updateVideoProducer - The function to update the video producer state.
+     * @param {(localProducer: Producer | null) => void} [options.parameters.updateLocalVideoProducer] - The function to update the local video producer state.
+     * @param {(transport: Transport | null) => void} options.parameters.updateProducerTransport - The function to update the producer transport state.
+     * @param {(localTransport: Transport | null) => void} [options.parameters.updateLocalProducerTransport] - The function to update the local producer transport state.
+     * @param {(state: boolean) => void} options.parameters.updateUpdateMainWindow - The function to update the main window state.
+     * @param {any} [options.parameters] - Additional parameters for future use.
      * @returns {Promise<void>} A promise that resolves when the send transport for video is connected.
      *
      * @throws Will throw an error if the connection fails.
+     *
+     * @example
+     * const options = {
+     *   videoParams: {
+     *     // video producer options (e.g., codec, bitrate)
+     *   },
+     *   targetOption: "all",
+     *   parameters: {
+     *     videoProducer: null,
+     *     localVideoProducer: null,
+     *     producerTransport: transport,
+     *     localProducerTransport: localTransport,
+     *     islevel: '2',
+     *     updateMainWindow: false,
+     *     updateVideoProducer: (producer) => console.log("Updated producer"),
+     *     updateLocalVideoProducer: (localProducer) => console.log("Updated local producer"),
+     *     updateProducerTransport: (transport) => console.log("Updated transport"),
+     *     updateLocalProducerTransport: (localTransport) => console.log("Updated local transport"),
+     *     updateUpdateMainWindow: (state) => console.log("Updated main window:", state),
+     *   },
+     * };
+     *
+     * connectSendTransportVideo(options)
+     *   .then(() => console.log("Video transport connected successfully"))
+     *   .catch((error) => console.error("Error connecting video transport:", error));
      */
-    connectSendTransportVideo: ({ videoParams, parameters, }: ConnectSendTransportVideoOptions) => Promise<void>;
+    connectSendTransportVideo: ({ videoParams, parameters, targetOption, }: ConnectSendTransportVideoOptions) => Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConnectSendTransportVideo, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConnectSendTransportVideo>;
 }

package/dist/lib/consumers/connect-send-transport.service.d.ts

@@ -17,15 +17,73 @@ export interface ConnectSendTransportParameters extends ConnectSendTransportAudi
 }
 export interface ConnectSendTransportOptions {
     option: 'audio' | 'video' | 'screen' | 'all';
+    targetOption?: 'local' | 'remote' | 'all';
     parameters: ConnectSendTransportParameters;
 }
 export type ConnectSendTransportType = (options: ConnectSendTransportOptions) => Promise<void>;
+/**
+ * Connects the send transport based on the specified option.
+ *
+ * @param {ConnectSendTransportOptions} options - The options for connecting the send transport.
+ * @param {string} options.option - The type of transport to connect ("audio", "video", "screen", or "all").
+ * @param {string} options.targetOption - The target of the transport to connect ("local", "remote", or "all").
+ * @param {ConnectSendTransportParameters} options.parameters - The parameters required for connecting the transport.
+ * @param {ProducerOptions} options.parameters.audioParams - The audio parameters.
+ * @param {ProducerOptions} options.parameters.videoParams - The video parameters.
+ * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.
+ * @param {MediaStream} options.parameters.canvasStream - The canvas stream.
+ * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard has ended.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {string} options.parameters.islevel - The level of the screen sharing.
+ * @param {Function} options.parameters.connectSendTransportAudio - Function to connect the audio send transport.
+ * @param {Function} options.parameters.connectSendTransportVideo - Function to connect the video send transport.
+ * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the screen send transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the transport is connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   option: 'audio', // Can be 'audio', 'video', 'screen', or 'all'
+ *   targetOption: 'local', // Can be 'local', 'remote', or 'all'
+ *   parameters: {
+ *     audioParams: { codec: 'opus' },
+ *     videoParams: { codec: 'vp8' },
+ *     localStreamScreen: null, // Set to your local screen stream
+ *     canvasStream: null, // Set to your canvas stream if using
+ *     whiteboardStarted: false,
+ *     whiteboardEnded: true,
+ *     shared: false,
+ *     islevel: '1',
+ *     connectSendTransportAudio: connectSendTransportAudioFunction,
+ *     connectSendTransportVideo: connectSendTransportVideoFunction,
+ *     connectSendTransportScreen: connectSendTransportScreenFunction,
+ *     updateVideoProducer: () => {},
+ *     updateProducerTransport: () => {},
+ *     updateScreenProducer: () => {},
+ *     updateMainWindow: false,
+ *   },
+ * };
+ *
+ * connectSendTransport(options)
+ *   .then(() => {
+ *     console.log('Transport connected successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting transport:', error);
+ *   });
+ * ```
+ */
 export declare class ConnectSendTransport {
     /**
      * Connects the send transport based on the specified option.
      *
      * @param {ConnectSendTransportOptions} options - The options for connecting the send transport.
      * @param {string} options.option - The type of transport to connect ("audio", "video", "screen", or both).
+     * @param {string} options.targetOption - The target of the transport to connect ("local", "remote", or "all").
      * @param {Object} options.parameters - The parameters required for connecting the transport.
      * @param {Object} options.parameters.audioParams - The audio parameters.
      * @param {Object} options.parameters.videoParams - The video parameters.
@@ -43,7 +101,7 @@ export declare class ConnectSendTransport {
      *
      * @throws Will throw an error if the connection fails.
      */
-    connectSendTransport({ option, parameters }: ConnectSendTransportOptions): Promise<void>;
+    connectSendTransport({ option, targetOption, parameters }: ConnectSendTransportOptions): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConnectSendTransport, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConnectSendTransport>;
 }

package/dist/lib/consumers/consumer-resume.service.d.ts

@@ -65,6 +65,42 @@ export interface ConsumerResumeOptions {
     nsock: Socket;
 }
 export type ConsumerResumeType = (options: ConsumerResumeOptions) => Promise<void>;
+/**
+ * Resumes a consumer, making it ready for use.
+ *
+ * @param {ConsumerResumeOptions} options - The options for resuming the consumer.
+ * @param {MediaStreamTrack} options.track - The media stream track associated with the resumed consumer.
+ * @param {string} options.kind - The type of media ('audio' or 'video') being resumed.
+ * @param {string} options.remoteProducerId - The ID of the remote producer associated with the resumed consumer.
+ * @param {ResumeParams} options.params - Additional parameters related to the resumed consumer.
+ * @param {ConsumerResumeParameters} options.parameters - The parameters object containing various utility functions and state.
+ * @param {Socket} options.nsock - The socket associated with the consumer.
+ * @throws Will throw an error if an issue occurs during the consumer resumption.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   track: mediaStreamTrack, // MediaStreamTrack to be resumed
+ *   remoteProducerId: 'producer-id', // Remote producer ID
+ *   params: {
+ *     id: 'consumer-id',
+ *     producerId: 'producer-id',
+ *     kind: 'audio',
+ *     rtpParameters: {},
+ *   },
+ *   parameters: consumerResumeParameters, // Parameters for the consumer
+ *   nsock: socket, // Socket for communication
+ * };
+ *
+ * consumerResume(options)
+ *   .then(() => {
+ *     console.log('Consumer resumed successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error resuming consumer:', error);
+ *   });
+ * ```
+ */
 export declare class ConsumerResume {
     /**
      * Resumes a consumer, making it ready for use.