mediasfu-angular 1.0.1 → 2.0.0

package/dist/lib/methods/utils/format-number.service.d.ts

@@ -3,21 +3,33 @@ export interface FormatNumberOptions {
     number: number;
 }
 export type FormatNumberType = (options: FormatNumberOptions) => Promise<string | undefined>;
+/**
+ * The `FormatNumber` service provides functionality to format numeric values
+ * into a more readable string representation, appending appropriate suffixes
+ * like K (thousands), M (millions), and B (billions).
+ *
+ * @service
+ * @example
+ * ```typescript
+ * import { FormatNumber } from 'mediasfu-angular';
+ *
+ * constructor(private formatNumber: FormatNumber) {}
+ *
+ * async displayFormattedNumber() {
+ *   const formatted = await this.formatNumber.formatNumber({ number: 1500 });
+ *   console.log(formatted); // Outputs: "1.5K"
+ * }
+ * ```
+ *
+ * @remarks
+ * This service can be useful for displaying large numbers in a more compact form
+ * in user interfaces, especially in dashboards or reports where space is limited.
+ *
+ * @property {FormatNumberOptions} options - Options containing the number to format.
+ *
+ * @returns {FormatNumber} The FormatNumber service for formatting numeric values.
+ */
 export declare class FormatNumber {
-    /**
-     * Formats a number into a string representation with appropriate suffixes (K, M, B).
-     *
-     * @param number - The number to format.
-     * @returns A promise that resolves to a formatted string or undefined if the input is falsy.
-     *
-     * @example
-     * ```typescript
-     * formatNumber(500); // "500"
-     * formatNumber(1500); // "1.5K"
-     * formatNumber(1500000); // "1.5M"
-     * formatNumber(1500000000); // "1.5B"
-     * ```
-     */
     formatNumber({ number }: FormatNumberOptions): Promise<string | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormatNumber, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FormatNumber>;

package/dist/lib/methods/utils/generate-random-messages.service.d.ts

@@ -8,6 +8,39 @@ export interface GenerateRandomMessagesOptions {
     forChatBroadcast?: boolean;
 }
 export type GenerateRandomMessagesType = (options: GenerateRandomMessagesOptions) => Message[];
+/**
+ * GenerateRandomMessages - Service to generate random chat messages from participants.
+ *
+ * This service generates random direct and group messages based on participants and a given host setup,
+ * with options to tailor messages for chat broadcast.
+ *
+ * @class
+ * @name GenerateRandomMessages
+ * @example
+ * ```typescript
+ * const generateRandomMessagesService = new GenerateRandomMessages();
+ * const messages = generateRandomMessagesService.generateRandomMessages({
+ *   participants: [
+ *     { name: 'Alice' },
+ *     { name: 'Bob' },
+ *     { name: 'Charlie' }
+ *   ],
+ *   member: 'Alice',
+ *   coHost: 'Bob',
+ *   host: 'Charlie',
+ *   forChatBroadcast: true
+ * });
+ * console.log(messages);
+ * ```
+ *
+ * @param {Object} options - Options for generating random messages.
+ * @param {Participant[]} options.participants - List of participants for message generation.
+ * @param {string} options.member - The primary member in the chat.
+ * @param {string} [options.coHost] - Optional co-host participant.
+ * @param {string} options.host - The chat host.
+ * @param {boolean} [options.forChatBroadcast=false] - Flag to indicate if messages are for chat broadcast.
+ * @returns {Message[]} Array of randomly generated messages with direct and group messaging.
+ */
 export declare class GenerateRandomMessages {
     /**
      * Generates random messages for a given set of participants.

package/dist/lib/methods/utils/generate-random-participants.service.d.ts

@@ -7,6 +7,33 @@ export interface GenerateRandomParticipantsOptions {
     forChatBroadcast?: boolean;
 }
 export type GenerateRandomParticipantsType = (options: GenerateRandomParticipantsOptions) => Participant[];
+/**
+ * GenerateRandomParticipants - Service to generate a list of random participants.
+ *
+ * This service creates a list of participants based on a set of specified options, with customization for chat broadcasts
+ * and designation of specific roles like member, co-host, and host.
+ *
+ * @class
+ * @name GenerateRandomParticipants
+ * @example
+ * ```typescript
+ * const generateRandomParticipantsService = new GenerateRandomParticipants();
+ * const participants = generateRandomParticipantsService.generateRandomParticipants({
+ *   member: 'Alice',
+ *   coHost: 'Bob',
+ *   host: 'Charlie',
+ *   forChatBroadcast: true
+ * });
+ * console.log(participants);
+ * ```
+ *
+ * @param {Object} options - Options for generating participants.
+ * @param {string} options.member - Primary member to include in the participants list.
+ * @param {string} [options.coHost] - Optional co-host in the participants list.
+ * @param {string} options.host - Host to include in the participants list.
+ * @param {boolean} [options.forChatBroadcast=false] - Indicates if participants are for a chat broadcast.
+ * @returns {Participant[]} Array of generated participants with randomized levels, muted states, and identifiers.
+ */
 export declare class GenerateRandomParticipants {
     /**
      * Generates a list of random participants with specified options.

package/dist/lib/methods/utils/generate-random-polls.service.d.ts

@@ -4,6 +4,32 @@ export interface GenerateRandomPollsOptions {
     numberOfPolls: number;
 }
 export type GenerateRandomPollsType = (options: GenerateRandomPollsOptions) => Poll[];
+/**
+   * Generates an array of random poll objects with varying types and options.
+   *
+   * Each poll includes a question, a type (e.g., "trueFalse", "yesNo", or "custom"), and multiple choice options.
+   * Poll types determine the options generated:
+   * - `"trueFalse"` polls have "True" and "False" options.
+   * - `"yesNo"` polls have "Yes" and "No" options.
+   * - `"custom"` polls generate 2–6 custom options labeled as "Option 1", "Option 2", etc.
+   *
+   * @param {GenerateRandomPollsOptions} options - An object containing the number of polls to generate.
+   * @param {number} options.numberOfPolls - The number of random polls to generate.
+   * @returns {Poll[]} An array of generated polls with unique IDs and randomly selected types and options.
+   *
+   * @example
+   * const pollService = new GenerateRandomPolls();
+   * const options = { numberOfPolls: 3 };
+   * const randomPolls = pollService.generateRandomPolls(options);
+   *
+   * console.log(randomPolls);
+   * // Output:
+   * // [
+   * //   { id: '1', question: 'Random Question 1', type: 'yesNo', options: ['Yes', 'No'], votes: [0, 0], status: 'inactive', voters: {} },
+   * //   { id: '2', question: 'Random Question 2', type: 'trueFalse', options: ['True', 'False'], votes: [0, 0], status: 'inactive', voters: {} },
+   * //   { id: '3', question: 'Random Question 3', type: 'custom', options: ['Option 1', 'Option 2', 'Option 3'], votes: [0, 0, 0], status: 'inactive', voters: {} }
+   * // ]
+   */
 export declare class GenerateRandomPolls {
     /**
      * Generates an array of random poll objects.

package/dist/lib/methods/utils/generate-random-request-list.service.d.ts

@@ -7,6 +7,42 @@ export interface GenerateRandomRequestListOptions {
     numberOfRequests: number;
 }
 export type GenerateRandomRequestListType = (options: GenerateRandomRequestListOptions) => Request[];
+/**
+  * Generates a random list of requests for participants, ensuring unique icons per participant
+  * and excluding the host and co-host from the request list.
+  *
+  * @param {GenerateRandomRequestListOptions} options - Configuration options for generating requests.
+  * @param {Participant[]} options.participants - Array of participant objects.
+  * @param {string} options.hostName - Name of the host to be excluded.
+  * @param {string} [options.coHostName] - Optional name of the co-host to be excluded.
+  * @param {number} options.numberOfRequests - Number of requests to generate per participant.
+  * @returns {Request[]} Array of requests, each uniquely associated with a participant.
+  *
+  * @example
+  * ```typescript
+  * const requestService = new GenerateRandomRequestList();
+  * const participants = [
+  *   { id: '1', name: 'Alice' },
+  *   { id: '2', name: 'Bob' },
+  *   { id: '3', name: 'Charlie' }
+  * ];
+  * const options = {
+  *   participants,
+  *   hostName: 'Alice',
+  *   coHostName: 'Bob',
+  *   numberOfRequests: 2
+  * };
+  *
+  * const requests = requestService.generateRandomRequestList(options);
+  *
+  * console.log(requests);
+  * // Output:
+  * // [
+  * //   { id: '3', name: 'charlie', icon: 'fa-microphone', username: 'charlie' },
+  * //   { id: '3', name: 'charlie', icon: 'fa-desktop', username: 'charlie' }
+  * // ]
+  * ```
+  */
 export declare class GenerateRandomRequestList {
     /**
      * Generates a list of random requests for participants, excluding the host and co-host.

package/dist/lib/methods/utils/generate-random-waiting-room-list.service.d.ts

@@ -1,6 +1,27 @@
 import { WaitingRoomParticipant } from '../../@types/types';
 import * as i0 from "@angular/core";
 export type GenerateRandomWaitingRoomListType = () => WaitingRoomParticipant[];
+/**
+  * Generates a random list of participants for a waiting room.
+  *
+  * @returns {WaitingRoomParticipant[]} An array of `WaitingRoomParticipant` objects, each with a unique ID and random name.
+  *
+  * @example
+  * ```typescript
+  * const generateListService = new GenerateRandomWaitingRoomList();
+  * const waitingRoomList = generateListService.generateRandomWaitingRoomList();
+  *
+  * console.log(waitingRoomList);
+  * // Output:
+  * // [
+  * //   { name: 'Dimen', id: '0' },
+  * //   { name: 'Nore', id: '1' },
+  * //   { name: 'Ker', id: '2' },
+  * //   { name: 'Lor', id: '3' },
+  * //   { name: 'Mik', id: '4' }
+  * // ]
+  * ```
+  */
 export declare class GenerateRandomWaitingRoomList {
     /**
      * Generates a random list of participants for a waiting room.

package/dist/lib/methods/utils/get-modal-position.util.d.ts

@@ -8,8 +8,18 @@ export interface GetModalPositionOptions {
 export type GetModalPositionType = (options: GetModalPositionOptions) => ModalPositionStyle;
 /**
  * Gets the style for positioning a modal based on the specified position.
- * @function
- * @param {string} position - The desired position for the modal ('center', 'topLeft', 'topRight', 'bottomLeft', 'bottomRight').
- * @returns {ModalPositionStyle} - The style object for positioning the modal.
+ *
+ * @param {GetModalPositionOptions} options - Object containing the desired modal position.
+ * @param {string} options.position - The modal position ('center', 'topLeft', 'topRight', 'bottomLeft', 'bottomRight').
+ * @returns {ModalPositionStyle} - Style object for aligning the modal according to the specified position.
+ *
+ * @example
+ * ```typescript
+ * const positionStyle = getModalPosition({ position: 'center' });
+ * // Output: { justifyContent: 'center', alignItems: 'center' }
+ *
+ * const topLeftStyle = getModalPosition({ position: 'topLeft' });
+ * // Output: { justifyContent: 'flex-start', alignItems: 'flex-start' }
+ * ```
  */
 export declare function getModalPosition({ position }: GetModalPositionOptions): ModalPositionStyle;

package/dist/lib/methods/utils/get-overlay-position.util.d.ts

@@ -5,8 +5,18 @@ export interface GetOverlayPositionOptions {
 export type GetOverlayPositionType = (options: GetOverlayPositionOptions) => OverlayPositionStyle;
 /**
  * Gets the style for positioning an overlay based on the specified position.
- * @function
- * @param {string} position - The desired position for the overlay ('topLeft', 'topRight', 'bottomLeft', 'bottomRight').
- * @returns {OverlayPositionStyle} - The style object for positioning the overlay.
+ *
+ * @param {GetOverlayPositionOptions} options - Contains the desired position for the overlay.
+ * @param {string} options.position - The position for the overlay ('topLeft', 'topRight', 'bottomLeft', 'bottomRight').
+ * @returns {OverlayPositionStyle} - Style object defining the overlay position.
+ *
+ * @example
+ * ```typescript
+ * const topLeftPosition = getOverlayPosition({ position: 'topLeft' });
+ * // Output: { top: 0, left: 0 }
+ *
+ * const bottomRightPosition = getOverlayPosition({ position: 'bottomRight' });
+ * // Output: { bottom: 0, right: 0 }
+ * ```
  */
 export declare function getOverlayPosition({ position }: GetOverlayPositionOptions): OverlayPositionStyle;

package/dist/lib/methods/utils/initial-values.util.d.ts

@@ -23,6 +23,7 @@ export interface InitialValuesStateType {
     validated: boolean;
     localUIMode: boolean;
     socket: Socket;
+    localSocket?: Socket;
     roomData: ResponseJoinRoom | null;
     device: Device | null;
     apiKey: string;
@@ -192,6 +193,7 @@ export interface InitialValuesStateType {
     allAudioStreams: (Participant | Stream)[];
     remoteScreenStream: Stream[];
     screenProducer: Producer | null;
+    localScreenProducer: Producer | null;
     gotAllVids: boolean;
     paginationHeightWidth: number;
     paginationDirection: string;
@@ -275,15 +277,19 @@ export interface InitialValuesStateType {
     hasCameraPermission: boolean;
     hasAudioPermission: boolean;
     transportCreated: boolean;
+    localTransportCreated: boolean;
     transportCreatedVideo: boolean;
     transportCreatedAudio: boolean;
     transportCreatedScreen: boolean;
     producerTransport: Transport | null;
+    localProducerTransport: Transport | null;
     videoProducer: Producer | null;
+    localVideoProducer: Producer | null;
     params: ProducerOptions;
     videoParams: ProducerOptions;
     audioParams: ProducerOptions;
     audioProducer: Producer | null;
+    localAudioProducer: Producer | null;
     consumerTransports: TransportType[];
     consumingTransports: string[];
     polls: Poll[];

package/dist/lib/methods/utils/join-room-on-media-sfu.service.d.ts

@@ -0,0 +1,52 @@
+import * as i0 from "@angular/core";
+export type CreateJoinRoomType = (options: {
+    payload: any;
+    apiUserName: string;
+    apiKey: string;
+}) => Promise<{
+    data: CreateJoinRoomResponse | CreateJoinRoomError | null;
+    success: boolean;
+}>;
+export type CreateRoomOnMediaSFUType = (options: {
+    payload: any;
+    apiUserName: string;
+    apiKey: string;
+}) => Promise<{
+    data: CreateJoinRoomResponse | CreateJoinRoomError | null;
+    success: boolean;
+}>;
+export interface CreateJoinRoomResponse {
+    message: string;
+    roomName: string;
+    secureCode?: string;
+    publicURL: string;
+    link: string;
+    secret: string;
+    success: boolean;
+}
+export interface CreateJoinRoomError {
+    error: string;
+    success?: boolean;
+}
+export declare class JoinRoomOnMediaSFU {
+    private readonly API_URL;
+    constructor();
+    /**
+     * Joins a room on MediaSFU.
+     *
+     * @param payload - The payload for the API request.
+     * @param apiUserName - The API username.
+     * @param apiKey - The API key.
+     * @returns The API response.
+     */
+    joinRoomOnMediaSFU({ payload, apiUserName, apiKey, }: {
+        payload: any;
+        apiUserName: string;
+        apiKey: string;
+    }): Promise<{
+        data: CreateJoinRoomResponse | CreateJoinRoomError | null;
+        success: boolean;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JoinRoomOnMediaSFU, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JoinRoomOnMediaSFU>;
+}

package/dist/lib/methods/utils/meeting-timer/start-meeting-progress-timer.service.d.ts

@@ -11,6 +11,43 @@ export interface StartMeetingProgressTimerOptions {
     parameters: StartMeetingProgressTimerParameters;
 }
 export type StartMeetingProgressTimerType = (options: StartMeetingProgressTimerOptions) => void;
+/**
+ * Starts a timer to track the progress of a meeting.
+ *
+ * @param {StartMeetingProgressTimerOptions} options - The options for starting the meeting progress timer.
+ * @param {number} options.startTime - The custom start time for the meeting progress timer in seconds since epoch.
+ * @param {StartMeetingProgressTimerParameters} options.parameters - The parameters required for updating the meeting progress.
+ * @param {Function} options.parameters.updateMeetingProgressTime - Function to update the formatted meeting progress time.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ *
+ * @returns {void}
+ *
+ * @remarks
+ * This function calculates the elapsed time since the meeting started and updates the meeting progress every second.
+ * The timer will stop if the validated flag is set to false or if the room name is not valid.
+ *
+ * The time is formatted in HH:MM:SS format, and the update function is called with the formatted time.
+ *
+ * @example
+ * ```typescript
+ * const options: StartMeetingProgressTimerOptions = {
+ *   startTime: Math.floor(Date.now() / 1000), // Current time in seconds
+ *   parameters: {
+ *     updateMeetingProgressTime: (formattedTime) => console.log(`Meeting Progress: ${formattedTime}`),
+ *     validated: true,
+ *     roomName: 'Room123',
+ *     getUpdatedAllParams: () => ({
+ *       validated: true,
+ *       roomName: 'Room123',
+ *       updateMeetingProgressTime: options.parameters.updateMeetingProgressTime,
+ *     }),
+ *   },
+ * };
+ *
+ * const timerService = new StartMeetingProgressTimer();
+ * timerService.startMeetingProgressTimer(options);
+ * ```
+ */
 export declare class StartMeetingProgressTimer {
     private timeProgress;
     /**

package/dist/lib/methods/utils/mini-audio-player/mini-audio-player.component.d.ts

@@ -18,6 +18,61 @@ export interface MiniAudioPlayerOptions {
     miniAudioProps?: Record<string, any>;
 }
 export type MiniAudioPlayerType = (options: MiniAudioPlayerOptions) => HTMLElement;
+/**
+ * The `MiniAudioPlayer` component manages audio playback for participants in a meeting, including volume control, audio visualization, and connection to the main application state.
+ * It uses audio analysis to display waveforms for active speakers and supports breakout room conditions, participant-specific audio decibel updates, and other media state dependencies.
+ *
+ * @component
+ * @example
+ * ```html
+ * <app-mini-audio-player
+ *    [stream]="audioStream"
+ *    [remoteProducerId]="producerId"
+ *    [parameters]="audioPlayerParameters">
+ * </app-mini-audio-player>
+ * ```
+ *
+ * @param {MediaStream} [stream] - The audio stream from the participant.
+ * @param {string} [remoteProducerId] - Unique ID for the remote producer of the audio stream.
+ * @param {MiniAudioPlayerParameters} [parameters] - Configuration object with various parameters and utility functions for audio management.
+ * @param {Component} [MiniAudioComponent] - Optional audio visualization component injected into the `MiniAudioPlayer`.
+ * @param {Record<string, any>} [miniAudioProps] - Additional properties for configuring the audio visualization component.
+ *
+ * @returns {HTMLElement} The created audio player element.
+ *
+ * @remarks
+ * The `MiniAudioPlayer` leverages the `AudioContext` API to process audio data, analyze frequency, and manage audio levels.
+ * It supports a dynamic breakout room feature that restricts audio visibility to limited participants, updates decibel levels for individual participants, and adjusts the waveforms based on audio activity.
+ *
+ * Key functionalities include:
+ * - Automatically toggling wave visualization for active speakers.
+ * - Handling audio settings for different room states (e.g., shared screens, breakout rooms).
+ * - Injecting configuration and parameter dependencies dynamically through `Injector`.
+ *
+ * @dependencies
+ * - `AudioContext`: Web API for processing and analyzing audio data.
+ * - `setInterval` for periodic volume level checks (auto-clears on component destruction).
+ * - `ReUpdateInterType` and `UpdateParticipantAudioDecibelsType` for dynamic participant audio decibel management.
+ *
+ * @example
+ * ```typescript
+ * const audioPlayerParameters: MiniAudioPlayerParameters = {
+ *   breakOutRoomStarted: true,
+ *   breakOutRoomEnded: false,
+ *   limitedBreakRoom: participantList,
+ *   reUpdateInter: reUpdateInterFunc,
+ *   updateParticipantAudioDecibels: updateAudioDecibelsFunc,
+ *   getUpdatedAllParams: () => getParams(),
+ * };
+ *
+ * // Initialize component with required inputs
+ * <app-mini-audio-player
+ *   [stream]="audioStream"
+ *   [remoteProducerId]="participantId"
+ *   [parameters]="audioPlayerParameters"
+ * ></app-mini-audio-player>
+ * ```
+ */
 export declare class MiniAudioPlayer implements OnInit, OnDestroy {
     private injector;
     stream: MediaStream | null;

package/dist/lib/methods/utils/producer/a-params.service.d.ts

@@ -4,6 +4,43 @@ export type AParamsType = {
     encodings: RtpEncodingParameters[];
     codecOptions?: ProducerCodecOptions;
 };
+/**
+ * The `AParams` service provides the encoding parameters for audio production in a media session using the Mediasoup library.
+ * It includes a default configuration for RTP encoding parameters, which can be used when creating audio producers.
+ *
+ * @service
+ * @example
+ * ```typescript
+ * import { AParams } from './path/to/a-params.service';
+ *
+ * constructor(private aParamsService: AParams) {
+ *   console.log(this.aParamsService.aParams);
+ * }
+ * ```
+ *
+ * @typedef AParamsType
+ * @property {RtpEncodingParameters[]} encodings - Array of RTP encoding parameters for audio.
+ * @property {ProducerCodecOptions} [codecOptions] - Optional codec options for the audio producer.
+ *
+ * @example
+ * const aParams: AParamsType = {
+ *   encodings: [
+ *     {
+ *       rid: 'r0',
+ *       maxBitrate: 64000, // Max bitrate for the audio stream (in bps)
+ *     },
+ *   ],
+ *   codecOptions: {
+ *     // Additional codec options can be defined here
+ *   },
+ * };
+ *
+ * @remarks
+ * The default `aParams` contains a single encoding with a `rid` of "r0" and a maximum bitrate of 64 kbps.
+ * This configuration can be adjusted based on application requirements.
+ *
+ * @returns {AParamsType} The audio parameters for use in audio producer configuration.
+ */
 export declare class AParams {
     aParams: AParamsType;
     static ɵfac: i0.ɵɵFactoryDeclaration<AParams, never>;

package/dist/lib/methods/utils/producer/h-params.service.d.ts

@@ -4,6 +4,56 @@ export type HParamsType = {
     encodings: RtpEncodingParameters[];
     codecOptions?: ProducerCodecOptions;
 };
+/**
+ * The `HParams` service provides encoding parameters for video production in a media session using the Mediasoup library.
+ * It includes a default configuration for RTP encoding parameters designed for handling high-quality video streams.
+ *
+ * @service
+ * @example
+ * ```typescript
+ * import { HParams } from './path/to/h-params.service';
+ *
+ * constructor(private hParamsService: HParams) {
+ *   console.log(this.hParamsService.hParams);
+ * }
+ * ```
+ *
+ * @typedef HParamsType
+ * @property {RtpEncodingParameters[]} encodings - Array of RTP encoding parameters for video.
+ * @property {ProducerCodecOptions} [codecOptions] - Optional codec options for the video producer.
+ *
+ * @example
+ * const hParams: HParamsType = {
+ *   encodings: [
+ *     {
+ *       rid: 'r8',
+ *       maxBitrate: 240000, // Max bitrate for this encoding (in bps)
+ *       scalabilityMode: 'L1T3', // Scalable video coding mode
+ *       scaleResolutionDownBy: 4.0, // Scale down the resolution by a factor of 4
+ *     },
+ *     {
+ *       rid: 'r9',
+ *       maxBitrate: 480000,
+ *       scalabilityMode: 'L1T3',
+ *       scaleResolutionDownBy: 2.0, // Scale down the resolution by a factor of 2
+ *     },
+ *     {
+ *       rid: 'r10',
+ *       maxBitrate: 960000,
+ *       scalabilityMode: 'L1T3',
+ *     },
+ *   ],
+ *   codecOptions: {
+ *     videoGoogleStartBitrate: 320, // Initial bitrate for the Google codec
+ *   },
+ * };
+ *
+ * @remarks
+ * The default `hParams` includes three encoding configurations with different resolutions and bitrates.
+ * The configurations are optimized for scalable video encoding, allowing for adaptive bitrate streaming based on network conditions.
+ *
+ * @returns {HParamsType} The video parameters for use in video producer configuration.
+ */
 export declare class HParams {
     hParams: HParamsType;
     static ɵfac: i0.ɵɵFactoryDeclaration<HParams, never>;

package/dist/lib/methods/utils/producer/screen-params.service.d.ts

@@ -4,6 +4,43 @@ export type ScreenParamsType = {
     encodings: RtpEncodingParameters[];
     codecOptions?: ProducerCodecOptions;
 };
+/**
+ * The `ScreenParams` service provides encoding parameters specifically for screen sharing in a media session using the Mediasoup library.
+ * It includes a default configuration for RTP encoding parameters optimized for high-quality screen sharing.
+ *
+ * @service
+ * @example
+ * ```typescript
+ * import { ScreenParams } from './path/to/screen-params.service';
+ *
+ * constructor(private screenParamsService: ScreenParams) {
+ *   console.log(this.screenParamsService.screenParams);
+ * }
+ * ```
+ *
+ * @typedef ScreenParamsType
+ * @property {RtpEncodingParameters[]} encodings - Array of RTP encoding parameters for screen sharing.
+ * @property {ProducerCodecOptions} [codecOptions] - Optional codec options for the screen sharing producer.
+ *
+ * @example
+ * const screenParams: ScreenParamsType = {
+ *   encodings: [
+ *     {
+ *       rid: 'r7',
+ *       maxBitrate: 3000000, // Max bitrate for this encoding (in bps)
+ *     },
+ *   ],
+ *   codecOptions: {
+ *     videoGoogleStartBitrate: 1000, // Initial bitrate for the Google codec
+ *   },
+ * };
+ *
+ * @remarks
+ * The default `screenParams` includes one encoding configuration with a high maximum bitrate suitable for sharing detailed screen content.
+ * The parameters are optimized to ensure a smooth experience during screen sharing sessions.
+ *
+ * @returns {ScreenParamsType} The screen sharing parameters for use in screen sharing producer configuration.
+ */
 export declare class ScreenParams {
     screenParams: ScreenParamsType;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScreenParams, never>;

package/dist/lib/methods/utils/producer/v-params.service.d.ts

@@ -4,6 +4,56 @@ export type VParamsType = {
     encodings: RtpEncodingParameters[];
     codecOptions?: ProducerCodecOptions;
 };
+/**
+ * The `VParams` service provides encoding parameters for video in a media session using the Mediasoup library.
+ * It includes a default configuration for RTP encoding parameters optimized for video streaming.
+ *
+ * @service
+ * @example
+ * ```typescript
+ * import { VParams } from './path/to/v-params.service';
+ *
+ * constructor(private vParamsService: VParams) {
+ *   console.log(this.vParamsService.vParams);
+ * }
+ * ```
+ *
+ * @typedef VParamsType
+ * @property {RtpEncodingParameters[]} encodings - Array of RTP encoding parameters for video.
+ * @property {ProducerCodecOptions} [codecOptions] - Optional codec options for the video producer.
+ *
+ * @example
+ * const vParams: VParamsType = {
+ *   encodings: [
+ *     {
+ *       rid: 'r3',
+ *       maxBitrate: 200000, // Max bitrate for this encoding (in bps)
+ *       scalabilityMode: 'L1T3', // Scalability mode for encoding
+ *       scaleResolutionDownBy: 4.0, // Scale down resolution by this factor
+ *     },
+ *     {
+ *       rid: 'r4',
+ *       maxBitrate: 400000,
+ *       scalabilityMode: 'L1T3',
+ *       scaleResolutionDownBy: 2.0,
+ *     },
+ *     {
+ *       rid: 'r5',
+ *       maxBitrate: 800000,
+ *       scalabilityMode: 'L1T3',
+ *     },
+ *   ],
+ *   codecOptions: {
+ *     videoGoogleStartBitrate: 320, // Initial bitrate for the Google codec
+ *   },
+ * };
+ *
+ * @remarks
+ * The default `vParams` includes multiple encoding configurations with different maximum bitrates,
+ * allowing for adaptive streaming based on network conditions and participant capabilities.
+ *
+ * @returns {VParamsType} The video parameters for use in video producer configuration.
+ */
 export declare class VParams {
     vParams: VParamsType;
     static ɵfac: i0.ɵɵFactoryDeclaration<VParams, never>;