hamrahi-player-library 1.0.0

package/dist/videoPlayerLibrary/helpers/interfaces/interfaces.d.ts

@@ -0,0 +1,252 @@
+import { Method } from 'axios';
+import { FeatureExcept, SettingSections } from './enums';
+import { MouseEvent } from 'react';
+export interface IParams {
+    type?: string;
+    id?: string;
+    bannerAlt?: string;
+    fullscreen?: string;
+    autoplay?: string;
+    banner?: string;
+    uuid?: string;
+    provider?: string;
+    onFinished?: Function;
+    onPlay?: Function;
+    onPause?: Function;
+    playStatus?: boolean;
+    onClickMiniPlayerIcon?: Function;
+    subtitles?: ISubtitle[];
+    currentTime?: number;
+    daaniHashCode?: string;
+    featureExec?: FeatureExcept[];
+    primaryColor?: string;
+}
+export interface ISubtitle {
+    id?: number;
+    title: string;
+    lang: string;
+    url: string;
+}
+export interface IVideoElementSizeInfo {
+    bottom: number;
+    top: number;
+    left: number;
+    right: number;
+    width: number;
+    height: number;
+}
+export interface IVideoDataSlice {
+    details: IDetails;
+    params: IParams;
+    markers: IMarker[];
+    liveId?: number;
+    isFetchDetails: boolean;
+    isValidAddress: boolean;
+    videoTimelines: number[];
+    isReady: boolean;
+    videoElementSizeInfo: IVideoElementSizeInfo;
+    subtitles: TextTrack[];
+    selectedSubtitle?: TextTrack;
+    subtitleText?: string;
+}
+export interface IControllerSlice {
+    play: boolean;
+    isAutoPlay: boolean;
+    duration: number;
+    currentTime: number;
+    qualityLevels: number[];
+    manualQuality?: number;
+    autoQuality?: number;
+    activeElements: boolean;
+    isLoading: boolean;
+    isFullScreen: boolean;
+    bufferedTimeWidth: number;
+    firstPlay: boolean;
+    activePointerProgressBar: boolean;
+    delayTurnOffControlbar: boolean;
+    canPlayVideo: boolean;
+    lock: boolean;
+    isEnded: boolean;
+    tooltipTime: number;
+}
+export interface IDetails {
+    stream_link: string;
+    type: string;
+    banner: string;
+    id?: number;
+    title?: string;
+    vtt?: string;
+    vtt_mobile?: string;
+    user_id: number | null;
+    content_id?: number;
+    content_type: null | number;
+    duration: number;
+    subtitles?: ISubtitle[];
+}
+export interface IUserSlice {
+    settings: IUserSettings;
+    videoSettings: IVideoSettings;
+}
+export interface IUserSettings {
+    quality: number;
+    volume: number;
+    brightness: number;
+    speed: number;
+}
+export interface IViewedVideo {
+    video_id: number;
+    video_type: 2;
+    time: number;
+}
+export interface IQualityLevel {
+    setSection?: (section: SettingSections.main) => void;
+    showQualityLevelsIcon?: boolean;
+}
+export interface ISpeed {
+    setSection?: (section: SettingSections.main) => void;
+    showSpeedIcon?: boolean;
+}
+export interface IVideoSettings {
+    time: number;
+}
+export interface IApiCaller {
+    url: string;
+    method?: Method;
+    data?: any;
+    headers?: any;
+    retryCount?: number;
+    maxRetryCount?: number;
+    delayDuration?: number;
+    errorMessage?: string;
+    retryPolicy?: IRetryPolicy[];
+    errorCallback?: (status: number, message: string) => void;
+    timeoutCount?: number;
+}
+export interface IRetryPolicy {
+    codeAbove: number | null;
+    codeBelow: number | null;
+    excludeCodes: number[];
+    includeCodes: number[];
+    delay: number;
+    count: number;
+}
+export interface IAxiosConfig {
+    url: string;
+    method: Method;
+    headers: {
+        "Content-Type": string;
+        "ACCEPT-LANGUAGE": string;
+        Authorization?: string;
+    };
+    data?: any;
+    params?: any;
+    timeout?: number;
+}
+export interface IEnvironment {
+    reduxDevTool: boolean;
+}
+export interface IDetailsConfig {
+    url: string;
+    maxRetryCount: number;
+    headers: any;
+    retryPolicy: IRetryPolicy[];
+    errorCallback?: (status: number, message: string) => void;
+}
+export interface IPopoversSlice {
+    settingPopover: boolean;
+    speedPopover: boolean;
+    qualityLevelsPopover: boolean;
+    markersListPopover: boolean;
+}
+export interface IPopoverProps {
+    children: JSX.Element;
+    type: "modal" | "popover";
+    onClose: any;
+    classNames?: string;
+    parentClassNames?: string;
+    styles?: any;
+    status?: boolean;
+    isBlurBackground?: boolean;
+    isFullHeight?: boolean;
+    isFullScreen?: boolean;
+    isHeader?: boolean;
+    headerTitle?: string;
+    customHeader?: any;
+    headerClassName?: string;
+    isHasCatchUpLineOnTop?: boolean;
+    animation?: string;
+    scrollbar?: boolean;
+    isFocusOnInput?: boolean;
+    showCloseIcon?: boolean;
+    pinContent?: any;
+}
+export interface IBackwardForwardProps {
+    type: string;
+    isRightDoubleTouched?: boolean;
+    isLeftDoubleTouched?: boolean;
+    setIsRightDoubleTouched?: (value: boolean) => void;
+    setIsLeftDoubleTouched?: (value: boolean) => void;
+}
+export interface IControllbarTooltipProps {
+    title: string;
+    className?: string;
+}
+export interface IMuteProps {
+    className?: string;
+    onClick?: (event: any) => void;
+}
+export interface IUnMuteProps {
+    className?: string;
+    onClick?: (event: any) => void;
+}
+export interface IToggleProps {
+    enabled: boolean;
+    setEnabled: any;
+}
+export interface ISpeedProps {
+    className?: string;
+    onClick?: (event: MouseEvent<SVGSVGElement>) => void;
+    onMouseOver?: (event: MouseEvent<SVGSVGElement>) => void;
+    onMouseLeave?: (event: MouseEvent<SVGSVGElement>) => void;
+}
+export interface IMiniPlayerParams {
+    id: string;
+    type: string;
+    currentTime?: number;
+    autoPlay?: boolean;
+    onClose: Function;
+    banner?: string;
+}
+export interface IMiniPlayerSlice {
+    params: IMiniPlayerParams;
+    details: Partial<IDetails>;
+    play: boolean;
+}
+export interface IMarker {
+    banner: string;
+    id: number;
+    live_id: number;
+    sticker: string;
+    time: number;
+    title: string;
+    video_type: 1;
+    vod_id: null | number;
+    description: string;
+    isPersonal: null | number;
+}
+export interface IEmojiProps {
+    name: string | undefined;
+    className?: string;
+    dataMarker?: string;
+}
+export interface IMarkerListIconProps {
+    className?: string;
+    onClick?: () => void;
+    onDoubleClick?: (event: any) => void;
+    onMouseOver?: () => void;
+    onMouseLeave?: () => void;
+}
+export interface ICloseIconProps {
+    className?: string;
+    onClick?: () => void;
+}

package/dist/videoPlayerLibrary/helpers/logs/fluentdLogger.d.ts

@@ -0,0 +1 @@
+export declare const sendFluentLog: (data: any) => void;

package/dist/videoPlayerLibrary/helpers/logs/logs.d.ts

@@ -0,0 +1,163 @@
+export declare const speedChangeLog: (selectedSpeed: Number) => {
+    category: string;
+    previousSelectedSpeed: number;
+    selectedSpeed: Number;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+    provider: string | undefined;
+};
+export declare const qualityChangeRequestLog: (selectedQuality: String) => {
+    category: string;
+    currentPlayingQuality: string;
+    previousSelectedQuality: string;
+    selectedQuality: String;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+    provider: string | undefined;
+};
+export declare const catchUpLoadingLog: (duration: number) => {
+    category: string;
+    previousVideoTime: number;
+    currentVideoTime: number;
+    duration: number;
+    quality: string;
+    isAutoQuality: any;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+    provider: string | undefined;
+};
+export declare const backwardForwardLog: (type: string) => {
+    category: string;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+    provider: string | undefined;
+};
+export declare const fullscreenLog: (category: string) => {
+    category: string;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+};
+export declare const brightnessLog: (source: number, target: number) => {
+    category: string;
+    source: number;
+    target: number;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+};
+export declare const volumeLog: (source: number, target: number) => {
+    category: string;
+    source: number;
+    target: number;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+};
+export declare const lockLog: (category: string) => {
+    category: string;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+};
+export declare const ExceptionsLog: (type: string, message: string, statusCode?: number, url?: string) => {
+    category: string;
+    type: string;
+    message: string;
+    statusCode: number | undefined;
+    url: string | undefined;
+};
+export declare const videoTimelineLog: (start: number, end: number) => {
+    category: string;
+    video_id: number;
+    video_type: string | undefined;
+    start: number;
+    end: number;
+    watchedDuration: number;
+    video_duration: number;
+    clientUUID: string;
+    user_id: number | null;
+    content_type: number | null;
+    content_id: number | undefined;
+};
+export declare const autoQualityChangeLog: (sourceQuality: String, targetQuality: String, diffQuality: number) => {
+    category: string;
+    sourceQuality: String;
+    targetQuality: String;
+    diffQuality: number;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+    provider: string | undefined;
+};
+export declare const pingpongLog: (startTimer: number, qualityHistory: number[]) => {
+    category: string;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+    PingPongDuration: number;
+    PingPongSourceQuality: string;
+    PingPongTargetQuality: string;
+    provider: string | undefined;
+};
+export declare const pausePlayLog: (isPlay: boolean) => {
+    category: string;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+    provider: string | undefined;
+};
+export declare const initLog: (loadingTime: number, waitingTime: number, bannerLoadingTime: number, firstChunkPlayingTime: number, timerRef: any) => {
+    category: string;
+    id: number;
+    type: string | undefined;
+    origin: string;
+    src: string | undefined;
+    loading: number;
+    bannerLoading: number;
+    waiting: number;
+    firstChunkPlaying: number;
+    totalTime: number;
+    provider: string | undefined;
+    performance: any;
+    userAgent: string;
+};
+export declare const loadingLog: (waitingDuration: number, qualityLevel: number, timerRef: any, loadingCounterRef: any, videoEntranceTime: number) => {
+    category: string;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+    duration: number;
+    quality: string;
+    isAutoQuality: any;
+    previousLoaderDiff: number;
+    counter: any;
+    loadingPercentile: number;
+    videoTime: number;
+    videoEntranceTime: number;
+    speed: number;
+    provider: string | undefined;
+};
+export declare const subtitleLog: (language: string) => {
+    category: string;
+    language: string;
+    id: number;
+    type: string | undefined;
+    src: string | undefined;
+};
+export declare const eventMarkerClickLog: (markerId: Number, markerTime: Number, markerTitle: String, markerDescription: String, markerSticker: String) => {
+    category: string;
+    video_id: number;
+    markerId: Number;
+    markerTime: Number;
+    markerTitle: String;
+    markerDescription: String;
+    markerSticker: String;
+    type: string | undefined;
+    src: string | undefined;
+    provider: string | undefined;
+};

package/dist/videoPlayerLibrary/helpers/redux/actions/controller.actions.d.ts

@@ -0,0 +1,12 @@
+export declare const handlePlayPause: (event: any) => void;
+export declare const handlePlayPauseAfterChangeVideo: () => void;
+export declare const handlePlayerPauseMiniPlayer: (event: any) => void;
+export declare const handlePlayPauseInDOM: (type: boolean) => boolean;
+export declare const handleChangeSoundVolume: (volume: number) => void;
+export declare const handleBackwardForward: (type: string, forwardBackwardCount?: number, event?: any) => void;
+export declare const handleFullScreen: () => void;
+export declare const handleLockOrientation: () => void;
+export declare const handleLock: (type: string) => void;
+export declare const handleVideoTimeline: (currentTimeValue: number, movedTimeValue?: number) => void;
+export declare const handleVideoElementSizeInfo: () => void;
+export declare const handleDoubleClick: (event: any) => void;

package/dist/videoPlayerLibrary/helpers/redux/actions/playerCore.actions.d.ts

@@ -0,0 +1,116 @@
+export declare const handleVideoError: (event: any) => void;
+export declare const handleAutoFullScreen: () => void;
+export declare const appendQueryParamsToChunksIOS: () => void;
+export declare const handleBufferedTime: (event: any, intervalRef: any) => void;
+export declare const handleHlsConfig: () => {
+    xhrSetup: (xhr: any, url: any) => void;
+    startLevel: number;
+    debug: boolean;
+    enableWorker: boolean;
+    abrBandWidthUpFactor: number;
+    abrBandWidthFactor: number;
+    backBufferLength: number;
+    maxBufferLength: number;
+    maxMaxBufferLength: number;
+    manifestLoadPolicy: {
+        default: {
+            maxTimeToFirstByteMs: number;
+            maxLoadTimeMs: number;
+            timeoutRetry: {
+                maxNumRetry: number;
+                retryDelayMs: number;
+                maxRetryDelayMs: number;
+            };
+            errorRetry: {
+                maxNumRetry: number;
+                retryDelayMs: number;
+                maxRetryDelayMs: number;
+            };
+        };
+    };
+    fragLoadPolicy: {
+        default: {
+            maxTimeToFirstByteMs: number;
+            maxLoadTimeMs: number;
+            timeoutRetry: {
+                maxNumRetry: number;
+                retryDelayMs: number;
+                maxRetryDelayMs: number;
+            };
+            errorRetry: {
+                maxNumRetry: number;
+                retryDelayMs: number;
+                maxRetryDelayMs: number;
+            };
+        };
+    };
+    playlistLoadPolicy: {
+        default: {
+            maxTimeToFirstByteMs: number;
+            maxLoadTimeMs: number;
+            timeoutRetry: {
+                maxNumRetry: number;
+                retryDelayMs: number;
+                maxRetryDelayMs: number;
+            };
+            errorRetry: {
+                maxNumRetry: number;
+                retryDelayMs: number;
+                maxRetryDelayMs: number;
+            };
+        };
+    };
+};
+export declare const handleMiniPlayerHlsConfig: () => {
+    xhrSetup: (xhr: any, url: any) => void;
+    startLevel: number;
+    debug: boolean;
+    maxMaxBufferLength: number;
+    playlistLoadPolicy: {
+        default: {
+            maxTimeToFirstByteMs: number;
+            maxLoadTimeMs: number;
+            timeoutRetry: {
+                maxNumRetry: number;
+                retryDelayMs: number;
+                maxRetryDelayMs: number;
+            };
+            errorRetry: {
+                maxNumRetry: number;
+                retryDelayMs: number;
+                maxRetryDelayMs: number;
+            };
+        };
+    };
+};
+export declare const handleManifestParsed: (hls: any) => void;
+export declare const handleMediaAttached: (Hls: any, hls: any) => void;
+export declare const handleLevels: (hls: any, data: any, setQualityLevel: any) => void;
+export declare const handleFragBuffered: (hls: any) => void;
+export declare const handleFragChanged: (hls: any, data: any, setQualityLevel: any) => void;
+export declare const handleFragParsed: (hls: any, data: any, setQualityLevel: any) => void;
+export declare const handleHlsErrors: (data: any) => {
+    type: string;
+    message: any;
+} | undefined;
+export declare const handleVideoWaiting: (event: any, waitingTimerRef: any) => void;
+export declare const handleVideoSeeking: (event: any, waitingTimerRef: any) => void;
+export declare const handleVideoPlay: (event: any, timerRef: any) => void;
+export declare const handleVideoPlaying: (loadingCounterRef: any, loadingDurationRef: any, initialWaitingDurationRef: any, bannerLoadingDurationRef: any, timerRef: any, waitingDurationRef: any, waitingTimerRef: any, videoEntranceTimeRef: any) => void;
+export declare const handleVideoPause: (event: any) => void;
+export declare const handleVideoTimeUpdate: (event: any) => void;
+export declare const handleVideoCanPlay: (event: any) => void;
+export declare const handleVideoEnded: (event: any) => void;
+export declare const handleIosVideoPlay: (event: any, timerRef: any) => void;
+export declare const handleIosVideoPlaying: () => void;
+export declare const handleIosVideoTimeUpdate: (event: any) => void;
+export declare const handleIosVideoEnded: () => void;
+export declare const handleStaticVideoPause: (event: any) => void;
+export declare const handleStaticVideoPlay: (event: any, timerRef: any) => void;
+export declare const handleStaticVideoPlaying: (loadingDurationRef: any, initialWaitingDurationRef: any, timerRef: any) => void;
+export declare const handleStaticVideoTimeUpdate: (event: any) => void;
+export declare const handleStaticVideoCanPlay: (event: any) => void;
+export declare const handleStaticVideoLoadedData: (event: any, intervalRef: any) => void;
+export declare const handleStaticVideoEnded: (event: any) => void;
+export declare const handleMiniPlayerMediaAttached: (hls: any) => Promise<void>;
+export declare const handleVideoVisibilityChange: () => void;

package/dist/videoPlayerLibrary/helpers/redux/actions/progressbar.actions.d.ts

@@ -0,0 +1,15 @@
+export declare const getPointerTime: (event: any) => number | undefined;
+export declare const getPointerPosition: (event: any) => number | undefined;
+export declare const getMarkerPosition: (markerTime: number) => number;
+export declare const hideProgressTooltip: (progressTooltip: any) => void;
+export declare const showProgressTooltip: (event: any, progressTooltip: any, progressBarTooltip: any) => void;
+export declare const handleTimeTooltip: (event: any, isTimer?: boolean) => void;
+export declare const handleProgressTime: (event: any) => void;
+export declare const handlePointerDown: (event: any, timeoutIds: any, setIsPointerDown: (value: boolean) => void) => void;
+export declare const handlePointerMove: (event: any) => void;
+export declare const handlePointerUp: (event: any, setTimeoutIds: (timeoutIds: any[]) => void, timeoutIds: any, setIsPointerDown: (value: boolean) => void) => void;
+export declare const handleCatchUpLoadingLog: () => void;
+export declare const handleMouseMove: (event: any) => void;
+export declare const handleMouseOut: () => void;
+export declare const fetchFile: (url: string, setVttPool: any) => void;
+export declare const getStyleForTime: (time: number, vttPool: any, cache: any) => any;

package/dist/videoPlayerLibrary/helpers/redux/actions/user.actions.d.ts

@@ -0,0 +1,2 @@
+export declare const handleContinuousPlayback: () => void;
+export declare const handleApplyContinuousPlayback: () => void;

package/dist/videoPlayerLibrary/helpers/redux/actions/videoData.actions.d.ts

@@ -0,0 +1,7 @@
+export declare const getVodDetails: (videoId?: string) => Promise<{
+    payload: import('../../interfaces/interfaces').IDetails;
+    type: "user/setDetailsMiniPlayer";
+} | undefined>;
+export declare const detailSetter: (data: any) => void;
+export declare const handleSubtitle: () => void;
+export declare const getAllGeneralMarker: (url: string) => Promise<any>;

package/dist/videoPlayerLibrary/helpers/redux/hooks.d.ts

@@ -0,0 +1,4 @@
+import { RootState } from './store';
+import { TypedUseSelectorHook } from 'react-redux';
+export declare const useAppDispatch: any;
+export declare const useAppSelector: TypedUseSelectorHook<RootState>;

package/dist/videoPlayerLibrary/helpers/redux/slices/controllerSlice.d.ts

@@ -0,0 +1,26 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { IControllerSlice } from '../../interfaces/interfaces';
+export declare const controllerSlice: import('@reduxjs/toolkit').Slice<IControllerSlice, {
+    setPlay: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<boolean>) => void;
+    setIsAutoPlay: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<boolean>) => void;
+    setDuration: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<number>) => void;
+    setCurrentTime: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<number>) => void;
+    setManualQuality: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<number | undefined>) => void;
+    setAutoQuality: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<number | undefined>) => void;
+    setQualityLevels: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<any[]>) => void;
+    setActiveElements: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<boolean>) => void;
+    setIsLoading: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<boolean>) => void;
+    setIsFullScreen: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<boolean>) => void;
+    setBufferedTimeWidth: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<number>) => void;
+    setFirstPlay: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<boolean>) => void;
+    setActivePointerProgressBar: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<boolean>) => void;
+    setDelayTurnOffControlbar: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<boolean>) => void;
+    setCanPlayVideo: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<boolean>) => void;
+    setLock: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<boolean>) => void;
+    setIsEnded: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<boolean>) => void;
+    setTooltipTime: (state: import('immer').WritableDraft<IControllerSlice>, action: PayloadAction<number>) => void;
+    setClearControllerSlice: () => IControllerSlice;
+}, "controller", "controller", import('@reduxjs/toolkit').SliceSelectors<IControllerSlice>>;
+export declare const setPlay: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "controller/setPlay">, setIsAutoPlay: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "controller/setIsAutoPlay">, setDuration: import('@reduxjs/toolkit').ActionCreatorWithPayload<number, "controller/setDuration">, setCurrentTime: import('@reduxjs/toolkit').ActionCreatorWithPayload<number, "controller/setCurrentTime">, setQualityLevels: import('@reduxjs/toolkit').ActionCreatorWithPayload<any[], "controller/setQualityLevels">, setAutoQuality: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<number | undefined, "controller/setAutoQuality">, setActiveElements: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "controller/setActiveElements">, setIsLoading: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "controller/setIsLoading">, setIsFullScreen: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "controller/setIsFullScreen">, setBufferedTimeWidth: import('@reduxjs/toolkit').ActionCreatorWithPayload<number, "controller/setBufferedTimeWidth">, setFirstPlay: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "controller/setFirstPlay">, setActivePointerProgressBar: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "controller/setActivePointerProgressBar">, setDelayTurnOffControlbar: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "controller/setDelayTurnOffControlbar">, setManualQuality: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<number | undefined, "controller/setManualQuality">, setCanPlayVideo: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "controller/setCanPlayVideo">, setLock: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "controller/setLock">, setIsEnded: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "controller/setIsEnded">, setTooltipTime: import('@reduxjs/toolkit').ActionCreatorWithPayload<number, "controller/setTooltipTime">, setClearControllerSlice: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"controller/setClearControllerSlice">;
+declare const _default: import('redux').Reducer<IControllerSlice>;
+export default _default;

package/dist/videoPlayerLibrary/helpers/redux/slices/miniPlayerSlice.d.ts

@@ -0,0 +1,11 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { IDetails, IMiniPlayerParams, IMiniPlayerSlice } from '../../interfaces/interfaces';
+export declare const userSlice: import('@reduxjs/toolkit').Slice<IMiniPlayerSlice, {
+    setMiniPlayerInfo: (state: import('immer').WritableDraft<IMiniPlayerSlice>, action: PayloadAction<IMiniPlayerParams>) => void;
+    setDetailsMiniPlayer: (state: import('immer').WritableDraft<IMiniPlayerSlice>, action: PayloadAction<IDetails>) => void;
+    setPlayMiniPlayer: (state: import('immer').WritableDraft<IMiniPlayerSlice>, action: PayloadAction<boolean>) => void;
+    setClearMiniPlayerSlice: () => IMiniPlayerSlice;
+}, "user", "user", import('@reduxjs/toolkit').SliceSelectors<IMiniPlayerSlice>>;
+export declare const setMiniPlayerInfo: import('@reduxjs/toolkit').ActionCreatorWithPayload<IMiniPlayerParams, "user/setMiniPlayerInfo">, setDetailsMiniPlayer: import('@reduxjs/toolkit').ActionCreatorWithPayload<IDetails, "user/setDetailsMiniPlayer">, setPlayMiniPlayer: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "user/setPlayMiniPlayer">, setClearMiniPlayerSlice: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"user/setClearMiniPlayerSlice">;
+declare const _default: import('redux').Reducer<IMiniPlayerSlice>;
+export default _default;

package/dist/videoPlayerLibrary/helpers/redux/slices/popoversSlice.d.ts

@@ -0,0 +1,12 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { IPopoversSlice } from '../../interfaces/interfaces';
+export declare const popoversSlice: import('@reduxjs/toolkit').Slice<IPopoversSlice, {
+    setSettingPopover: (state: import('immer').WritableDraft<IPopoversSlice>, action: PayloadAction<boolean>) => void;
+    setSpeedPopover: (state: import('immer').WritableDraft<IPopoversSlice>, action: PayloadAction<boolean>) => void;
+    setQualityLevelsPopover: (state: import('immer').WritableDraft<IPopoversSlice>, action: PayloadAction<boolean>) => void;
+    setMarkersListPopover: (state: import('immer').WritableDraft<IPopoversSlice>, action: PayloadAction<boolean>) => void;
+    setClearPopoversSlice: (state: import('immer').WritableDraft<IPopoversSlice>) => void;
+}, "popover", "popover", import('@reduxjs/toolkit').SliceSelectors<IPopoversSlice>>;
+export declare const setSettingPopover: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "popover/setSettingPopover">, setSpeedPopover: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "popover/setSpeedPopover">, setQualityLevelsPopover: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "popover/setQualityLevelsPopover">, setMarkersListPopover: import('@reduxjs/toolkit').ActionCreatorWithPayload<boolean, "popover/setMarkersListPopover">, setClearPopoversSlice: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"popover/setClearPopoversSlice">;
+declare const _default: import('redux').Reducer<IPopoversSlice>;
+export default _default;

package/dist/videoPlayerLibrary/helpers/redux/slices/userSlice.d.ts

@@ -0,0 +1,10 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { IUserSettings, IUserSlice, IVideoSettings } from '../../interfaces/interfaces';
+export declare const userSlice: import('@reduxjs/toolkit').Slice<IUserSlice, {
+    setUserSettings: (state: import('immer').WritableDraft<IUserSlice>, action: PayloadAction<IUserSettings>) => void;
+    setVideoSettings: (state: import('immer').WritableDraft<IUserSlice>, action: PayloadAction<IVideoSettings>) => void;
+    setClearUserSlice: () => IUserSlice;
+}, "user", "user", import('@reduxjs/toolkit').SliceSelectors<IUserSlice>>;
+export declare const setUserSettings: import('@reduxjs/toolkit').ActionCreatorWithPayload<IUserSettings, "user/setUserSettings">, setVideoSettings: import('@reduxjs/toolkit').ActionCreatorWithPayload<IVideoSettings, "user/setVideoSettings">, setClearUserSlice: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"user/setClearUserSlice">;
+declare const _default: import('redux').Reducer<IUserSlice>;
+export default _default;