@evercam/ui 0.0.61 → 0.0.63-preview-create-image-comparator-comp-e2247e3c3

package/dist/index.d.ts

@@ -1,3 +1,779 @@
-export * from './src/index'
-import EvercamUI from './src/index'
-export default EvercamUI
+import EAvatar from './components/EAvatar.vue';
+import EBadge from './components/EBadge.vue';
+import EIcon from './components/EIcon.vue';
+import ESpinner from './components/ESpinner.vue';
+import ERow from './components/ERow.vue';
+import ECol from './components/ECol.vue';
+import EVideoPlayer from './components/EVideoPlayer.vue';
+import ETimeline from './components/ETimeline.vue';
+import EVideoEmbed from './components/EVideoEmbed.vue';
+import EHeatmapBar from './components/EHeatmapBar.vue';
+import EHoursHeatmap from './components/EHoursHeatmap.vue';
+import EReadMore from './components/EReadMore.vue';
+import ETruncatedDiv from './components/ETruncatedDiv.vue';
+import ECompareSeparator from './components/ECompareSeparator.vue';
+import EImagesComparator from './components/EImagesComparator.vue';
+import EExpandableMenu from './components/EExpandableMenu.vue';
+import ESvgIcon from './components/ESvgIcon.vue';
+import EToggleSwitch from './components/EToggleSwitch.vue';
+import EZoomable from './components/EZoomable.vue';
+import { VueConstructor } from "vue";
+import EGlobalSearch from './components/EGlobalSearch.vue';
+export declare const components: {
+    EAvatar: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        sizes: {
+            xs: string;
+            sm: string;
+            base: string;
+            lg: string;
+            xl: string;
+            "2xl": string;
+        };
+    }, unknown, {
+        avatarClasses: string[];
+    }, {
+        size: import('./types').Size;
+        showBadge: boolean;
+        badgeColor: import('./types').BaseColor;
+        badgeText: string;
+        badgeSize: import('./types').Size;
+        image: string;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EBadge: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        colors: {
+            error: string;
+            info: string;
+            warning: string;
+            primary: string;
+            default: string;
+            success: string;
+        };
+        sizes: {
+            dot: string;
+            xs: string;
+            sm: string;
+            base: string;
+            lg: string;
+            xl: string;
+        };
+    }, unknown, {
+        badgeClasses: string[];
+        showText: boolean;
+    }, {
+        text: string;
+        color: import('./types').BaseColor;
+        size: import('./types').Size;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EIcon: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        sizes: Record<import('./types').Size, string>;
+        iconClasses: string[];
+    }, {
+        icon: string;
+        color: string;
+        size: import('./types').Size;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ESpinner: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        sizes: any;
+        colors: any;
+    }, {
+        getNthPathStyle(index: number): {
+            animationDuration: string;
+            animationDelay: string;
+            fill: string;
+        };
+    }, {
+        computedSize: number;
+        fill: {
+            primary: string;
+            secondary: string;
+        };
+    }, {
+        dark: boolean;
+        color: boolean;
+        animationDuration: string | number;
+        size: import('./types').Size;
+        opacity: string | number;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ERow: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        justifyClasses: Record<string, boolean>;
+        rowClasses: Record<string, boolean>;
+    }, {
+        align: import('./types').FlexAlignItems;
+        alignContent: import('./types').FlexAlignContent;
+        justify: import('./types').FlexJustifyContent;
+        justifyXs: import('./types').FlexJustifyContent;
+        justifySm: import('./types').FlexJustifyContent;
+        justifyMd: import('./types').FlexJustifyContent;
+        justifyLg: import('./types').FlexJustifyContent;
+        justifyXl: import('./types').FlexJustifyContent;
+        noGutters: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ECol: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, {
+        autoClasses(prefix: string, value: string | number | boolean): string;
+        isSizePropAuto(prop: string | number | boolean | undefined, acceptUndefined?: boolean): boolean;
+        isSizePropertyNumeric(prop: string | number | boolean | undefined): boolean;
+    }, {
+        colClasses: Record<string, boolean>;
+    }, {
+        alignSelf: string;
+        cols: string | number | boolean;
+        lg: string | number | boolean;
+        md: string | number | boolean;
+        offset: string | number;
+        offsetLg: string | number;
+        offsetMd: string | number;
+        offsetSm: string | number;
+        offsetXs: string | number;
+        offsetXl: string | number;
+        sm: string | number | boolean;
+        xs: string | number | boolean;
+        xl: string | number | boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EVideoPlayer: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        playing: boolean;
+        percentagePlayed: number;
+        videoLength: string;
+        duration: number;
+        videoDuration: number;
+        currentTime: string;
+        realtime: number;
+        isScrubbing: boolean;
+        wasPaused: boolean;
+        isFullscreen: boolean;
+        isFinished: boolean;
+        isLoading: boolean;
+        isError: boolean;
+        player: import("hls.js").default;
+        playbackRetries: number;
+        preloadedSeconds: number;
+        preloadedInterval: {
+            start: string;
+            end: string;
+        };
+    }, {
+        initHls(src?: string): void;
+        onContainerClick(): void;
+        handle404Error(): void;
+        handleHlsError(_: import("hls.js").Events.ERROR, data: import("hls.js").ErrorData): void;
+        bindEvents(): void;
+        onProgress(): void;
+        unbindEvents(): void;
+        bindVideoEvent(which: string): void;
+        initializePlayer(): void;
+        destroyPlayer(): void;
+        removeFullscreenListeners(): void;
+        initializeFullscreenListeners(): void;
+        handleFullscreenChange(): void;
+        isLooped(): boolean;
+        handleScrubbingOnMouseEnd(e: MouseEvent): void;
+        handleEnded(): void;
+        handleLoading(): void;
+        play(): Promise<void>;
+        pause(): void;
+        togglePlay(): Promise<void>;
+        setPlaying(state: boolean): void;
+        seekToPercentage(percentage: number): void;
+        convertTimeToDuration(seconds: number): string;
+        closeFullscreenMode(): void;
+        openFullscreenMode(): void;
+        toggleFullscreenMode(): void;
+        getDuration(): void;
+        handleTimeUpdate(): void;
+        handleTimelineUpdate(e: MouseEvent): void;
+        skip(duration?: number): void;
+        toggleScrubbing(e: MouseEvent): Promise<void>;
+        handleKeyDown(e: KeyboardEvent): void;
+    }, {
+        posterUrl: string;
+        sourceItems: import('./components/EVideoPlayer.vue').VideoSource[];
+        hasStartedOrFinished: boolean;
+        withControls: "" | "hide";
+    }, {
+        targetTimestamp: string;
+        sources: string | import('./components/EVideoPlayer.vue').VideoSource[];
+        videoListeners: {};
+        videoOptions: {};
+        isHls: boolean;
+        streamingToken: string;
+        pauseOnClick: boolean;
+        isHlsLoading: boolean;
+        isPlaying: boolean;
+        isZoomable: boolean;
+        zoomableIgnorePointerEvents: boolean;
+        timezone: string;
+        playPauseAnimation: boolean;
+        disablePlayPauseAnimation: boolean;
+        isWebRtc: boolean;
+        withColoredLoader: boolean;
+        loaderSize: string;
+        withOverlayOnBackground: boolean;
+        fallbackSrc: string;
+        hlsOptions: {};
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ETimeline: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        tooltip: HTMLElement;
+        cursor: HTMLElement;
+        timeline: HTMLElement;
+        wrapperDiv: HTMLElement;
+        selectedTimestampCursor: HTMLElement;
+        svg: import("d3-selection").Selection<SVGSVGElement, any, any, any>;
+        axesContainer: import("d3-selection").Selection<SVGGElement, any, any, any>;
+        xAxes: Record<import('./types').TimelineAxis, import("d3-axis").Axis<Date>>;
+        timeScale: import("d3-scale").ScaleTime<any, any, unknown>;
+        initialTimeScale: import("d3-scale").ScaleTime<any, any, unknown>;
+        currentTimeScaleDensity: number;
+        zoomBehavior: import("d3-zoom").ZoomBehavior<SVGSVGElement, unknown>;
+        isMouseDown: boolean;
+        axisHeight: number;
+        isHoveringEvent: boolean;
+        hoveredEvent: import('./types').TimelineEvent;
+        isHoveringTimeline: boolean;
+        hoveredTimestamp: string;
+        eventTooltipStyle: {};
+        hoveredEventType: string;
+        utcOffset: number;
+        lastTransform: {
+            x: number;
+            k: number;
+        };
+        transformDiff: {
+            translation: number;
+            scale: number;
+        };
+        yScale: import("d3-scale").ScaleLinear<any, any, never>;
+        hoveredCounts: {
+            count: number;
+            type: string;
+        }[];
+        countsByTimestamp: Record<string, Record<string, number>>;
+        dotsByTimestamp: Record<string, import("d3-selection").Selection<SVGCircleElement, any, any, any>[]>;
+        visibleFrom: Date;
+        visibleTo: Date;
+        curtainHandleWidth: number;
+        leftCurtainWidth: number;
+        rightCurtainWidth: number;
+        isHoveringCurtain: boolean;
+        isDraggingCurtain: boolean;
+        characterWidth: number;
+        textPadding: number;
+        debouncedOnResize: Function;
+        isFirstPaint: boolean;
+        timeouts: number[];
+        groupsVisibility: Record<string, boolean>;
+        markersPositions: Record<string, {
+            position: number;
+            isHidden: boolean;
+        }>;
+        markersDragBehavior: import("d3-drag").DragBehavior<HTMLElement, import('./types').TimelineMarker, any>;
+        initialMarkerDragMouseOffset: number;
+        selectedMilestoneId: any;
+        isInitialized: boolean;
+        lastValidTransform: import("d3-zoom").ZoomTransform;
+        lastPanTransform: import("d3-zoom").ZoomTransform;
+        isZoomingInterval: boolean;
+        defs: {
+            transparencyGradient: string;
+            transparencyGradientLight: string;
+            loadingGradient: string;
+            stripedPattern: string;
+        };
+    }, {
+        updateTimeline(): void;
+        initTimeline(startDate?: string | undefined, endDate?: string | undefined): void;
+        initRefs(): void;
+        initOrUpdateSvg(): void;
+        initDefs(): void;
+        initUtcOffset(): void;
+        initTimeScale(start?: string | undefined, end?: string | undefined): void;
+        initXAxes(): void;
+        updateXAxes(): void;
+        initYScale(): void;
+        updateYScaleDomain(): void;
+        initZoomBehavior(): void;
+        zoomToFitMarkers(): void;
+        zoomToTargetInterval(start?: string | number | undefined, end?: string | number | undefined): void;
+        translateIntervalIntoView(minTimestamp: number, maxTimestamp: number, scaleFactor: number): void;
+        initSelectedTimestampCursor(): void;
+        updateMarkers(): void;
+        updateAndRedrawTimeline(): void;
+        clearTimeline(): void;
+        repositionSelectedTimestampCursor(): void;
+        updateCurrentTimeScaleDensity(): void;
+        registerEventsListeners(): void;
+        emitVisibleInterval(trigger: import('./types').TimelineIntervalChangeTrigger): void;
+        createAxis(axisName: import('./types').TimelineAxis): import("d3-axis").Axis<Date>;
+        getAxisTicksConfig(configs: import('./types').TimelineTicksConfig[]): {
+            formatFn: (d: Date) => string;
+            interval: any;
+        };
+        onResize(resizeObserverEntry: ResizeObserverEntry): void;
+        handleResize({ contentRect }: ResizeObserverEntry): void;
+        handleDarkModeChange(): void;
+        handleMouseDown(): void;
+        handleDocumentMouseUp(_e: MouseEvent): void;
+        handleMouseLeave(): void;
+        handleMouseMove(event: MouseEvent): void;
+        handleClick(event: MouseEvent): void;
+        handleMarkerClick(marker: import('./types').TimelineMarker): void;
+        handleLineMouseOver(_event: MouseEvent, eventData: import('./types').TimelineCountEvent, eventType: string): void;
+        handleLineMouseOut(): void;
+        handleBarMouseOver(event: MouseEvent, eventData: import('./types').TimelineEvent, eventType: string): void;
+        handleBarMouseOut(): void;
+        handleLabelMouseOver(groupType: string): void;
+        handleLabelMouseLeave(groupType: string): void;
+        isZoomAllowed(event: import("d3-zoom").D3ZoomEvent<SVGSVGElement, any>): boolean;
+        handleZoom(event: import("d3-zoom").D3ZoomEvent<SVGSVGElement, any>): void;
+        panToTimestamp(targetTimestamp: string | Date): void;
+        emitCurtainChange(): void;
+        calculateDateRangeFromCurtains(): {
+            startDate: Date;
+            endDate: Date;
+        };
+        handleDragStart(): void;
+        handleDragEnd(): void;
+        handleLeftDrag(event: import("d3-drag").D3DragEvent<SVGRectElement, any, any>): void;
+        handleRightDrag(event: import("d3-drag").D3DragEvent<SVGRectElement, any, any>): void;
+        zoomToStartAndEndDates(): void;
+        rescaleAxis(axisName: string, newScale: import("d3-scale").ScaleTime<any, any, unknown>): void;
+        translateTicksText(axisName: string): void;
+        updateEventsBars(): void;
+        updateBarChart(): void;
+        updateLineGraphs(): void;
+        updateLineGraphHoverZones(): void;
+        getEventRectX(d: import('./types').TimelineEvent): any;
+        getEventRectWidth(d: import('./types').TimelineEvent): number;
+        getEventText(e: import('./types').TimelineEvent): string;
+        getElementLeftPosition(element: HTMLElement): number;
+        isTimestampAllowedForMarker(timestamp: number | Date, marker: import('./types').TimelineMarker): boolean;
+        handleMarkerDrag({ marker, markerElement, dragEvent, }: {
+            marker: import('./types').TimelineMarker;
+            markerElement: import("d3-selection").Selection<any, import('./types').TimelineMarker, any, any>;
+            dragEvent: import("d3-drag").D3DragEvent<any, import('./types').TimelineMarker, any>;
+        }): void;
+        removeMarkersDragBehavior(): void;
+        initMarkersDragBehavior(): void;
+        initCurtains(): void;
+        createCurtains(): void;
+        updateCurtains(): void;
+        updateForbiddenIntervals(reset?: boolean): void;
+        drawEventsGroups(): void;
+        drawLineGraphEventsGroups(): void;
+        drawLineGraph({ events, gElement, color, type, }: {
+            events: import('./types').TimelineEvent[];
+            gElement: import("d3-selection").Selection<SVGGElement, any, any, any>;
+            color: string;
+            type: string;
+        }): void;
+        drawLineGraphHoverZones({ events, gElement, color, type, }: {
+            events: import('./types').TimelineCountEvent[];
+            gElement: import("d3-selection").Selection<SVGGElement, any, any, any>;
+            color: string;
+            type: string;
+        }): void;
+        drawSingleBarEventsGroup({ type, eventsGroup, milestone, dots, dotsSize, bottom, }: {
+            type: string;
+            eventsGroup: import('./types').TimelineEventsGroup;
+            milestone?: boolean | undefined;
+            dots?: boolean | undefined;
+            dotsSize?: number | undefined;
+            bottom?: boolean | undefined;
+        }): void;
+        drawBarEventsGroups(): void;
+        drawMilestonesPlaceholder(): void;
+        getMilestoneClass(milestone: import('./types').TimelineEvent): Record<string, boolean>;
+        getMilestoneColors(milestoneColor: string | undefined, groupColor: string): {
+            background: string;
+            border: string;
+        };
+        getMilestoneGroupYPosition(groupName: string): number;
+        getBarGroupYPosition(groupName: string, bottom?: boolean | undefined): number;
+        getBarGroupHeight(eventsGroup: import('./types').TimelineEventsGroup): number;
+        updateMilestonesPositions(): void;
+        drawBarChartEventsGroups(): void;
+        drawProgressIndicator({ yPosition, type, isLoading, }: {
+            yPosition: number;
+            type: string;
+            color: string;
+            isLoading: Boolean | undefined;
+        }): void;
+        drawBackground({ color, yPosition, gElement, height, }: {
+            gElement: import("d3-selection").Selection<SVGGElement, any, any, any>;
+            yPosition: number;
+            color: string;
+            height?: number | undefined;
+        }): void;
+        drawBars({ events, gElement, yPosition, color, type, dots, dotsSize, height, barBorderRadius, }: {
+            events: import('./types').TimelineEvent[];
+            gElement: import("d3-selection").Selection<SVGGElement, any, any, any>;
+            yPosition: number;
+            color: string;
+            type: string;
+            dots?: boolean | undefined;
+            dotsSize?: number | undefined;
+            height?: number | undefined;
+            barBorderRadius?: number | undefined;
+        }): void;
+        drawBarsChart({ events, gElement, color, yOffset, type, index, }: {
+            events: import('./types').TimelineEvent[];
+            gElement: import("d3-selection").Selection<SVGGElement, any, any, any>;
+            color: string;
+            yOffset: number;
+            type: string;
+            index: number;
+        }): void;
+        onBarChartBarMouseOver(container: import("d3-selection").Selection<SVGGElement, any, any, any>, color: string): void;
+        onBarChartBarMouseOut(container: import("d3-selection").Selection<SVGGElement, any, any, any>, eventType: string): void;
+        drawTextLabel({ gElement, yPosition, color, label, type, height, }: {
+            gElement: import("d3-selection").Selection<SVGGElement, any, any, any>;
+            yPosition: number;
+            color: string;
+            label: string;
+            type: string;
+            height?: number | undefined;
+        }): void;
+        getTextFillColor(baseColor: string, k?: number): string;
+        getLabelBackgroundColor(baseColor: string): string;
+        getCurrentGroupVisibility(type: string): boolean;
+        toggleGroupVisibility(type: string): void;
+        getExternalLabelStyles(type: string): {
+            background: string;
+            color: string;
+        };
+        getExternalLabelWrapperStyles(type: string): {
+            borderColor: string;
+        };
+        getMarkerClass(marker: import('./types').TimelineMarker): {
+            "marker--hidden": boolean;
+            "marker--draggable": boolean | undefined;
+        };
+        getMarkerContainerStyle(marker: import('./types').TimelineMarker): Record<string, string>;
+        getMarkerLabelStyle(marker: import('./types').TimelineMarker): Record<string, string>;
+        getMarkerLineStyle(marker: import('./types').TimelineMarker): Record<string, string>;
+        tzStringToDate(timestamp: import('./types').Timestamp): Date;
+        dateToTzString(date: Date): string;
+        getCurrentTimeBounds(): {
+            startDate: string;
+            endDate: string;
+        };
+        getFormattedTimestamp(timestamp: import('./types').Timestamp): string;
+        fillTimeGaps(events: import('./types').TimelineEvent[]): (import('./types').TimelineBarEvent | import('./types').TimelineRangeEvent | import('./types').TimelineCountEvent | {
+            timestamp: string;
+            count: number;
+        })[];
+        fillEvents(events: import('./types').TimelineEvent[]): import('./types').TimelineEvent[];
+        onMilestoneClick(milestone: import('./types').TimelineEvent, milestoneType: any): void;
+        getSortedEvents(events: import('./types').TimelineEvent[]): import('./types').TimelineEvent[];
+    }, {
+        combinedBarsHeight: number;
+        combinedBottomBarsHeight: number;
+        combinedMilestonesHeight: number;
+        milestonesYOffset: number;
+        chartsYOffset: number;
+        barsYOffset: number;
+        hasMilestones: boolean;
+        barChartHeight: number;
+        classes: Record<string, string | Record<string, boolean>>;
+        lineGraphGroups: import('./types').TimelineEventsByType;
+        chartHeight: number;
+        barGroups: import('./types').TimelineEventsByType;
+        barChartGroups: import('./types').TimelineEventsByType;
+        milestonesGroups: import('./types').TimelineEventsByType;
+        hasChart: boolean;
+        labelRectWidth: number;
+        combinedXAxesHeight: number;
+        timelineHeight: number;
+        filteredEventsGroups: import('./types').TimelineEventsByType;
+        allEventsSorted: import('./types').TimelineEvent[];
+        oldestEvent: import('./types').TimelineEvent;
+        latestEvent: import('./types').TimelineEvent;
+        allLineChartTimestamps: string[];
+        placeholderLineChartGroup: import('./types').TimelineEvent[];
+        filledGapsLineGraphGroups: import('./types').TimelineEventsByType;
+        isInteractingWithCurtain: boolean;
+        flattenedCounts: import('./types').TimelineCountEvent[];
+        hiddenGroupsLabels: string[];
+        minHoverZone: number;
+        sortedMarkers: import('./types').TimelineMarker[];
+    }, {
+        eventsGroups: {};
+        xAxesConfig: import('./types').TimelineAxesConfig;
+        dark: boolean;
+        startDate: string;
+        endDate: string;
+        selectedTimestamp: string;
+        showEventTooltip: boolean;
+        disableZoom: boolean;
+        insertZerosAtInterval: import('./types').TimelinePrecision;
+        flattenLineGraphEnds: boolean;
+        curtains: boolean;
+        showLabels: boolean;
+        rectMinWidth: number;
+        barHeight: number;
+        barYPadding: number;
+        barXPadding: number;
+        chartMinHeight: number;
+        chartMinLabelHeight: number;
+        minZoom: number;
+        maxZoom: number;
+        minDate: string;
+        maxDate: string;
+        cursorTimestamp: string | undefined;
+        selectedClass: string | undefined;
+        panOnDateClick: boolean;
+        panTransitionDuration: number;
+        selectedDate: string;
+        autoResize: boolean;
+        markers: import('./types').TimelineMarker[];
+        stickyMarkers: boolean;
+        fitMarkersOnChange: boolean;
+        zoomToIntervalTransitionDuration: number;
+        zoomToBoundariesTransitionDuration: number;
+        milestoneBulletSize: number;
+        milestonesFirst: boolean;
+        forbiddenIntervals: import('./types').TimelineInterval[];
+        forbiddenIntervalColor: string;
+        focusedInterval: import('./types').TimelineInterval | undefined;
+        locked: boolean;
+        timezone: string | undefined;
+        stopClickPropagation: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EVideoEmbed: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        videoId: string | undefined;
+        embedUrl: string;
+    }, {
+        videoUrl: string;
+        platform: "youtube" | "vimeo";
+        iframeListeners: {};
+        iframeOptions: any;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EHeatmapBar: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, {
+        getColorIndex(count: number): number;
+        getColor(count: number): string;
+        getItemStyle(count: number): {
+            background: string;
+        };
+    }, {
+        heatMapBarItems: import('./types').HeatmapBarItem[];
+        maxCount: number;
+    }, {
+        items: unknown[];
+        selectedValue: string | number;
+        showCounts: boolean;
+        showNames: boolean;
+        colors: unknown[];
+        label: string;
+        dense: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EHoursHeatmap: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, {
+        getFormattedHour(h: number): string;
+    }, {
+        itemsByHour: Record<string, import('./types').HoursHeatmapChartItem>;
+        heatmapBarItems: any;
+    }, {
+        items: unknown[];
+        selectedHour: string | number;
+        showHours: boolean;
+        colors: unknown[];
+        label: string;
+        dense: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EReadMore: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        showAllContent: boolean;
+    }, {
+        displayContent(): any;
+        displayArrayContent(): any;
+        displayTextContent(): string | unknown[] | (() => null);
+        toggleContentExpansion(): void;
+    }, {
+        hiddenContentLength: number;
+        isArrayContent: boolean;
+        isHiddenTextContent: boolean;
+        isHiddenArrayContent: boolean;
+        isContentExpanded: boolean;
+        computedMoreText: string;
+    }, {
+        content: string | unknown[] | (() => null);
+        maxLength: number;
+        showAll: boolean;
+        expandText: string;
+        collapseText: string;
+        moreTextWithPlaceholder: string;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ETruncatedDiv: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        containerStyle: Record<string, any>;
+    }, {
+        width: string | number;
+        fixedWidth: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ECompareSeparator: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        separatorStyle: Record<string, any>;
+    }, {
+        xOffset: string | number;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EImagesComparator: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        separatorPositionX: number;
+        startSeparatorPositionX: number;
+        computedImageDimension: Record<string, any>;
+        isSeparatorDragging: boolean;
+        watermarkDimension: Record<string, any>;
+        touchIdentifier: number | null;
+        startTouchX: number;
+        containerRect: DOMRect;
+    }, {
+        handleResize(): void;
+        handleWatermarkResize(): void;
+        handleMouseMove(event: MouseEvent): void;
+        handleMouseDown(): void;
+        handleMouseUp(): void;
+        handleTouchStart(event: TouchEvent): void;
+        handleTouchMove(event: TouchEvent): void;
+        handleTouchEnd(event: TouchEvent): void;
+    }, {
+        clipStyle: Record<string, string>;
+        contentStyle: Record<string, string>;
+    }, {
+        beforeImageSrc: string;
+        afterImageSrc: string;
+        isLoading: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EToggleSwitch: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        value: any;
+    }, {
+        getButtonClasses(optionValue: any): {
+            "e-border-none": boolean;
+            "e-bg-inherit": boolean;
+            "e-bg-brand-600": boolean;
+            "e-bg-gray-600": boolean;
+            "e-bg-[#629efc] e-text-gray-900 e-font-normal": boolean;
+        };
+        handleClick(value: any): void;
+    }, {
+        sizeClasses: {
+            container: import('./components/EToggleSwitch.vue').CssClassMap;
+            button: import('./components/EToggleSwitch.vue').CssClassMap;
+            text: import('./components/EToggleSwitch.vue').CssClassMap;
+        };
+        containerClasses: import('./components/EToggleSwitch.vue').CssClassMap;
+        textClasses: import('./components/EToggleSwitch.vue').CssClassMap;
+        buttonBaseClasses: import('./components/EToggleSwitch.vue').CssClassMap;
+    }, {
+        options: import('./components/EToggleSwitch.vue').EToggleSwitchOption[];
+        color: string;
+        size: import('./types').Size;
+        defaultValue: string | number | boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EExpandableMenu: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        menu: boolean;
+        touched: boolean;
+        baseSize: {};
+    }, {
+        toggleMenu(): void;
+        setButtonsPositions(open?: boolean | undefined): void;
+    }, {
+        row: boolean;
+        reverse: boolean;
+    }, {
+        padding: number;
+        direction: string;
+        isMobile: boolean;
+    }, {}, import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        timeouts: number[];
+    }, {
+        $setTimeout(cb: Function, timeout?: number): number;
+        $clearTimeouts(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin> | import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        eventListeners: import("./mixins/event-listeners").IEventListener[];
+    }, {
+        $addEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListeners(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>;
+    EZoomable: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        scale: number;
+        minScale: number;
+        maxScale: number;
+        top: number;
+        left: number;
+        isPanning: boolean;
+        panStart: {
+            x: number;
+            y: number;
+        };
+        isPinching: boolean;
+        previousPinchDistance: number;
+        pinchDistance: number;
+        pointers: Record<number, PointerEvent>;
+        transform: string;
+    }, {
+        updateZoomScale(): void;
+        handleZoom(e: WheelEvent): void;
+        handleMouseDown(e: MouseEvent): void;
+        handleMouseUp(): void;
+        handleMouseLeave(): void;
+        handleMouseMove(e: MouseEvent): void;
+        applyBoundsCorrection(): void;
+        updateTransform(): void;
+        getPointersDistance(a: PointerEvent, b: PointerEvent): number;
+        getPointersMidPoint(a: PointerEvent, b: PointerEvent): {
+            x: number;
+            y: number;
+        };
+        updatePointerEvent(e: PointerEvent): void;
+        clearPointerEvent(e: PointerEvent): void;
+        updatePinchDistance(): void;
+        handlePointerDown(e: PointerEvent): void;
+        handlePointerMove(e: PointerEvent): void;
+        handlePointerUp(e: PointerEvent): void;
+    }, {
+        contentStyle: import("vue").StyleValue;
+        isZoomed: boolean;
+    }, {
+        ignorePointerEvents: boolean;
+        withOverlay: boolean;
+        disabled: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EGlobalSearch: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        search: string;
+        isSearching: boolean;
+    }, {
+        onInput(event: InputEvent): void;
+        searchObjectsByQuery(objects: import('./types').GlobalSearchResultInput[], query: string): import('./types').GlobalSearchResult[];
+        findMatchesInObject(obj: import('./types').GlobalSearchResultInput, query: string, path: string[]): import('./types').GlobalSearchMatch[];
+        matchesQuery(value: any, query: string): boolean;
+        isValidDate(date: string | Date): boolean;
+        formattedTimestamp(timestamp: string): string;
+        onKeyHandler(event: unknown): void;
+    }, {
+        inputClasses: Record<string, boolean>;
+    }, {
+        dark: boolean;
+        items: import('./types').GlobalSearchResultInput;
+        timezone: string;
+        convertedDateFormat: string;
+        currentDateFormat: string;
+        isFixedPosition: boolean;
+        isHidden: boolean;
+        deep: boolean;
+    }, {}, import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        eventListeners: import("./mixins/event-listeners").IEventListener[];
+    }, {
+        $addEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListeners(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>;
+    ESvgIcon: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        svgIconComponent: any;
+    }, {
+        icon: string;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+};
+declare const _default: {
+    install(Vue: VueConstructor): void;
+};
+export default _default;
+export { EAvatar, EBadge, EIcon, ESpinner, ERow, ECol, EVideoPlayer, ETimeline, EVideoEmbed, EHeatmapBar, EHoursHeatmap, EReadMore, ETruncatedDiv, ECompareSeparator, EImagesComparator, EToggleSwitch, EExpandableMenu, EZoomable, EGlobalSearch, ESvgIcon, };
+export * from './constants';
+export * from './types';
+export * from './utils';
+export * from './directives';
+export * from './mixins';