mediasfu-angular 1.0.0

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

@@ -0,0 +1,343 @@
+import { Producer, ProducerOptions, RtpCapabilities, Transport } from 'mediasoup-client/lib/types';
+import { AParamsType, CoHostResponsibility, EventType, HParamsType, Participant, Poll, ScreenParamsType, Stream, VidCons, VParamsType, ConsumeSocket, MeetingRoomParams, UserRecordingParams, ScreenState, AudioDecibels, CustomMediaComponent, GridSizes, Message, WaitingRoomParticipant, Request, BreakoutParticipant, WhiteboardUser, Shape, ResponseJoinRoom, ComponentSizes, Transport as TransportType } from '../../@types/types';
+import { Device } from 'mediasoup-client/lib/types';
+import { Socket } from 'socket.io-client';
+import { SelfieSegmentation } from '@mediapipe/selfie_segmentation';
+export interface InitialValuesStateType {
+    roomName: string;
+    member: string;
+    adminPasscode: string;
+    islevel: string;
+    coHost: string;
+    coHostResponsibility: CoHostResponsibility[];
+    youAreCoHost: boolean;
+    youAreHost: boolean;
+    confirmedToRecord: boolean;
+    meetingDisplayType: string;
+    meetingVideoOptimized: boolean;
+    eventType: EventType;
+    participants: Participant[];
+    filteredParticipants: Participant[];
+    participantsCounter: number;
+    participantsFilter: string;
+    validated: boolean;
+    localUIMode: boolean;
+    socket: Socket;
+    roomData: ResponseJoinRoom | null;
+    device: Device | null;
+    apiKey: string;
+    apiUserName: string;
+    apiToken: string;
+    link: string;
+    consume_sockets: ConsumeSocket[];
+    rtpCapabilities: RtpCapabilities | null;
+    roomRecvIPs: string[];
+    meetingRoomParams: MeetingRoomParams | null;
+    itemPageLimit: number;
+    audioOnlyRoom: boolean;
+    addForBasic: boolean;
+    screenPageLimit: number;
+    shareScreenStarted: boolean;
+    shared: boolean;
+    targetOrientation: string;
+    targetResolution: string;
+    targetResolutionHost: string;
+    vidCons: VidCons;
+    frameRate: number;
+    hParams: HParamsType;
+    vParams: VParamsType;
+    screenParams: ScreenParamsType;
+    aParams: AParamsType;
+    recordingAudioPausesLimit: number;
+    recordingAudioPausesCount: number;
+    recordingAudioSupport: boolean;
+    recordingAudioPeopleLimit: number;
+    recordingAudioParticipantsTimeLimit: number;
+    recordingVideoPausesCount: number;
+    recordingVideoPausesLimit: number;
+    recordingVideoSupport: boolean;
+    recordingVideoPeopleLimit: number;
+    recordingVideoParticipantsTimeLimit: number;
+    recordingAllParticipantsSupport: boolean;
+    recordingVideoParticipantsSupport: boolean;
+    recordingAllParticipantsFullRoomSupport: boolean;
+    recordingVideoParticipantsFullRoomSupport: boolean;
+    recordingPreferredOrientation: string;
+    recordingSupportForOtherOrientation: boolean;
+    recordingMultiFormatsSupport: boolean;
+    userRecordingParams: UserRecordingParams;
+    canRecord: boolean;
+    startReport: boolean;
+    endReport: boolean;
+    recordTimerInterval: NodeJS.Timeout | null;
+    recordStartTime: number;
+    recordElapsedTime: number;
+    isTimerRunning: boolean;
+    canPauseResume: boolean;
+    recordChangeSeconds: number;
+    pauseLimit: number;
+    pauseRecordCount: number;
+    canLaunchRecord: boolean;
+    stopLaunchRecord: boolean;
+    participantsAll: Participant[];
+    firstAll: boolean;
+    updateMainWindow: boolean;
+    first_round: boolean;
+    landScaped: boolean;
+    lock_screen: boolean;
+    screenId: string;
+    allVideoStreams: (Participant | Stream)[];
+    newLimitedStreams: (Participant | Stream)[];
+    newLimitedStreamsIDs: string[];
+    activeSounds: string[];
+    screenShareIDStream: string;
+    screenShareNameStream: string;
+    adminIDStream: string;
+    adminNameStream: string;
+    youYouStream: (Participant | Stream)[];
+    youYouStreamIDs: string[];
+    localStream: MediaStream | null;
+    recordStarted: boolean;
+    recordResumed: boolean;
+    recordPaused: boolean;
+    recordStopped: boolean;
+    adminRestrictSetting: boolean;
+    videoRequestState: string | null;
+    videoRequestTime: number;
+    videoAction: boolean;
+    localStreamVideo: MediaStream | null;
+    userDefaultVideoInputDevice: string;
+    currentFacingMode: string;
+    prevFacingMode: string;
+    defVideoID: string;
+    allowed: boolean;
+    dispActiveNames: string[];
+    activeNames: string[];
+    prevActiveNames: string[];
+    p_activeNames: string[];
+    p_dispActiveNames: string[];
+    membersReceived: boolean;
+    deferScreenReceived: boolean;
+    hostFirstSwitch: boolean;
+    micAction: boolean;
+    screenAction: boolean;
+    chatAction: boolean;
+    audioRequestState: string | null;
+    screenRequestState: string | null;
+    chatRequestState: string | null;
+    audioRequestTime: number;
+    screenRequestTime: number;
+    chatRequestTime: number;
+    updateRequestIntervalSeconds: number;
+    oldSoundIds: string[];
+    hostLabel: string;
+    mainScreenFilled: boolean;
+    localStreamScreen: MediaStream | null;
+    screenAlreadyOn: boolean;
+    chatAlreadyOn: boolean;
+    redirectURL: string;
+    oldAllStreams: (Participant | Stream)[];
+    adminVidID: string;
+    streamNames: Stream[];
+    non_alVideoStreams: Participant[];
+    sortAudioLoudness: boolean;
+    audioDecibels: AudioDecibels[];
+    mixed_alVideoStreams: (Participant | Stream)[];
+    non_alVideoStreams_muted: Participant[];
+    paginatedStreams: (Participant | Stream)[][];
+    localStreamAudio: MediaStream | null;
+    defAudioID: string;
+    userDefaultAudioInputDevice: string;
+    userDefaultAudioOutputDevice: string;
+    prevAudioInputDevice: string;
+    prevVideoInputDevice: string;
+    audioPaused: boolean;
+    mainScreenPerson: string;
+    adminOnMainScreen: boolean;
+    screenStates: ScreenState[];
+    prevScreenStates: ScreenState[];
+    updateDateState: number | null;
+    lastUpdate: number | null;
+    nForReadjustRecord: number;
+    fixedPageLimit: number;
+    removeAltGrid: boolean;
+    nForReadjust: number;
+    reorderInterval: number;
+    fastReorderInterval: number;
+    lastReorderTime: number;
+    audStreamNames: Stream[];
+    currentUserPage: number;
+    mainHeightWidth: number;
+    prevMainHeightWidth: number;
+    prevDoPaginate: boolean;
+    doPaginate: boolean;
+    shareEnded: boolean;
+    lStreams: (Participant | Stream)[];
+    chatRefStreams: (Participant | Stream)[];
+    controlHeight: number;
+    isWideScreen: boolean;
+    isMediumScreen: boolean;
+    isSmallScreen: boolean;
+    addGrid: boolean;
+    addAltGrid: boolean;
+    gridRows: number;
+    gridCols: number;
+    altGridRows: number;
+    altGridCols: number;
+    numberPages: number;
+    currentStreams: (Participant | Stream)[];
+    showMiniView: boolean;
+    nStream: MediaStream | null;
+    defer_receive: boolean;
+    allAudioStreams: (Participant | Stream)[];
+    remoteScreenStream: Stream[];
+    screenProducer: Producer | null;
+    gotAllVids: boolean;
+    paginationHeightWidth: number;
+    paginationDirection: string;
+    gridSizes: GridSizes;
+    screenForceFullDisplay: boolean;
+    mainGridStream: CustomMediaComponent[];
+    otherGridStreams: CustomMediaComponent[][];
+    audioOnlyStreams: CustomMediaComponent[];
+    videoInputs: MediaDeviceInfo[];
+    audioInputs: MediaDeviceInfo[];
+    meetingProgressTime: string;
+    meetingElapsedTime: number;
+    ref_participants: Participant[];
+    messages: Message[];
+    startDirectMessage: boolean;
+    directMessageDetails: Participant | null;
+    showMessagesBadge: boolean;
+    audioSetting: string;
+    videoSetting: string;
+    screenshareSetting: string;
+    chatSetting: string;
+    displayOption: string;
+    autoWave: boolean;
+    forceFullDisplay: boolean;
+    prevForceFullDisplay: boolean;
+    prevMeetingDisplayType: string;
+    waitingRoomFilter: string;
+    waitingRoomList: WaitingRoomParticipant[];
+    waitingRoomCounter: number;
+    filteredWaitingRoomList: WaitingRoomParticipant[];
+    requestFilter: string;
+    requestList: Request[];
+    requestCounter: number;
+    filteredRequestList: Request[];
+    totalReqWait: number;
+    alertVisible: boolean;
+    alertMessage: string;
+    alertType: 'success' | 'danger';
+    alertDuration: number;
+    progressTimerVisible: boolean;
+    progressTimerValue: number;
+    isMenuModalVisible: boolean;
+    isRecordingModalVisible: boolean;
+    isSettingsModalVisible: boolean;
+    isRequestsModalVisible: boolean;
+    isWaitingModalVisible: boolean;
+    isCoHostModalVisible: boolean;
+    isMediaSettingsModalVisible: boolean;
+    isDisplaySettingsModalVisible: boolean;
+    isParticipantsModalVisible: boolean;
+    isMessagesModalVisible: boolean;
+    isConfirmExitModalVisible: boolean;
+    isConfirmHereModalVisible: boolean;
+    isShareEventModalVisible: boolean;
+    isLoadingModalVisible: boolean;
+    recordingMediaOptions: string;
+    recordingAudioOptions: string;
+    recordingVideoOptions: string;
+    recordingVideoType: string;
+    recordingVideoOptimized: boolean;
+    recordingDisplayType: 'video' | 'media' | 'all';
+    recordingAddHLS: boolean;
+    recordingNameTags: boolean;
+    recordingBackgroundColor: string;
+    recordingNameTagsColor: string;
+    recordingAddText: boolean;
+    recordingCustomText: string;
+    recordingCustomTextPosition: string;
+    recordingCustomTextColor: string;
+    recordingOrientationVideo: string;
+    clearedToResume: boolean;
+    clearedToRecord: boolean;
+    recordState: string;
+    showRecordButtons: boolean;
+    recordingProgressTime: string;
+    audioSwitching: boolean;
+    videoSwitching: boolean;
+    videoAlreadyOn: boolean;
+    audioAlreadyOn: boolean;
+    componentSizes: ComponentSizes;
+    hasCameraPermission: boolean;
+    hasAudioPermission: boolean;
+    transportCreated: boolean;
+    transportCreatedVideo: boolean;
+    transportCreatedAudio: boolean;
+    transportCreatedScreen: boolean;
+    producerTransport: Transport | null;
+    videoProducer: Producer | null;
+    params: ProducerOptions;
+    videoParams: ProducerOptions;
+    audioParams: ProducerOptions;
+    audioProducer: Producer | null;
+    consumerTransports: TransportType[];
+    consumingTransports: string[];
+    polls: Poll[];
+    poll: Poll | null;
+    isPollModalVisible: boolean;
+    customImage: string;
+    selectedImage: string;
+    segmentVideo: MediaStream | null;
+    selfieSegmentation: SelfieSegmentation | null;
+    pauseSegmentation: boolean;
+    processedStream: MediaStream | null;
+    keepBackground: boolean;
+    backgroundHasChanged: boolean;
+    virtualStream: MediaStream | null;
+    mainCanvas: HTMLCanvasElement | null;
+    prevKeepBackground: boolean;
+    appliedBackground: boolean;
+    isBackgroundModalVisible: boolean;
+    autoClickBackground: boolean;
+    breakoutRooms: BreakoutParticipant[][];
+    currentRoomIndex: number;
+    canStartBreakout: boolean;
+    breakOutRoomStarted: boolean;
+    breakOutRoomEnded: boolean;
+    hostNewRoom: number;
+    limitedBreakRoom: BreakoutParticipant[];
+    mainRoomsLength: number;
+    memberRoom: number;
+    isBreakoutRoomsModalVisible: boolean;
+    whiteboardUsers: WhiteboardUser[];
+    currentWhiteboardIndex: number;
+    canStartWhiteboard: boolean;
+    whiteboardStarted: boolean;
+    whiteboardEnded: boolean;
+    whiteboardLimit: number;
+    isWhiteboardModalVisible: boolean;
+    isConfigureWhiteboardModalVisible: boolean;
+    shapes: Shape[];
+    useImageBackground: boolean;
+    redoStack: Shape[];
+    undoStack: string[];
+    canvasStream: MediaStream | null;
+    canvasWhiteboard: HTMLCanvasElement | null;
+    canvasScreenboard: HTMLCanvasElement | null;
+    processedScreenStream: MediaStream | null;
+    annotateScreenStream: boolean;
+    mainScreenCanvas: HTMLCanvasElement | null;
+    isScreenboardModalVisible: boolean;
+    micActive: boolean;
+    videoActive: boolean;
+    screenShareActive: boolean;
+    endCallActive: boolean;
+    participantsActive: boolean;
+    menuActive: boolean;
+    commentsActive: boolean;
+}
+export declare const initialValuesState: InitialValuesStateType;

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

@@ -0,0 +1,31 @@
+import * as i0 from "@angular/core";
+export interface StartMeetingProgressTimerParameters {
+    updateMeetingProgressTime: (formattedTime: string) => void;
+    validated: boolean;
+    roomName: string;
+    getUpdatedAllParams: () => StartMeetingProgressTimerParameters;
+    [key: string]: any;
+}
+export interface StartMeetingProgressTimerOptions {
+    startTime: number;
+    parameters: StartMeetingProgressTimerParameters;
+}
+export type StartMeetingProgressTimerType = (options: StartMeetingProgressTimerOptions) => void;
+export declare class StartMeetingProgressTimer {
+    private timeProgress;
+    /**
+     * Starts a timer to track the progress of a meeting.
+     *
+     * @param {Object} options - The options for starting the meeting progress timer.
+     * @param {number} options.startTime - The custom start time for the meeting progress timer.
+     * @param {Object} options.parameters - The parameters required for updating the meeting progress.
+     * @param {Function} options.parameters.updateMeetingProgressTime - Function to update the meeting progress time.
+     * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     *
+     * @returns {void}
+     */
+    startMeetingProgressTimer: ({ startTime, parameters, }: StartMeetingProgressTimerOptions) => void;
+    stopMeetingProgressTimer: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StartMeetingProgressTimer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StartMeetingProgressTimer>;
+}

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

@@ -0,0 +1,46 @@
+import { OnInit, OnDestroy, Injector, ElementRef } from '@angular/core';
+import { ReUpdateInterType, UpdateParticipantAudioDecibelsType, ReUpdateInterParameters, Participant } from '../../../@types/types';
+import * as i0 from "@angular/core";
+export interface MiniAudioPlayerParameters extends ReUpdateInterParameters {
+    breakOutRoomStarted: boolean;
+    breakOutRoomEnded: boolean;
+    limitedBreakRoom: Participant[];
+    reUpdateInter: ReUpdateInterType;
+    updateParticipantAudioDecibels: UpdateParticipantAudioDecibelsType;
+    getUpdatedAllParams: () => MiniAudioPlayerParameters;
+    [key: string]: any;
+}
+export interface MiniAudioPlayerOptions {
+    stream: MediaStream | null;
+    remoteProducerId: string;
+    parameters: MiniAudioPlayerParameters;
+    MiniAudioComponent?: any;
+    miniAudioProps?: Record<string, any>;
+}
+export type MiniAudioPlayerType = (options: MiniAudioPlayerOptions) => HTMLElement;
+export declare class MiniAudioPlayer implements OnInit, OnDestroy {
+    private injector;
+    stream: MediaStream | null;
+    remoteProducerId: string;
+    parameters: MiniAudioPlayerParameters;
+    MiniAudioComponent: any;
+    miniAudioProps: Record<string, any>;
+    audioElement: ElementRef<HTMLAudioElement>;
+    showWaveModal: boolean;
+    isMuted: boolean;
+    audioContext: AudioContext;
+    intervalId: any;
+    autoWaveCheck: boolean;
+    private previousShowWaveModal;
+    private previousIsMuted;
+    private injectorCache;
+    private cachedMiniAudioProps;
+    constructor(injector: Injector, injectedStream: MediaStream | null, injectedRemoteProducerId: string, injectedParameters: MiniAudioPlayerParameters, injectedMiniAudioComponent: any, injectedMiniAudioProps: Record<string, any>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    setupAudioProcessing(): void;
+    createInjector(inputs: any): Injector;
+    getMiniAudioProps(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MiniAudioPlayer, [null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MiniAudioPlayer, "app-mini-audio-player", never, { "stream": { "alias": "stream"; "required": false; }; "remoteProducerId": { "alias": "remoteProducerId"; "required": false; }; "parameters": { "alias": "parameters"; "required": false; }; "MiniAudioComponent": { "alias": "MiniAudioComponent"; "required": false; }; "miniAudioProps": { "alias": "miniAudioProps"; "required": false; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,11 @@
+import { ProducerCodecOptions, RtpEncodingParameters } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export type AParamsType = {
+    encodings: RtpEncodingParameters[];
+    codecOptions?: ProducerCodecOptions;
+};
+export declare class AParams {
+    aParams: AParamsType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AParams, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AParams>;
+}

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

@@ -0,0 +1,11 @@
+import { ProducerCodecOptions, RtpEncodingParameters } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export type HParamsType = {
+    encodings: RtpEncodingParameters[];
+    codecOptions?: ProducerCodecOptions;
+};
+export declare class HParams {
+    hParams: HParamsType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HParams, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HParams>;
+}

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

@@ -0,0 +1,11 @@
+import { ProducerCodecOptions, RtpEncodingParameters } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export type ScreenParamsType = {
+    encodings: RtpEncodingParameters[];
+    codecOptions?: ProducerCodecOptions;
+};
+export declare class ScreenParams {
+    screenParams: ScreenParamsType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenParams, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenParams>;
+}

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

@@ -0,0 +1,11 @@
+import { ProducerCodecOptions, RtpEncodingParameters } from 'mediasoup-client/lib/types';
+import * as i0 from "@angular/core";
+export type VParamsType = {
+    encodings: RtpEncodingParameters[];
+    codecOptions?: ProducerCodecOptions;
+};
+export declare class VParams {
+    vParams: VParamsType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VParams, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VParams>;
+}

package/dist/lib/methods/utils/producer/video-capture-constraints.service.d.ts

@@ -0,0 +1,131 @@
+import * as i0 from "@angular/core";
+export declare class VideoCaptureConstraints {
+    QnHDCons: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    sdCons: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    hdCons: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    fhdCons: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    qhdCons: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    QnHDConsPort: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    sdConsPort: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    hdConsPort: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    fhdConsPort: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    qhdConsPort: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    QnHDConsNeu: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    sdConsNeu: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    hdConsNeu: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    fhdConsNeu: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    qhdConsNeu: {
+        width: {
+            ideal: number;
+        };
+        height: {
+            ideal: number;
+        };
+    };
+    QnHDFrameRate: number;
+    sdFrameRate: number;
+    hdFrameRate: number;
+    fhdFrameRate: number;
+    qhdFrameRate: number;
+    screenFrameRate: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VideoCaptureConstraints, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VideoCaptureConstraints>;
+}

package/dist/lib/methods/utils/sleep.util.d.ts

@@ -0,0 +1,12 @@
+export interface SleepOptions {
+    ms: number;
+}
+export type SleepType = (options: SleepOptions) => Promise<void>;
+/**
+ * Pauses the execution for a specified number of milliseconds.
+ *
+ * @param {SleepOptions} options - An object containing the sleep duration.
+ * @param {number} options.ms - The number of milliseconds to sleep.
+ * @returns {Promise<void>} A promise that resolves after the specified duration.
+ */
+export declare function sleep({ ms }: SleepOptions): Promise<void>;

package/dist/lib/methods/utils/sound-player.service.d.ts

@@ -0,0 +1,13 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface SoundPlayerOptions {
+    soundUrl: string;
+}
+export type SoundPlayerType = (options: SoundPlayerOptions) => void;
+export declare class SoundPlayer implements OnInit {
+    soundUrl: string | undefined;
+    ngOnInit(): void;
+    playSound({ soundUrl }: SoundPlayerOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SoundPlayer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SoundPlayer>;
+}

package/dist/lib/methods/utils/validate-alphanumeric.service.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+export interface ValidateAlphanumericOptions {
+    str: string;
+}
+export type ValidateAlphanumericType = (options: ValidateAlphanumericOptions) => Promise<boolean>;
+export declare class ValidateAlphanumeric {
+    /**
+     * Validates if the given string contains only alphanumeric characters.
+     *
+     * @param {ValidateAlphanumericOptions} options - The options containing the string to validate.
+     * @param {string} options.str - The string to be validated.
+     * @returns {Promise<boolean>} - A promise that resolves to `true` if the string is alphanumeric, otherwise `false`.
+     */
+    validateAlphanumeric({ str }: ValidateAlphanumericOptions): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidateAlphanumeric, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidateAlphanumeric>;
+}

package/dist/lib/methods/waiting-methods/launch-waiting.service.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+export interface LaunchWaitingOptions {
+    updateIsWaitingModalVisible: (visible: boolean) => void;
+    isWaitingModalVisible: boolean;
+}
+export type LaunchWaitingType = (options: LaunchWaitingOptions) => void;
+export declare class LaunchWaiting {
+    /**
+     * Toggles the visibility of the waiting modal.
+     *
+     * @param updateIsWaitingModalVisible - Function to update the visibility state of the waiting modal.
+     * @param isWaitingModalVisible - Current visibility state of the waiting modal.
+     */
+    launchWaiting({ updateIsWaitingModalVisible, isWaitingModalVisible, }: LaunchWaitingOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaunchWaiting, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaunchWaiting>;
+}