mediasfu-shared 1.0.5 → 1.1.0

package/dist/methods/utils/initialValuesState.d.ts

@@ -0,0 +1,388 @@
+export declare const initialValuesState: {
+    roomName: string;
+    member: string;
+    adminPasscode: string;
+    islevel: string;
+    coHost: string;
+    coHostResponsibility: {
+        name: string;
+        value: boolean;
+        dedicated: boolean;
+    }[];
+    youAreCoHost: boolean;
+    youAreHost: boolean;
+    confirmedToRecord: boolean;
+    meetingDisplayType: string;
+    meetingVideoOptimized: boolean;
+    eventType: string;
+    participants: never[];
+    filteredParticipants: never[];
+    participantsCounter: number;
+    participantsFilter: string;
+    validated: boolean;
+    localUIMode: boolean;
+    socket: {};
+    localSocket: undefined;
+    roomData: null;
+    device: null;
+    apiKey: string;
+    apiUserName: string;
+    apiToken: string;
+    link: string;
+    consume_sockets: never[];
+    rtpCapabilities: null;
+    roomRecvIPs: never[];
+    meetingRoomParams: null;
+    itemPageLimit: number;
+    audioOnlyRoom: boolean;
+    addForBasic: boolean;
+    screenPageLimit: number;
+    shareScreenStarted: boolean;
+    shared: boolean;
+    targetOrientation: string;
+    targetResolution: string;
+    targetResolutionHost: string;
+    vidCons: {
+        width: number;
+        height: number;
+    };
+    frameRate: number;
+    hParams: {};
+    vParams: {};
+    screenParams: {};
+    aParams: {};
+    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: {
+        mainSpecs: {
+            mediaOptions: string;
+            audioOptions: string;
+            videoOptions: string;
+            videoType: string;
+            videoOptimized: boolean;
+            recordingDisplayType: string;
+            addHLS: boolean;
+        };
+        dispSpecs: {
+            nameTags: boolean;
+            backgroundColor: string;
+            nameTagsColor: string;
+            orientationVideo: string;
+        };
+    };
+    canRecord: boolean;
+    startReport: boolean;
+    endReport: boolean;
+    recordTimerInterval: null;
+    recordStartTime: number;
+    recordElapsedTime: number;
+    isTimerRunning: boolean;
+    canPauseResume: boolean;
+    recordChangeSeconds: number;
+    pauseLimit: number;
+    pauseRecordCount: number;
+    canLaunchRecord: boolean;
+    stopLaunchRecord: boolean;
+    participantsAll: never[];
+    firstAll: boolean;
+    updateMainWindow: boolean;
+    first_round: boolean;
+    landScaped: boolean;
+    lock_screen: boolean;
+    screenId: string;
+    allVideoStreams: never[];
+    newLimitedStreams: never[];
+    newLimitedStreamsIDs: never[];
+    activeSounds: never[];
+    screenShareIDStream: string;
+    screenShareNameStream: string;
+    adminIDStream: string;
+    adminNameStream: string;
+    youYouStream: never[];
+    youYouStreamIDs: never[];
+    localStream: null;
+    recordStarted: boolean;
+    recordResumed: boolean;
+    recordPaused: boolean;
+    recordStopped: boolean;
+    adminRestrictSetting: boolean;
+    videoRequestState: null;
+    videoRequestTime: number;
+    videoAction: boolean;
+    localStreamVideo: null;
+    userDefaultVideoInputDevice: string;
+    currentFacingMode: string;
+    prevFacingMode: string;
+    defVideoID: string;
+    allowed: boolean;
+    dispActiveNames: never[];
+    activeNames: never[];
+    prevActiveNames: never[];
+    p_activeNames: never[];
+    p_dispActiveNames: never[];
+    membersReceived: boolean;
+    deferScreenReceived: boolean;
+    hostFirstSwitch: boolean;
+    micAction: boolean;
+    screenAction: boolean;
+    chatAction: boolean;
+    audioRequestState: null;
+    screenRequestState: null;
+    chatRequestState: null;
+    audioRequestTime: number;
+    screenRequestTime: number;
+    chatRequestTime: number;
+    updateRequestIntervalSeconds: number;
+    oldSoundIds: never[];
+    hostLabel: string;
+    mainScreenFilled: boolean;
+    localStreamScreen: null;
+    screenAlreadyOn: boolean;
+    chatAlreadyOn: boolean;
+    redirectURL: string;
+    oldAllStreams: never[];
+    adminVidID: string;
+    streamNames: never[];
+    non_alVideoStreams: never[];
+    sortAudioLoudness: boolean;
+    audioDecibels: never[];
+    mixed_alVideoStreams: never[];
+    non_alVideoStreams_muted: never[];
+    paginatedStreams: never[];
+    localStreamAudio: null;
+    defAudioID: string;
+    userDefaultAudioInputDevice: string;
+    userDefaultAudioOutputDevice: string;
+    prevAudioInputDevice: string;
+    prevVideoInputDevice: string;
+    audioPaused: boolean;
+    mainScreenPerson: string;
+    adminOnMainScreen: boolean;
+    screenStates: {
+        mainScreenPerson: string;
+        mainScreenProducerId: string;
+        mainScreenFilled: boolean;
+        adminOnMainScreen: boolean;
+    }[];
+    prevScreenStates: {
+        mainScreenPerson: string;
+        mainScreenProducerId: string;
+        mainScreenFilled: boolean;
+        adminOnMainScreen: boolean;
+    }[];
+    updateDateState: null;
+    lastUpdate: null;
+    nForReadjustRecord: number;
+    fixedPageLimit: number;
+    removeAltGrid: boolean;
+    nForReadjust: number;
+    reorderInterval: number;
+    fastReorderInterval: number;
+    lastReorderTime: number;
+    audStreamNames: never[];
+    currentUserPage: number;
+    mainHeightWidth: number;
+    prevMainHeightWidth: number;
+    prevDoPaginate: boolean;
+    doPaginate: boolean;
+    shareEnded: boolean;
+    lStreams: never[];
+    chatRefStreams: never[];
+    controlHeight: number;
+    isWideScreen: boolean;
+    isMediumScreen: boolean;
+    isSmallScreen: boolean;
+    addGrid: boolean;
+    addAltGrid: boolean;
+    gridRows: number;
+    gridCols: number;
+    altGridRows: number;
+    altGridCols: number;
+    numberPages: number;
+    currentStreams: never[];
+    showMiniView: boolean;
+    nStream: null;
+    defer_receive: boolean;
+    allAudioStreams: never[];
+    remoteScreenStream: never[];
+    screenProducer: null;
+    localScreenProducer: null;
+    gotAllVids: boolean;
+    paginationHeightWidth: number;
+    paginationDirection: string;
+    gridSizes: {
+        gridWidth: number;
+        gridHeight: number;
+        altGridWidth: number;
+        altGridHeight: number;
+    };
+    screenForceFullDisplay: boolean;
+    mainGridStream: never[];
+    otherGridStreams: never[][];
+    audioOnlyStreams: never[];
+    videoInputs: never[];
+    audioInputs: never[];
+    meetingProgressTime: string;
+    meetingElapsedTime: number;
+    ref_participants: never[];
+    messages: never[];
+    startDirectMessage: boolean;
+    directMessageDetails: null;
+    showMessagesBadge: boolean;
+    audioSetting: string;
+    videoSetting: string;
+    screenshareSetting: string;
+    chatSetting: string;
+    displayOption: string;
+    autoWave: boolean;
+    forceFullDisplay: boolean;
+    prevForceFullDisplay: boolean;
+    prevMeetingDisplayType: string;
+    waitingRoomFilter: string;
+    waitingRoomList: never[];
+    waitingRoomCounter: number;
+    filteredWaitingRoomList: never[];
+    requestFilter: string;
+    requestList: never[];
+    requestCounter: number;
+    filteredRequestList: never[];
+    totalReqWait: number;
+    alertVisible: boolean;
+    alertMessage: string;
+    alertType: string;
+    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: string;
+    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: {
+        mainHeight: number;
+        otherHeight: number;
+        mainWidth: number;
+        otherWidth: number;
+    };
+    hasCameraPermission: boolean;
+    hasAudioPermission: boolean;
+    transportCreated: boolean;
+    localTransportCreated: boolean;
+    transportCreatedVideo: boolean;
+    transportCreatedAudio: boolean;
+    transportCreatedScreen: boolean;
+    producerTransport: null;
+    localProducerTransport: null;
+    videoProducer: null;
+    localVideoProducer: null;
+    params: {};
+    videoParams: {};
+    audioParams: {};
+    audioProducer: null;
+    localAudioProducer: null;
+    consumerTransports: never[];
+    consumingTransports: never[];
+    polls: never[];
+    poll: null;
+    isPollModalVisible: boolean;
+    customImage: string;
+    selectedImage: string;
+    segmentVideo: null;
+    selfieSegmentation: null;
+    pauseSegmentation: boolean;
+    processedStream: null;
+    keepBackground: boolean;
+    backgroundHasChanged: boolean;
+    virtualStream: null;
+    mainCanvas: null;
+    prevKeepBackground: boolean;
+    appliedBackground: boolean;
+    isBackgroundModalVisible: boolean;
+    autoClickBackground: boolean;
+    breakoutRooms: never[];
+    currentRoomIndex: number;
+    canStartBreakout: boolean;
+    breakOutRoomStarted: boolean;
+    breakOutRoomEnded: boolean;
+    hostNewRoom: number;
+    limitedBreakRoom: never[];
+    mainRoomsLength: number;
+    memberRoom: number;
+    isBreakoutRoomsModalVisible: boolean;
+    whiteboardUsers: never[];
+    currentWhiteboardIndex: number;
+    canStartWhiteboard: boolean;
+    whiteboardStarted: boolean;
+    whiteboardEnded: boolean;
+    whiteboardLimit: number;
+    isWhiteboardModalVisible: boolean;
+    isConfigureWhiteboardModalVisible: boolean;
+    shapes: never[];
+    useImageBackground: boolean;
+    redoStack: never[];
+    undoStack: never[];
+    canvasStream: null;
+    canvasWhiteboard: null;
+    canvasScreenboard: null;
+    processedScreenStream: null;
+    annotateScreenStream: boolean;
+    mainScreenCanvas: null;
+    isScreenboardModalVisible: boolean;
+    micActive: boolean;
+    videoActive: boolean;
+    screenShareActive: boolean;
+    endCallActive: boolean;
+    participantsActive: boolean;
+    menuActive: boolean;
+    commentsActive: boolean;
+};
+export type InitialValuesStateType = typeof initialValuesState;
+//# sourceMappingURL=initialValuesState.d.ts.map

package/dist/methods/utils/initialValuesState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialValuesState.d.ts","sourceRoot":"","sources":["../../../src/methods/utils/initialValuesState.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkZ9B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,OAAO,kBAAkB,CAAC"}

package/dist/methods/utils/joinRoomOnMediaSFU.d.ts

@@ -0,0 +1,56 @@
+import { CreateMediaSFURoomOptions, JoinMediaSFURoomOptions } from '../../types/types';
+export type CreateJoinRoomType = (options: {
+    payload: CreateMediaSFURoomOptions | JoinMediaSFURoomOptions;
+    apiUserName: string;
+    apiKey: string;
+    localLink?: 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 type JoinRoomOnMediaSFUType = (options: {
+    payload: JoinMediaSFURoomOptions;
+    apiUserName: string;
+    apiKey: string;
+    localLink?: string;
+}) => Promise<{
+    data: CreateJoinRoomResponse | CreateJoinRoomError | null;
+    success: boolean;
+}>;
+/**
+ * Calls the MediaSFU join-room API and returns a normalized success/error result.
+ *
+ * This helper supports both cloud and self-hosted deployments through the
+ * optional `localLink` override.
+ *
+ * @param options API request options including credentials and join payload.
+ * @returns A result object containing either parsed response data or an error payload.
+ *
+ * @example
+ * ```typescript
+ * const result = await joinRoomOnMediaSFU({
+ *   payload: { action: 'join', meetingID: 'room123', userName: 'Ada' },
+ *   apiUserName: 'sampleuser',
+ *   apiKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+ * });
+ *
+ * if (result.success) {
+ *   console.log(result.data?.roomName);
+ * }
+ * ```
+ */
+export declare const joinRoomOnMediaSFU: CreateJoinRoomType;
+//# sourceMappingURL=joinRoomOnMediaSFU.d.ts.map

package/dist/methods/utils/joinRoomOnMediaSFU.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"joinRoomOnMediaSFU.d.ts","sourceRoot":"","sources":["../../../src/methods/utils/joinRoomOnMediaSFU.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAG5F,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE;IACzC,OAAO,EAAE,yBAAyB,GAAG,uBAAuB,CAAC;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,KAAK,OAAO,CAAC;IACZ,IAAI,EAAE,sBAAsB,GAAG,mBAAmB,GAAG,IAAI,CAAC;IAC1D,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC,CAAC;AAEH,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,EAAE;IAC7C,OAAO,EAAE,uBAAuB,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,KAAK,OAAO,CAAC;IACZ,IAAI,EAAE,sBAAsB,GAAG,mBAAmB,GAAG,IAAI,CAAC;IAC1D,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC,CAAC;AAmBH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,kBAAkB,EAAE,kBA8ChC,CAAC"}

package/dist/methods/utils/liveSubtitle.d.ts

@@ -0,0 +1,36 @@
+export interface TranslationTranscriptData {
+    speakerId: string;
+    speakerName?: string;
+    language: string;
+    originalText: string;
+    translatedText?: string;
+    timestamp?: number;
+    targetLanguage?: string;
+    isFinal?: boolean;
+    [key: string]: any;
+}
+export interface LiveSubtitle {
+    text: string;
+    language: string;
+    timestamp: number;
+    expiresAt: number;
+    speakerId: string;
+    speakerName?: string;
+}
+export interface UpdateLiveSubtitlesOptions {
+    currentSubtitles: Map<string, LiveSubtitle>;
+    transcript: TranslationTranscriptData;
+    now?: number;
+}
+export declare const createLiveSubtitle: (params: {
+    text: string;
+    language: string;
+    speakerId: string;
+    speakerName?: string;
+    timestamp?: number;
+}) => LiveSubtitle;
+export declare const isSubtitleExpired: (subtitle: LiveSubtitle, now?: number) => boolean;
+export declare const pruneExpiredSubtitles: (subtitles: Map<string, LiveSubtitle>, now?: number) => Map<string, LiveSubtitle>;
+export declare const updateLiveSubtitlesFromTranscript: ({ currentSubtitles, transcript, now, }: UpdateLiveSubtitlesOptions) => Map<string, LiveSubtitle>;
+export declare const getSubtitleForSpeaker: (subtitles: Map<string, LiveSubtitle>, speakerId: string, speakerName?: string, now?: number) => LiveSubtitle | null;
+//# sourceMappingURL=liveSubtitle.d.ts.map

package/dist/methods/utils/liveSubtitle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveSubtitle.d.ts","sourceRoot":"","sources":["../../../src/methods/utils/liveSubtitle.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,0BAA0B;IACzC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC5C,UAAU,EAAE,yBAAyB,CAAC;IACtC,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,eAAO,MAAM,kBAAkB,GAAI,QAAQ;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,KAAG,YAYH,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,UAAU,YAAY,EAAE,YAAgB,KAAG,OAE5E,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,WAAW,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EACpC,YAAgB,KACf,GAAG,CAAC,MAAM,EAAE,YAAY,CAU1B,CAAC;AAEF,eAAO,MAAM,iCAAiC,GAAI,wCAI/C,0BAA0B,KAAG,GAAG,CAAC,MAAM,EAAE,YAAY,CAiBvD,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,WAAW,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EACpC,WAAW,MAAM,EACjB,cAAc,MAAM,EACpB,YAAgB,KACf,YAAY,GAAG,IAYjB,CAAC"}

package/dist/methods/utils/meetingTimeRemaining.d.ts

@@ -0,0 +1,15 @@
+import { EventType, ShowAlert } from '../../types/types';
+export interface MeetingTimeRemainingOptions {
+    timeRemaining: number;
+    showAlert?: ShowAlert;
+    eventType: EventType;
+}
+export type MeetingTimeRemainingType = (options: MeetingTimeRemainingOptions) => Promise<void>;
+/**
+ * Shows a meeting countdown alert for non-chat event types.
+ *
+ * @param options Function options including the remaining time in milliseconds.
+ * @returns A promise that resolves after the alert has been evaluated and dispatched.
+ */
+export declare const meetingTimeRemaining: ({ timeRemaining, showAlert, eventType, }: MeetingTimeRemainingOptions) => Promise<void>;
+//# sourceMappingURL=meetingTimeRemaining.d.ts.map

package/dist/methods/utils/meetingTimeRemaining.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meetingTimeRemaining.d.ts","sourceRoot":"","sources":["../../../src/methods/utils/meetingTimeRemaining.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9D,MAAM,WAAW,2BAA2B;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,SAAS,EAAE,SAAS,CAAC;CACtB;AAED,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,EAAE,2BAA2B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAE/F;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAU,0CAIxC,2BAA2B,KAAG,OAAO,CAAC,IAAI,CAY5C,CAAC"}

package/dist/methods/utils/meetingTimer/startMeetingProgressTimer.d.ts

@@ -0,0 +1,35 @@
+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;
+/**
+ * Starts a one-second meeting progress timer and updates a formatted elapsed-time string.
+ *
+ * The timer automatically stops when the current runtime parameters indicate the
+ * meeting is no longer validated or no room is active.
+ *
+ * @param options Timer start options.
+ *
+ * @example
+ * ```typescript
+ * startMeetingProgressTimer({
+ *   startTime: Math.floor(Date.now() / 1000),
+ *   parameters: {
+ *     validated: true,
+ *     roomName: 'room123',
+ *     updateMeetingProgressTime: setMeetingTime,
+ *     getUpdatedAllParams: () => currentParams,
+ *   },
+ * });
+ * ```
+ */
+export declare function startMeetingProgressTimer({ startTime, parameters, }: StartMeetingProgressTimerOptions): void;
+//# sourceMappingURL=startMeetingProgressTimer.d.ts.map

package/dist/methods/utils/meetingTimer/startMeetingProgressTimer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startMeetingProgressTimer.d.ts","sourceRoot":"","sources":["../../../../src/methods/utils/meetingTimer/startMeetingProgressTimer.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mCAAmC;IAClD,yBAAyB,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;IAC/D,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,gCAAgC;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,mCAAmC,CAAC;CACjD;AAED,MAAM,MAAM,6BAA6B,GAAG,CAAC,OAAO,EAAE,gCAAgC,KAAK,IAAI,CAAC;AAEhG;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,SAAS,EACT,UAAU,GACX,EAAE,gCAAgC,GAAG,IAAI,CAgCzC"}

package/dist/methods/utils/producer/aParams.d.ts

@@ -0,0 +1,3 @@
+import { AParamsType } from '../../../types/types';
+export declare const aParams: AParamsType;
+//# sourceMappingURL=aParams.d.ts.map

package/dist/methods/utils/producer/aParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aParams.d.ts","sourceRoot":"","sources":["../../../../src/methods/utils/producer/aParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,eAAO,MAAM,OAAO,EAAE,WAOrB,CAAC"}

package/dist/methods/utils/producer/hParams.d.ts

@@ -0,0 +1,3 @@
+import { HParamsType } from '../../../types/types';
+export declare const hParams: HParamsType;
+//# sourceMappingURL=hParams.d.ts.map

package/dist/methods/utils/producer/hParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hParams.d.ts","sourceRoot":"","sources":["../../../../src/methods/utils/producer/hParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,eAAO,MAAM,OAAO,EAAE,WAuBrB,CAAC"}

package/dist/methods/utils/producer/screenParams.d.ts

@@ -0,0 +1,3 @@
+import { ScreenParamsType } from '../../../types/types';
+export declare const screenParams: ScreenParamsType;
+//# sourceMappingURL=screenParams.d.ts.map

package/dist/methods/utils/producer/screenParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenParams.d.ts","sourceRoot":"","sources":["../../../../src/methods/utils/producer/screenParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,eAAO,MAAM,YAAY,EAAE,gBAU1B,CAAC"}

package/dist/methods/utils/producer/vParams.d.ts

@@ -0,0 +1,3 @@
+import { VParamsType } from '../../../types/types';
+export declare const vParams: VParamsType;
+//# sourceMappingURL=vParams.d.ts.map

package/dist/methods/utils/producer/vParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vParams.d.ts","sourceRoot":"","sources":["../../../../src/methods/utils/producer/vParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,eAAO,MAAM,OAAO,EAAE,WAuBrB,CAAC"}