@hotelinking/ui 10.43.0 → 10.43.5

package/dist/ui.d.ts

@@ -0,0 +1,1927 @@
+import { App } from 'vue';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { DefineComponent } from 'vue';
+import { FileInputType as FileInputType_2 } from '../../../types';
+import { FunctionalComponent } from 'vue';
+import { InputType as InputType_2 } from '../../../types';
+import { PublicProps } from 'vue';
+import { SelectItemType as SelectItemType_2 } from '../../../types';
+import { UiCheckboxType as UiCheckboxType_2 } from '../../../types';
+import { UiDropdownItemType as UiDropdownItemType_2 } from '../../../types';
+import { UiTagInterface as UiTagInterface_2 } from '../../../types';
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_2<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_3<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_4<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_5<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_6<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_7<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_8<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+export declare const AllColors: readonly ["primary", "secondary", "light", "green", "yellow", "red", "black", "gray", "white"];
+
+declare const AllColors: readonly ["primary", "secondary", "light", "green", "yellow", "red", "black", "gray", "white"];
+
+declare type AllColors_2 = typeof AllColors[number];
+
+export declare const AllSizes: readonly ["small", "medium", "big", "bigger", "huge", "massive"];
+
+declare const AllSizes: readonly ["small", "medium", "big", "bigger", "huge", "massive"];
+
+declare type AllSizes_2 = typeof AllSizes[number];
+
+export declare const BiggerSizes: readonly ["bigger", "huge", "massive"];
+
+export declare type chartOptionsType = {
+    chart: {
+        toolbar: {
+            show: boolean;
+        };
+        zoom: {
+            enabled: boolean;
+        };
+        stacked?: boolean;
+        type?: "area" | "line" | "bar" | "scatter";
+    };
+    colors: any;
+    stroke?: {
+        show: boolean;
+        curve: string;
+        lineCap: string;
+        width: number;
+        dashArray: number;
+    };
+    dataLabels: {
+        enabled: boolean;
+        formatter?: Function;
+    };
+    markers: {
+        strokeWidth: number;
+        size: number;
+        hover: {
+            size: number;
+        };
+    };
+    annotations?: {
+        yaxis: [
+            {
+            y: number;
+            borderColor: string;
+            label: {
+                borderColor: string;
+                style: {
+                    color: string;
+                    background: string;
+                };
+                text: string;
+            };
+        }
+        ];
+    };
+    tooltip?: {
+        intersect: boolean;
+        shared: boolean;
+    };
+    plotOptions?: {
+        bar: {
+            horizontal?: boolean;
+            borderRadius?: number;
+            barHeight?: string;
+            isFunnel?: boolean;
+        };
+    };
+};
+
+export declare const Colors: readonly ["primary", "secondary", "light", "green", "yellow", "red"];
+
+declare const Colors: readonly ["primary", "secondary", "light", "green", "yellow", "red"];
+
+declare type Colors_2 = typeof Colors[number];
+
+declare const _default: {
+    install: typeof install;
+};
+export default _default;
+
+export declare type FileInputType = {
+    /** Id of the input field */
+    id: string;
+    /** Uploaded files */
+    files: any;
+};
+
+export declare type InputType = {
+    /** Name of the input field */
+    name: string;
+    /** Internal value of input field */
+    value: string;
+};
+
+declare type InputTypes = typeof UiInputTypes[number];
+
+declare function install(app: App): void;
+
+export declare const MonoColors: readonly ["black", "gray", "white"];
+
+export declare type SelectItemType = {
+    /** Unique value inside the select */
+    id: string;
+    /** Name of the item */
+    name: string;
+};
+
+export declare const Sizes: readonly ["small", "medium", "big"];
+
+declare const Sizes: readonly ["small", "medium", "big"];
+
+declare type Sizes_2 = typeof Sizes[number];
+
+export declare type TableItemType = {
+    /** co unique id */
+    id: string | number;
+    /** when a row is emitted, if additional info is needed, can be put here */
+    emitWith?: any;
+    /** content, can be string, link, tag */
+    row: Array<string | {
+        /** string literal */
+        content: string;
+        /** if tag, backgroun color of tag */
+        color: AllColors_2;
+        /** tag, link that emits, or href link */
+        type?: 'tag' | 'link' | 'href';
+        /** content emitted if clicked on link type */
+        emits?: any;
+        /** target url of href type */
+        href?: string;
+    }>;
+};
+
+export declare type TaskType = {
+    /** internal id of task*/
+    id: number;
+    /** name of task */
+    name: string;
+    /** task action string */
+    action: string;
+    /** task action href */
+    href: string;
+    /** task action status */
+    status: "Complete" | "In progress" | "Incomplete";
+    /** task status literal string */
+    statusLiteral: string;
+    /** task description */
+    description: string;
+};
+
+export declare const Types: string[];
+
+declare const Types: string[];
+
+declare type Types_2 = typeof Types[number];
+
+export declare const uiAlert: __VLS_WithTemplateSlots_4<DefineComponent<UiAlertInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+alertEvent: (T: string) => any;
+}, string, PublicProps, Readonly<UiAlertInterface> & Readonly<{
+onAlertEvent?: ((T: string) => any) | undefined;
+}>, {
+loading: boolean;
+type: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+
+export declare interface UiAlertEventsInterface {
+    /** When an alert action is clicked emits UiAlertInterface["actions"]["event"] */
+    (e: 'alertEvent', T: string): void;
+}
+
+export declare interface UiAlertInterface {
+    /** List of possible actions that are at the bottom of the notification */
+    actions?: {
+        name: string;
+        event: string;
+    }[];
+    /** Notification title */
+    title: string;
+    /** Notification type */
+    type?: string;
+    /** Is loading or not */
+    loading?: boolean;
+}
+
+export declare const uiBreadcrumbs: DefineComponent<UiBreadcrumbsInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+breadCrumbClicked: (T: string) => any;
+}, string, PublicProps, Readonly<UiBreadcrumbsInterface> & Readonly<{
+onBreadCrumbClicked?: ((T: string) => any) | undefined;
+}>, {
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiBreadcrumbsEventInterface {
+    /** emits UiBreadcrumbsInterface["pages"]["routeName"] when a breadcrumb is clicked */
+    (e: 'breadCrumbClicked', T: string): void;
+}
+
+export declare interface UiBreadcrumbsInterface {
+    /** pages array */
+    pages: {
+        /** string literal */
+        name: string;
+        /** route link */
+        routeName: string;
+        /** it´s current route or not */
+        current?: boolean;
+    }[];
+    /** shows skeletons */
+    loading?: boolean;
+}
+
+export declare const uiButton: __VLS_WithTemplateSlots<DefineComponent<UiButtonInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<UiButtonInterface> & Readonly<{}>, {
+loading: boolean;
+size: "big" | "small" | "medium";
+color: "primary" | "secondary" | "light" | "green" | "yellow" | "red";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+
+export declare interface UiButtonInterface {
+    /** Defines if button as block class applied or not */
+    block?: boolean;
+    /** Color options (see type Colors) */
+    color?: Colors_2;
+    /** Button is enabled or disabled */
+    disabled?: boolean;
+    /** Defines an icon in button´s left side. As you need to import the icon directly from icons library, you must use '@heroicons/vue/24/outline' icon type */
+    icon?: FunctionalComponent;
+    /** Is in skeleton mode or not */
+    loading: boolean;
+    /** Size options (see type Sizes) */
+    size?: Sizes_2;
+}
+
+export declare const uiCard: DefineComponent<UiCardInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+cardSelected: (T: {
+id: string;
+name: string;
+type: string;
+tags: UiTagInterface_2[] | undefined;
+}) => any;
+}, string, PublicProps, Readonly<UiCardInterface> & Readonly<{
+onCardSelected?: ((T: {
+id: string;
+name: string;
+type: string;
+tags: UiTagInterface_2[] | undefined;
+}) => any) | undefined;
+}>, {
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiCardEventsInterface {
+    /** Emits when card is clicked */
+    (e: 'cardSelected', T: {
+        id: UiCardInterface["id"];
+        name: UiCardInterface["name"];
+        type: UiCardInterface["type"];
+        tags: UiCardInterface["tags"];
+    }): void;
+}
+
+export declare interface UiCardInterface {
+    /** card id */
+    id: string;
+    /** card title */
+    name: string;
+    /** card subtitle */
+    type: string;
+    /** array of tags */
+    tags?: UiTagInterface[];
+    /** logo url string */
+    logo: string;
+    /** show skeleton */
+    loading: boolean;
+}
+
+export declare const uiChart: DefineComponent<UiChartInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+selectedRange: (T: {
+range: {
+from: string | Date;
+to: string | Date;
+};
+chartId: string;
+}) => any;
+chartUpdated: () => any;
+dataPointSelection: (T: any) => any;
+maximizeChart: (T: string) => any;
+}, string, PublicProps, Readonly<UiChartInterface> & Readonly<{
+onSelectedRange?: ((T: {
+range: {
+from: string | Date;
+to: string | Date;
+};
+chartId: string;
+}) => any) | undefined;
+onChartUpdated?: (() => any) | undefined;
+onDataPointSelection?: ((T: any) => any) | undefined;
+onMaximizeChart?: ((T: string) => any) | undefined;
+}>, {
+loading: boolean;
+type: "area" | "line" | "bar" | "scatter";
+id: string;
+empty: boolean;
+horizontal: boolean;
+stacked: boolean;
+height: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiChartEventsInterface {
+    /** emitted when user clicks on range inputs */
+    (e: "selectedRange", T: {
+        range: {
+            from: Date | string;
+            to: Date | string;
+        };
+        chartId: UiChartInterface["id"];
+    }): void;
+    /** emitted when chart updated */
+    (e: "chartUpdated"): void;
+    /** emitted when a point inside chart is clicked */
+    (e: "dataPointSelection", T: any): void;
+    /** emitted when user clicks on enlarge icon */
+    (e: "maximizeChart", T: UiChartInterface["id"]): void;
+}
+
+export declare interface UiChartInterface {
+    /** uiCircleChart sections labels */
+    labels?: string[];
+    /** default date ranges */
+    dates?: {
+        from: Date | string;
+        to: Date | string;
+    };
+    /** chart title */
+    title: string;
+    /** chart is Net promoter score */
+    isNps?: boolean;
+    /** nps string literals */
+    npsLiterals?: {
+        unhappy: string;
+        neutral: string;
+        happy: string;
+    };
+    /** chart id */
+    id: string;
+    /** chart type (NOT USED in uiCircleChart && uiFunnelChartV2) */
+    type?: "area" | "line" | "bar" | "scatter";
+    /** chart series and if different type, type */
+    series: {
+        name: string;
+        type?: "area" | "line" | "bar" | "scatter";
+        data: number[];
+    }[];
+    /** chart options (NOT USED in uiCircleChart) */
+    options?: {
+        xaxis: {
+            type: string;
+            max?: number;
+            categories: string[];
+        };
+    };
+    /** show skeleton */
+    loading?: boolean;
+    /** if chart has no data */
+    empty?: boolean;
+    /** show data in this range */
+    range?: "24h" | "7d" | "1m" | "3m" | "all";
+    /** horizontal or vertical (for columns) (NOT USED in uiCircleChart && uiFunnelChartV2) */
+    horizontal?: boolean;
+    /** columns are stacked (NOT USED in uiCircleChart && uiFunnelChartV2) */
+    stacked?: boolean;
+    /** if charts needs a custom height */
+    height?: number;
+    /** draw a line (check score objetive) (NOT USED in uiCircleChart && uiFunnelChartV2) */
+    annotations?: {
+        text: string;
+        high: number;
+    };
+}
+
+export declare const uiCheckbox: __VLS_WithTemplateSlots_2<DefineComponent<UiCheckboxInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+checkboxChanged: (checkbox: UiCheckboxType_2) => any;
+}, string, PublicProps, Readonly<UiCheckboxInterface> & Readonly<{
+onCheckboxChanged?: ((checkbox: UiCheckboxType_2) => any) | undefined;
+}>, {
+disabled: boolean;
+loading: boolean;
+check: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+
+export declare interface UiCheckboxEventsInterface {
+    /** Emitted when click over checkbox */
+    (e: 'checkboxChanged', checkbox: UiCheckboxType): void;
+}
+
+export declare interface UiCheckboxInterface {
+    /** Is checked or not */
+    check?: boolean;
+    /** Is disabled or not */
+    disabled?: boolean;
+    /** Is loading or not */
+    loading: boolean;
+    /** Internal value of checkbox */
+    value: string;
+    /** To be used in UiSidebarV2 */
+    text?: string;
+}
+
+export declare type UiCheckboxType = {
+    /** Is checked or not */
+    checked: boolean;
+    /** Internal value of checkbox */
+    value: string;
+};
+
+export declare const uiCircleChart: DefineComponent<UiChartInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+selectedRange: (T: {
+range: {
+from: string | Date;
+to: string | Date;
+};
+chartId: string;
+}) => any;
+chartUpdated: () => any;
+dataPointSelection: (T: any) => any;
+maximizeChart: (T: string) => any;
+}, string, PublicProps, Readonly<UiChartInterface> & Readonly<{
+onSelectedRange?: ((T: {
+range: {
+from: string | Date;
+to: string | Date;
+};
+chartId: string;
+}) => any) | undefined;
+onChartUpdated?: (() => any) | undefined;
+onDataPointSelection?: ((T: any) => any) | undefined;
+onMaximizeChart?: ((T: string) => any) | undefined;
+}>, {
+loading: boolean;
+id: string;
+empty: boolean;
+horizontal: boolean;
+stacked: boolean;
+height: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare const uiDateRange: DefineComponent<UiDateRangeInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+uiDateRangeButtonClicked: (t: {
+from: string | Date;
+to: string | Date;
+} | undefined) => any;
+}, string, PublicProps, Readonly<UiDateRangeInterface> & Readonly<{
+onUiDateRangeButtonClicked?: ((t: {
+from: string | Date;
+to: string | Date;
+} | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiDateRangeEventsInterface {
+    /** emitted when date range button is clicked */
+    (e: 'uiDateRangeButtonClicked', t: UiDateRangeInterface["values"] | undefined): void;
+}
+
+export declare interface UiDateRangeInterface {
+    /** unique identifier */
+    id: string;
+    /** show skeleton */
+    loading?: boolean;
+    /** date range literal strings */
+    literals: {
+        from: string;
+        to: string;
+        search: string;
+    };
+    /** default date ranges */
+    values: {
+        from: Date | string;
+        to: Date | string;
+    };
+    /** date range field colors */
+    color?: AllColors_2;
+    /** show error message below field */
+    error?: string;
+    /** is date range disabled */
+    disabled?: boolean;
+    /** show label above date range */
+    label?: string;
+    /** fields placeholder */
+    placeholder?: string;
+}
+
+export declare const uiDeviceStatus: DefineComponent<UiDeviceStatusInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+deviceStatusTagClicked: (T: string | undefined) => any;
+deviceStatusQtyClicked: (T: string) => any;
+}, string, PublicProps, Readonly<UiDeviceStatusInterface> & Readonly<{
+onDeviceStatusTagClicked?: ((T: string | undefined) => any) | undefined;
+onDeviceStatusQtyClicked?: ((T: string) => any) | undefined;
+}>, {
+loading: boolean;
+qty: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiDeviceStatusEventsInterface {
+    /** emitted when a tag is clicked*/
+    (e: 'deviceStatusTagClicked', T: UiTagInterface["event"]): void;
+    /** emitted when the link in the device status is clicked */
+    (e: 'deviceStatusQtyClicked', T: UiDeviceStatusInterface["id"]): void;
+}
+
+export declare interface UiDeviceStatusInterface {
+    /** device id */
+    id: string;
+    /** device name */
+    name: string;
+    /** icon component from Heroicons */
+    icon: any;
+    /** icon background color */
+    color: AllColors_2;
+    /** device quantity */
+    qty: number;
+    /** tags array */
+    tags?: UiTagInterface[];
+    /** show skeleton */
+    loading: boolean;
+}
+
+export declare const uiDragAndDrop: DefineComponent<UiDragAndDropInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+dragAndDropUpdated: (T: any) => any;
+}, string, PublicProps, Readonly<UiDragAndDropInterface> & Readonly<{
+onDragAndDropUpdated?: ((T: any) => any) | undefined;
+}>, {
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiDragAndDropEventsInterface {
+    /** emitted when drag and drop elements are updated (dragged)*/
+    (e: "dragAndDropUpdated", T: any): void;
+}
+
+export declare interface UiDragAndDropInterface {
+    /** drag and drop array of elements */
+    elements: {
+        id: number;
+        name: string;
+        description: string;
+    }[];
+    /** show skeleton */
+    loading?: boolean;
+}
+
+export declare const uiDropdown: DefineComponent<UiDropdownInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+optionSelected: (v: UiDropdownItemType) => any;
+}, string, PublicProps, Readonly<UiDropdownInterface> & Readonly<{
+onOptionSelected?: ((v: UiDropdownItemType) => any) | undefined;
+}>, {
+position: "left" | "right";
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiDropdownEventsInterface {
+    /** On option selected */
+    (e: 'optionSelected', v: UiDropdownItemType): void;
+}
+
+export declare interface UiDropdownInterface {
+    /** Dropdown items */
+    items: UiDropdownItemType[];
+    /** Set dropdown to left or right */
+    position?: "left" | "right";
+    /** Is disabled or not */
+    disabled?: boolean;
+    /** Top label of Dropdown */
+    label?: string;
+    /** Is loading or not */
+    loading: boolean;
+    /** Text that appears top right side of the dropdown field, that informs to user is a required field */
+    requiredText?: string;
+}
+
+export declare type UiDropdownItemType = {
+    /** Name of item */
+    name: string;
+    /** Value of item */
+    value: string;
+    /** Is it active or not */
+    active?: boolean;
+};
+
+export declare const uiDynamicStats: DefineComponent<UiDynamicStatsInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<UiDynamicStatsInterface> & Readonly<{}>, {
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface UiDynamicStatsInterface {
+    /** uiStat Array */
+    dynamicStats: UiStatsInterface["item"][];
+    /** show skeleton */
+    loading: boolean;
+}
+
+export declare const uiFilter: DefineComponent<UiFilterInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+filterSelected: (T: string) => any;
+}, string, PublicProps, Readonly<UiFilterInterface> & Readonly<{
+onFilterSelected?: ((T: string) => any) | undefined;
+}>, {
+position: "left" | "right";
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiFilterEventsInterface {
+    /** emits UiFilterInterface["items"]["value"] when filter is selected */
+    (e: 'filterSelected', T: string): void;
+}
+
+export declare interface UiFilterInterface {
+    /** items array */
+    items: {
+        /** item name */
+        name: string;
+        /** item value */
+        value: string;
+        /** is is selected or not */
+        active?: boolean;
+    }[];
+    /** float position of dropdown */
+    position?: "left" | "right";
+    /** label literal above filter */
+    label?: string;
+    /** show skeleton */
+    loading?: boolean;
+}
+
+export declare const uiFooter: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare const uiFunnelChartV2: DefineComponent<UiChartInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+selectedRange: (T: {
+range: {
+from: string | Date;
+to: string | Date;
+};
+chartId: string;
+}) => any;
+chartUpdated: () => any;
+dataPointSelection: (T: any) => any;
+maximizeChart: (T: string) => any;
+}, string, PublicProps, Readonly<UiChartInterface> & Readonly<{
+onSelectedRange?: ((T: {
+range: {
+from: string | Date;
+to: string | Date;
+};
+chartId: string;
+}) => any) | undefined;
+onChartUpdated?: (() => any) | undefined;
+onDataPointSelection?: ((T: any) => any) | undefined;
+onMaximizeChart?: ((T: string) => any) | undefined;
+}>, {
+loading: boolean;
+type: "area" | "line" | "bar" | "scatter";
+id: string;
+range: "24h" | "7d" | "1m" | "3m" | "all";
+empty: boolean;
+horizontal: boolean;
+stacked: boolean;
+height: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare const uiGallery: DefineComponent<UiGalleryInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+modalAction: (T: any) => any;
+deleteImage: (T: any) => any;
+imgClicked: (T: any) => any;
+}, string, PublicProps, Readonly<UiGalleryInterface> & Readonly<{
+onModalAction?: ((T: any) => any) | undefined;
+onDeleteImage?: ((T: any) => any) | undefined;
+onImgClicked?: ((T: any) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface UiGalleryEventsInterface {
+    /** emitted when a modal action is clicked, emits modal action */
+    (e: "modalAction", T: any): void;
+    /** emitted when delete image bin icon is clicked, emits image */
+    (e: "deleteImage", T: any): void;
+    /** emitted when an image is clicked, emits image */
+    (e: "imgClicked", T: any): void;
+}
+
+export declare interface UiGalleryInterface {
+    /** unique id gallery */
+    galleryId: string;
+    /** images gallery array */
+    gallery: {
+        /** image title or file name */
+        title: string;
+        /** image size reference */
+        size: string;
+        /** image url */
+        source: string;
+    }[];
+    /** show skeleton */
+    loading?: boolean;
+    /** image gallery string literals */
+    literals: {
+        /** delete button string literal */
+        deleteAllImages: string;
+        /** doble opt in modal title */
+        modalTitle: string;
+        /** doble opt in modal text */
+        modalText: string;
+        /** close action string literal */
+        closeAction: string;
+        /** delete action string literal */
+        deleteAction: string;
+    };
+}
+
+export declare const uiIcon: DefineComponent<UiIconInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<UiIconInterface> & Readonly<{}>, {
+loading: boolean;
+size: "big" | "small" | "medium" | "bigger" | "huge" | "massive";
+color: "primary" | "secondary" | "light" | "green" | "yellow" | "red" | "black" | "gray" | "white";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiIconInterface {
+    /** Imported icon from '@heroicons/vue/24/outline' */
+    icon: FunctionalComponent;
+    /** Size options (see type AllSizes) */
+    size?: AllSizes_2;
+    /** Color options (see type AllColors) */
+    color?: AllColors_2;
+    /** Is loading or not */
+    loading: boolean;
+}
+
+export declare const uiInput: DefineComponent<UiInputInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+inputChanged: (T: InputType_2) => any;
+rightAddOnClicked: () => any;
+addOnClicked: () => any;
+}, string, PublicProps, Readonly<UiInputInterface> & Readonly<{
+onInputChanged?: ((T: InputType_2) => any) | undefined;
+onRightAddOnClicked?: (() => any) | undefined;
+onAddOnClicked?: (() => any) | undefined;
+}>, {
+loading: boolean;
+type: "number" | "text" | "email" | "password" | "date" | "datetime-local";
+color: "primary" | "secondary" | "light" | "green" | "yellow" | "red" | "black" | "gray" | "white";
+placeholder: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiInputEventsInterface {
+    /** Whenever the input changes */
+    (e: "inputChanged", T: InputType): void;
+    /** Right addon is clicked */
+    (e: "rightAddOnClicked"): void;
+    /** Addon clicked */
+    (e: "addOnClicked"): void;
+}
+
+export declare const uiInputFile: DefineComponent<UiInputFileInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+filesUploaded: (T: FileInputType_2) => any;
+}, string, PublicProps, Readonly<UiInputFileInterface> & Readonly<{
+onFilesUploaded?: ((T: FileInputType_2) => any) | undefined;
+}>, {
+loading: boolean;
+icon: any;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiInputFileEventsInterface {
+    /** Whenever files are dragged inside input field, or send the default way */
+    (e: "filesUploaded", T: FileInputType): void;
+}
+
+export declare interface UiInputFileInterface {
+    /** Name of the input field */
+    name: string;
+    /** Id of the input field */
+    id: string;
+    /** Text that appears top right side of the input field, that informs to user is a required field */
+    requiredText?: string;
+    /** Placeholder of the input field */
+    placeholder: string;
+    /** Part of text literal that makes reference to drag and drop a file inside the input field */
+    dragAndDrop: string;
+    /** Part of text literal that makes reference to file types inside the input field */
+    fileTypesAndSizes: string;
+    /** Text below the input field that shows the error */
+    error?: string;
+    /** MIME types of files that input field must accept */
+    accept: string;
+    /** Imported icon from '@heroicons/vue/24/outline' */
+    icon?: any;
+    /** Is loading or not */
+    loading: boolean;
+    /** Label in top of the input field */
+    label?: string;
+}
+
+export declare interface UiInputInterface {
+    /** Label in top of the input field */
+    label?: string;
+    /** Input field type */
+    type?: InputTypes;
+    /** Name of the input field */
+    name: string;
+    /** Placeholder of the input field */
+    placeholder?: string;
+    /** Imported icon from '@heroicons/vue/24/outline' */
+    icon?: any;
+    /** Is disabled or not */
+    disabled?: boolean;
+    /** Color options (see type Colors) */
+    color?: AllColors_2;
+    /** Internal value of input field */
+    value?: string;
+    /** Text below the input field that shows the error */
+    error?: string;
+    /** Text that appears top right side of the input field, that informs to user is a required field */
+    requiredText?: string;
+    /** Addon text in the input field */
+    addOn?: string;
+    /** Addon text but at right side of input field */
+    rightAddOn?: string;
+    /**max value*/
+    max?: string | number;
+    /**min value*/
+    min?: string | number;
+    /** Is loading or not */
+    loading: boolean;
+}
+
+export declare const UiInputTypes: readonly ["text", "email", "password", "number", "date", "datetime-local"];
+
+export declare const uiLoadingScreen: DefineComponent<UiLoadScreenInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<UiLoadScreenInterface> & Readonly<{}>, {
+fixed: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface UiLoadScreenInterface {
+    /** title string */
+    title?: string;
+    /** message string */
+    message?: string;
+    /** not in use, only for DS purposes */
+    fixed?: boolean;
+}
+
+export declare const uiModal: __VLS_WithTemplateSlots_5<DefineComponent<UiModalInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+modalAction: (T: {
+modal: string;
+action: string;
+}) => any;
+}, string, PublicProps, Readonly<UiModalInterface> & Readonly<{
+onModalAction?: ((T: {
+modal: string;
+action: string;
+}) => any) | undefined;
+}>, {
+loading: boolean;
+type: string;
+open: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+
+export declare interface UiModalEventsInterface {
+    /** emitted when a modal action is clicked, action emits: UiModalInterface["actions"]["value"] */
+    (e: 'modalAction', T: {
+        modal: UiModalInterface["modalName"];
+        action: string;
+    }): void;
+}
+
+export declare interface UiModalInterface {
+    /** modal title */
+    title: string;
+    /** actions array */
+    actions: {
+        /** value of the action */
+        value: string;
+        /** action literal */
+        name: string;
+    }[];
+    /** modal name */
+    modalName: string;
+    /** show modal or not */
+    open: boolean;
+    /** modal type */
+    type?: Types_2;
+    /** show skeleton */
+    loading?: boolean;
+}
+
+export declare const uiNoResults: DefineComponent<UiNoResultsInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+action: (T: string) => any;
+noResultsOptionSelected: (T: UiDropdownItemType_2) => any;
+}, string, PublicProps, Readonly<UiNoResultsInterface> & Readonly<{
+onAction?: ((T: string) => any) | undefined;
+onNoResultsOptionSelected?: ((T: UiDropdownItemType_2) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface UiNoResultsEventsInterface {
+    /** action button clicked */
+    (e: "action", T: string): void;
+    /** dropdown option selected */
+    (e: "noResultsOptionSelected", T: UiDropdownItemType): void;
+}
+
+export declare interface UiNoResultsInterface {
+    /** title string literal */
+    title: string;
+    /** message string literal */
+    message: string;
+    /** uiButtons array */
+    actions: {
+        /** action to emit when clicked */
+        action: string;
+        /** string literal */
+        text: string;
+    }[];
+    /** want to add more options, add items */
+    items: UiDropdownItemType[];
+    /** default selected item */
+    select: UiDropdownItemType;
+}
+
+export declare const uiNotification: DefineComponent<UiNotificationInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+closeNotification: () => any;
+}, string, PublicProps, Readonly<UiNotificationInterface> & Readonly<{
+onCloseNotification?: (() => any) | undefined;
+}>, {
+fixed: boolean;
+type: string;
+show: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiNotificationEventsInterface {
+    /** emitted when X icon is clicked */
+    (e: 'closeNotification'): void;
+}
+
+export declare interface UiNotificationInterface {
+    /** notification type */
+    type?: Types_2;
+    /** notification title */
+    title: string;
+    /** notification message */
+    message?: string;
+    /** not in use, only for DS purposes */
+    fixed: boolean;
+    /** show or not */
+    show: boolean;
+}
+
+export declare const uiPagination: __VLS_WithTemplateSlots_6<DefineComponent<UiPaginationInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+changePage: (T: number) => any;
+}, string, PublicProps, Readonly<UiPaginationInterface> & Readonly<{
+onChangePage?: ((T: number) => any) | undefined;
+}>, {
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+'test-first-button': HTMLButtonElement;
+'test-last-button': HTMLButtonElement;
+}, any>, {
+    previous?(_: {}): any;
+    previous?(_: {}): any;
+    next?(_: {}): any;
+    next?(_: {}): any;
+    showing?(_: {}): any;
+    of?(_: {}): any;
+}>;
+
+export declare interface UiPaginationEventsInterface {
+    /** emits when a button is clicked, emits a page number */
+    (e: "changePage", T: number): void;
+}
+
+export declare interface UiPaginationInterface {
+    /** current page number */
+    current: number;
+    /** total number of pages */
+    total: number;
+    /** show skeleton */
+    loading?: boolean;
+}
+
+export declare const uiPriceCalendar: DefineComponent<UiPriceCalendarInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+tableAction: (t: any) => any;
+dateChanged: (t: Date) => any;
+changeCategoryBulkPrices: () => any;
+changeCategorySelectionPrice: (t: UiRoomTypeSelectionPriceType) => any;
+changeCategoryUpgradePrice: (t: UiRoomTypeSelectionPriceType) => any;
+changeRoomPrice: (t: {
+price: UiRoomTypeSelectionPriceType;
+roomId: string;
+roomName: string;
+}) => any;
+}, string, PublicProps, Readonly<UiPriceCalendarInterface> & Readonly<{
+onTableAction?: ((t: any) => any) | undefined;
+onDateChanged?: ((t: Date) => any) | undefined;
+onChangeCategoryBulkPrices?: (() => any) | undefined;
+onChangeCategorySelectionPrice?: ((t: UiRoomTypeSelectionPriceType) => any) | undefined;
+onChangeCategoryUpgradePrice?: ((t: UiRoomTypeSelectionPriceType) => any) | undefined;
+onChangeRoomPrice?: ((t: {
+price: UiRoomTypeSelectionPriceType;
+roomId: string;
+roomName: string;
+}) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiPriceCalendarInterface {
+    /** show skeleton */
+    loading: boolean;
+    /** default starting date */
+    today: Date;
+    /** Is a prices table or a discounts table */
+    type: "prices" | "discounts";
+    /** currency information */
+    currency: {
+        /** currency name: ej "EUR" */
+        name: string;
+        /** currency symbol: ej "€" */
+        symbol: string;
+    };
+    /** listed default selection prices and upgrade prices for this category */
+    category: {
+        /** category name */
+        name: string;
+        /** array of selection prices based on date */
+        selectionPrices: {
+            date: Date;
+            price: number;
+        }[];
+        /** array of upgrade prices based on date */
+        upgradePrices: {
+            date: Date;
+            price: number;
+        }[];
+    };
+    /** listed rooms for this category with selection prices by date */
+    rooms: UiPriceCalendarRoomType[];
+    /** table actions based on row selections */
+    actions: {
+        /** action string literal */
+        name: string;
+        /** actino id */
+        id: string;
+    }[];
+    /** table literals check storybook */
+    literals: {
+        category: string;
+        changeInBulk: string;
+        pricesSelection: string;
+        pricesUpgrade: string;
+        room: string;
+        building: string;
+        floor: string;
+        pricesDiscount: string;
+    };
+}
+
+export declare type UiPriceCalendarRoomType = {
+    /** room id */
+    id: string;
+    /** room name */
+    name: string;
+    /** building the room is in */
+    building: string;
+    /** the floor the room is in */
+    floor: string;
+    /** selection prices for this room based on dates */
+    selectionPrices: UiRoomTypeSelectionPriceType[];
+};
+
+export declare interface UiPricesCalendarEventsInterface {
+    /** when a date button is clicked */
+    (e: 'dateChanged', t: Date): void;
+    /** click change category prices in bulk button */
+    (e: 'changeCategoryBulkPrices'): void;
+    /** click on category price */
+    (e: 'changeCategorySelectionPrice', t: UiRoomTypeSelectionPriceType): void;
+    /** click on category upgrade price */
+    (e: 'changeCategoryUpgradePrice', t: UiRoomTypeSelectionPriceType): void;
+    /** click on room price */
+    (e: 'changeRoomPrice', t: {
+        price: UiRoomTypeSelectionPriceType;
+        roomId: string;
+        roomName: string;
+    }): void;
+    /** click on table action */
+    (e: 'tableAction', t: any): void;
+}
+
+export declare const uiRangeSlider: DefineComponent<UiRangeSliderInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+sliderUpdated: (T: any) => any;
+}, string, PublicProps, Readonly<UiRangeSliderInterface> & Readonly<{
+onSliderUpdated?: ((T: any) => any) | undefined;
+}>, {
+disabled: boolean;
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface UiRangeSliderEventsInterface {
+    /** Whenever the slider is changed */
+    (e: "sliderUpdated", T: any): void;
+}
+
+export declare interface UiRangeSliderInterface {
+    /** Is loading or not */
+    loading: boolean;
+    /** Is disabled or not */
+    disabled?: boolean;
+    /** Min number of the range slider */
+    min?: number;
+    /** Max number of the range slider */
+    max?: number;
+    /** Actual value or range of values of the slider */
+    sliderValue?: number | number[];
+    /** Label in top of the slider */
+    label: string;
+    /** Text that appears top right side of the input field, that informs to user is a required field */
+    requiredText?: string;
+}
+
+export declare const uiRightSidebar: __VLS_WithTemplateSlots_7<DefineComponent<UiRightSidebarInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+closeRightBar: () => any;
+}, string, PublicProps, Readonly<UiRightSidebarInterface> & Readonly<{
+onCloseRightBar?: (() => any) | undefined;
+}>, {
+open: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+
+export declare interface UiRightSidebarEventsInterface {
+    /** emits when click outside bar or X icon */
+    (e: "closeRightBar"): void;
+}
+
+export declare interface UiRightSidebarInterface {
+    /** Sidebar title */
+    title?: string;
+    /** sidebar description or secondary text */
+    description?: string;
+    /** is sidebar open? */
+    open: boolean;
+}
+
+/** selection prices for this room based on dates */
+export declare type UiRoomTypeSelectionPriceType = {
+    date: Date;
+    price: number;
+};
+
+export declare const uiSectionTitle: DefineComponent<UiSectionTitleInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<UiSectionTitleInterface> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiSectionTitleInterface {
+    /** section title */
+    title: string;
+    /** section description */
+    description?: string;
+}
+
+export declare const uiSelect: DefineComponent<UiSelectInterface, {
+handleChange: (value: SelectItemType) => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+selectChanged: (T: SelectItemType) => any;
+}, string, PublicProps, Readonly<UiSelectInterface> & Readonly<{
+onSelectChanged?: ((T: SelectItemType) => any) | undefined;
+}>, {
+loading: boolean;
+color: "primary" | "secondary" | "light" | "green" | "yellow" | "red" | "black" | "gray" | "white";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiSelectEventsInterface {
+    /** When a item is selected */
+    (e: "selectChanged", T: SelectItemType): void;
+}
+
+export declare interface UiSelectInterface {
+    /** Array of items */
+    items: SelectItemType[];
+    /** Label in top of the Select */
+    label?: string;
+    /** Text below the input field that shows the error */
+    error?: string;
+    /** Color options (see type AllColors) */
+    color?: AllColors_2;
+    /** Selected item */
+    select: SelectItemType;
+    /** Is loading or not */
+    loading?: boolean;
+    /** Is disabled or not */
+    disabled?: boolean;
+    /** Text that appears top right side of the input field, that informs to user is a required field */
+    requiredText?: string;
+}
+
+export declare const uiSidebar: DefineComponent<UiSidebarInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+sideBarClick: (t: string) => any;
+}, string, PublicProps, Readonly<UiSidebarInterface> & Readonly<{
+onSideBarClick?: ((t: string) => any) | undefined;
+}>, {
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface UiSidebarEventsInterface {
+    /** emitted when a link is clicked, emits item id */
+    (e: 'sideBarClick', t: string): any;
+}
+
+export declare interface UiSidebarInterface {
+    /** navigation array */
+    navigation?: {
+        /** name string literal */
+        name: string;
+        /** icon component from Heroicons */
+        icon?: any;
+        /** is current sidebar item */
+        current?: boolean;
+        /** unique id */
+        id: string;
+        /** If item is parent, has children items */
+        children?: {
+            /** name string literal */
+            name: string;
+            /** unique id */
+            id: string;
+            /** is current sidebar item */
+            current?: boolean;
+        }[];
+    };
+    /** instead, can be a filters sidebar */
+    filterNavigation?: {
+        /** has search input on top */
+        hasSearch?: boolean;
+        /** search props */
+        search?: UiInputInterface;
+        /** check groups */
+        items?: {
+            /** check groups title */
+            label: string;
+            /** checkbox array */
+            filters: UiCheckboxInterface[];
+        }[];
+    };
+    /** is filter sidebar or navigation sidebar */
+    isFilterNavigation?: boolean;
+    /** show skeleton */
+    loading?: boolean;
+    /** sidebar brand logo */
+    logo?: string;
+}
+
+export declare const uiSidebarV2: DefineComponent<UiSidebarV2Interface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+sideBarClick: (t: string) => any;
+productBarClick: (t: string) => any;
+}, string, PublicProps, Readonly<UiSidebarV2Interface> & Readonly<{
+onSideBarClick?: ((t: string) => any) | undefined;
+onProductBarClick?: ((t: string) => any) | undefined;
+}>, {
+loading: boolean;
+isFilterNavigation: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface uiSidebarV2EventsInterface {
+    /** emits product name when clicked */
+    (e: 'productBarClick', t: string): void;
+    /** emitted when a link is clicked, emits item id */
+    (e: 'sideBarClick', t: string): void;
+}
+
+export declare interface UiSidebarV2Interface {
+    /** navigation array */
+    navigation?: {
+        /** name string literal */
+        name: string;
+        /** icon component from Heroicons */
+        icon?: any;
+        /** is current sidebar item */
+        current?: boolean;
+        /** unique id */
+        id: string;
+        /** If item is parent, has children items */
+        children?: {
+            /** name string literal */
+            name: string;
+            /** unique id */
+            id: string;
+            /** is current sidebar item */
+            current?: boolean;
+        }[];
+    };
+    /** instead, can be a filters sidebar */
+    filterNavigation?: {
+        /** has search input on top */
+        hasSearch?: boolean;
+        /** search props */
+        search?: UiInputInterface;
+        /** check groups */
+        items?: {
+            /** check groups title */
+            label: string;
+            /** checkbox array */
+            filters: UiCheckboxInterface[];
+        }[];
+    };
+    /** is filter sidebar or navigation sidebar */
+    isFilterNavigation?: boolean;
+    /** show skeleton */
+    loading?: boolean;
+    /** sidebar brand logo */
+    logo?: string;
+    /** left sidebar with product logos */
+    productsSidebar: {
+        name: string;
+        icon: any;
+        active?: boolean;
+    }[];
+}
+
+export declare const uiSmartFilter: DefineComponent<UiSmartFilterInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+rightAddOnClicked: () => any;
+smartFilterSelected: (T: {
+name: string;
+value: string;
+active?: boolean | undefined;
+}[]) => any;
+smartInputChanged: (T: InputType_2) => any;
+smartSelectChanged: (T: SelectItemType_2[]) => any;
+smartOptionSelected: (T: UiDropdownItemType_2) => any;
+}, string, PublicProps, Readonly<UiSmartFilterInterface> & Readonly<{
+onRightAddOnClicked?: (() => any) | undefined;
+onSmartFilterSelected?: ((T: {
+name: string;
+value: string;
+active?: boolean | undefined;
+}[]) => any) | undefined;
+onSmartInputChanged?: ((T: InputType_2) => any) | undefined;
+onSmartSelectChanged?: ((T: SelectItemType_2[]) => any) | undefined;
+onSmartOptionSelected?: ((T: UiDropdownItemType_2) => any) | undefined;
+}>, {
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface UiSmartFilterEventInterface {
+    /** when a filter is selected */
+    (e: 'smartFilterSelected', T: UiFilterInterface["items"]): void;
+    /** when an input is changed */
+    (e: 'smartInputChanged', T: InputType): void;
+    /** when a select is changed*/
+    (e: 'smartSelectChanged', T: UiSelectInterface["items"]): void;
+    /** when a dropdown option is selected */
+    (e: 'smartOptionSelected', T: UiDropdownItemType): void;
+    /** Right addon is clicked */
+    (e: "rightAddOnClicked"): void;
+}
+
+/** uiSmartFilter */
+export declare interface UiSmartFilterInterface {
+    /** Filter items */
+    items: {
+        /** item name */
+        name: string;
+        /** item value */
+        value: string;
+        /** is is selected or not */
+        active?: boolean;
+        /** for use in UiSmartFilter, it determines if input is a dropdown or input field */
+        type: "uiDropdowm" | "uiInput" | "uiSelect";
+        /** filter props based on componend being used */
+        props: UiInputInterface | UiDropdownInterface;
+    }[];
+    /** filter action literal */
+    buttonLiteral: string;
+    /** show skeleton */
+    loading?: boolean;
+}
+
+export declare const uiStats: DefineComponent<UiStatsInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+statClick: (T: string) => any;
+}, string, PublicProps, Readonly<UiStatsInterface> & Readonly<{
+onStatClick?: ((T: string) => any) | undefined;
+}>, {
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiStatsEventsInterface {
+    /** emits when actionText is clicked, emits item.id */
+    (e: "statClick", T: string): void;
+}
+
+export declare interface UiStatsInterface {
+    item: {
+        /** stat icon */
+        icon: any;
+        /** increase o decrease value ej: 122% */
+        change?: string;
+        /** change direction */
+        changeType?: "increase" | "decrease" | "neutral";
+        /** footer action link */
+        actionText?: string;
+        /** unique id */
+        id: string;
+        /** stats name */
+        name: string;
+        /** stat value */
+        stat: string | number;
+        /** helper text */
+        explanation?: string;
+        /** icon background color */
+        color?: AllColors_2;
+        /** show footer with action */
+        showFooter?: boolean;
+    };
+    /** show skeleton */
+    loading?: boolean;
+}
+
+export declare const uiStripedCard: DefineComponent<UiStripedCardInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+itemClicked: (T: string) => any;
+}, string, PublicProps, Readonly<UiStripedCardInterface> & Readonly<{
+onItemClicked?: ((T: string) => any) | undefined;
+}>, {
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiStripedCardEventsInterface {
+    /** emits when link is clicked, emits item emits */
+    (e: "itemClicked", T: string): void;
+}
+
+export declare interface UiStripedCardInterface {
+    /** card title */
+    title: string;
+    /** card subtitle */
+    subtitle: string;
+    /** array of card rows */
+    items: {
+        /** row title */
+        title: string;
+        /** row text */
+        text: string;
+        /** if link, when click, emits: */
+        emits: string;
+        /** row content, if undefined, the content is text */
+        type?: "link" | "tags";
+        /** if type tags, tags array */
+        tags?: UiTagInterface[];
+    }[];
+    /** show skeleton */
+    loading?: boolean;
+}
+
+export declare interface UiTabEventsInterface {
+    /** emits when a tab is clicked, emits tab id */
+    (e: "tabClicked", T: string): void;
+}
+
+export declare interface UiTabInterface {
+    /** tabs array */
+    tabs: {
+        /** tab string literal */
+        name: string;
+        /** tab unique id */
+        id: string;
+        /** tab count tag */
+        count?: number;
+        /** is current tag */
+        current?: boolean;
+    }[];
+}
+
+export declare const uiTable: DefineComponent<UiTableInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+tableAction: (T: {
+action: string;
+items: (string | number)[];
+}) => any;
+orderBy: (T: {
+value: string;
+orderDirection: "desc" | "asc";
+}) => any;
+customEmit: (T: {
+data: {
+content: string;
+type: string;
+emits: any;
+};
+}) => any;
+selectedItemsDeleted: () => any;
+}, string, PublicProps, Readonly<UiTableInterface> & Readonly<{
+onTableAction?: ((T: {
+action: string;
+items: (string | number)[];
+}) => any) | undefined;
+onOrderBy?: ((T: {
+value: string;
+orderDirection: "desc" | "asc";
+}) => any) | undefined;
+onCustomEmit?: ((T: {
+data: {
+content: string;
+type: string;
+emits: any;
+};
+}) => any) | undefined;
+onSelectedItemsDeleted?: (() => any) | undefined;
+}>, {
+loading: boolean;
+resetSelected: boolean;
+orderDirection: "desc" | "asc";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiTableEventsInterface {
+    /** if table action is clicked, emits selected rows ids */
+    (e: "tableAction", T: {
+        action: string;
+        items: Array<string | number>;
+    }): void;
+    /** emits header value and asc desc */
+    (e: "orderBy", T: {
+        value: string;
+        orderDirection: "desc" | "asc";
+    }): void;
+    /** if colum is link and has custom info */
+    (e: "customEmit", T: {
+        data: {
+            content: string;
+            type: string;
+            emits: any;
+        };
+    }): void;
+    /** emitted when resetSelected prop is sent with true, use it to rollback resetSelected to false */
+    (e: "selectedItemsDeleted"): void;
+}
+
+export declare interface UiTableInterface {
+    /** if you send this prop to the table with true it will reset all checked rows */
+    resetSelected: boolean;
+    /** header value the table is ordered */
+    orderedBy: string;
+    /** order direction */
+    orderDirection?: "asc" | "desc";
+    /** show skeleton */
+    loading?: boolean;
+    /** table header */
+    header: {
+        /** table column header name */
+        name: string;
+        /** table column header value, used for orders */
+        value: string;
+        /** tooltip string literal if needed */
+        tooltip?: string;
+    }[];
+    /** rows */
+    items: TableItemType[] | [];
+    /** when row is checked, available actions shows */
+    actions: {
+        /** action string literal */
+        name: string;
+        /** action id */
+        id: string;
+    }[];
+}
+
+export declare const uiTabs: DefineComponent<UiTabInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+tabClicked: (T: string) => any;
+}, string, PublicProps, Readonly<UiTabInterface> & Readonly<{
+onTabClicked?: ((T: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare const uiTag: __VLS_WithTemplateSlots_3<DefineComponent<UiTagInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+tagEvent: (T: string | undefined) => any;
+}, string, PublicProps, Readonly<UiTagInterface> & Readonly<{
+onTagEvent?: ((T: string | undefined) => any) | undefined;
+}>, {
+loading: boolean;
+size: "big" | "small" | "medium";
+color: "primary" | "secondary" | "light" | "green" | "yellow" | "red" | "black" | "gray" | "white";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+
+export declare interface UiTagEventsInterface {
+    /** When clicked, if props.event is defined. It emits the value of props.event */
+    (e: "tagEvent", T: UiTagInterface["event"]): void;
+}
+
+export declare interface UiTagInterface {
+    /** Color options (see type AllColors) */
+    color?: AllColors_2;
+    /** Is loading or not */
+    loading?: boolean;
+    /** Size options (see type Sizes) */
+    size?: Sizes_2;
+    /** If tag is clickable, this is the name of the event will be fired */
+    event?: string;
+    /** In uiCard, uiDeviceStatus, tag instead of slot uses name */
+    name?: string;
+    /** Tag text usually uses the slot, but there is some other components that needs the taxt text as a prop. You can use text instead of prop if needed */
+    text?: string;
+}
+
+export declare interface UiTaskList {
+    /** list of tasks */
+    tasks: TaskType[];
+    /** show skeleton */
+    loading?: boolean;
+}
+
+export declare const uiTaskList: DefineComponent<UiTaskList, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<UiTaskList> & Readonly<{}>, {
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare const uiTextArea: DefineComponent<UiTextAreaInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+inputChanged: (T: {
+name: string;
+value?: string | undefined;
+}) => any;
+}, string, PublicProps, Readonly<UiTextAreaInterface> & Readonly<{
+onInputChanged?: ((T: {
+name: string;
+value?: string | undefined;
+}) => any) | undefined;
+}>, {
+disabled: boolean;
+loading: boolean;
+color: "primary" | "secondary" | "light" | "green" | "yellow" | "red" | "black" | "gray" | "white";
+placeholder: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiTextAreaEventsInterface {
+    /** Whenever text area value changes is emitted */
+    (e: "inputChanged", T: {
+        name: string;
+        value?: string;
+    }): void;
+}
+
+export declare interface UiTextAreaInterface {
+    /** Name of the text area */
+    name: string;
+    /** Label in top of the text area */
+    label: string;
+    /** Placeholder of the text area */
+    placeholder?: string;
+    /** Value (text) of the text area */
+    value?: string;
+    /** Color options (see type Colors) */
+    color?: AllColors_2;
+    /** Is disabled or not */
+    disabled?: boolean;
+    /** Text below the text area that shows the error */
+    error?: string;
+    /** Is loading or not */
+    loading?: boolean;
+    /** Text that appears top right side of the text area, that informs to user is a required field */
+    requiredText?: string;
+}
+
+export declare const uiTimeline: DefineComponent<UiTimelineInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+timelineEventClicked: (t: string | number) => any;
+timelineFooterClicked: (t: string) => any;
+}, string, PublicProps, Readonly<UiTimelineInterface> & Readonly<{
+onTimelineEventClicked?: ((t: string | number) => any) | undefined;
+onTimelineFooterClicked?: ((t: string) => any) | undefined;
+}>, {
+loading: boolean;
+empty: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiTimelineEventsInterface {
+    /** when a timeline event is clicked, emits item id */
+    (e: 'timelineEventClicked', t: string | number): void;
+    /** emits when footer link is clicked */
+    (e: 'timelineFooterClicked', t: string): void;
+}
+
+export declare interface UiTimelineInterface {
+    /** timeline title */
+    name: string;
+    /** items */
+    timeline: {
+        /** timeline unique id */
+        id: string;
+        /** timeline footer literal */
+        footerText: string;
+        /** items array */
+        items: {
+            /** row id */
+            id: number | string;
+            /** link id */
+            linkId: number | string;
+            /** row text */
+            content: string;
+            /** item name, reference.. */
+            target: string;
+            /** target link */
+            href: string;
+            /** event date */
+            date: string;
+            /** event formatted date */
+            datetime: string;
+            /** event icon */
+            icon: any;
+            /** event icon background color */
+            iconBackground: string;
+        }[];
+    };
+    /** if custom height in px */
+    height?: number;
+    /** is timeline empty */
+    empty?: boolean;
+    /** show skeleton */
+    loading?: boolean;
+}
+
+export declare const uiToggle: DefineComponent<UiToggleInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+toggleChanged: (T: {
+item: {
+title: string;
+subtitle?: string | undefined;
+active?: boolean | undefined;
+action: string;
+};
+active: boolean;
+}) => any;
+actionClicked: (item: {
+title: string;
+subtitle?: string | undefined;
+active?: boolean | undefined;
+action: string;
+}) => any;
+}, string, PublicProps, Readonly<UiToggleInterface> & Readonly<{
+onToggleChanged?: ((T: {
+item: {
+title: string;
+subtitle?: string | undefined;
+active?: boolean | undefined;
+action: string;
+};
+active: boolean;
+}) => any) | undefined;
+onActionClicked?: ((item: {
+title: string;
+subtitle?: string | undefined;
+active?: boolean | undefined;
+action: string;
+}) => any) | undefined;
+}>, {
+disabled: boolean;
+loading: boolean;
+checked: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiToggleEventsInterface {
+    /** emitted when toggle is changed */
+    (e: 'toggleChanged', T: {
+        item: UiToggleInterface["item"];
+        active: boolean;
+    }): void;
+    /** emitted when right action is clicked */
+    (e: 'actionClicked', item: UiToggleInterface["item"]): void;
+}
+
+export declare interface UiToggleInterface {
+    /** Toggle item that contains title, subtitle, if it´s active or not, and the action */
+    item: {
+        title: string;
+        subtitle?: string;
+        active?: boolean;
+        action: string;
+    };
+    /** Is checked or not */
+    checked?: boolean;
+    /** Is disabled or not */
+    disabled?: boolean;
+    /** Is loading or not */
+    loading: boolean;
+}
+
+export declare const uiTopbar: DefineComponent<UiTopbarInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+topBarClick: (T: string) => any;
+}, string, PublicProps, Readonly<UiTopbarInterface> & Readonly<{
+onTopBarClick?: ((T: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface UiTopbarEventsInterface {
+    /** when clicked in any menu item */
+    (e: "topBarClick", T: string): void;
+}
+
+export declare interface UiTopbarInterface {
+    /** brand logo */
+    logo: string;
+    /** show alert icon */
+    alerted: boolean;
+    /** sub brand logo */
+    accountLogo: string;
+    /** profile menu of sub brand */
+    profileMenu?: {
+        name: string;
+        id: string;
+    }[];
+    /** brand name and description */
+    brand?: {
+        title: string;
+        subtitle: string;
+    };
+    /** when mobile, this is the sidebar navigation menu */
+    navigation?: UiSidebarV2Interface["navigation"];
+}
+
+export declare const uiWrapper: __VLS_WithTemplateSlots_8<DefineComponent<UiWrapperInterface, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+selectChanged: (T: SelectItemType) => any;
+sideBarClick: (t: string) => any;
+productBarClick: (t: string) => any;
+topBarClick: (T: string) => any;
+}, string, PublicProps, Readonly<UiWrapperInterface> & Readonly<{
+onSelectChanged?: ((T: SelectItemType) => any) | undefined;
+onSideBarClick?: ((t: string) => any) | undefined;
+onProductBarClick?: ((t: string) => any) | undefined;
+onTopBarClick?: ((T: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>, {
+    default?(_: {}): any;
+}>;
+
+export declare interface UiWrapperEventsInterface {
+    /** emits product name when clicked */
+    (e: 'productBarClick', t: string): void;
+    /** emitted when a link is clicked, emits item id */
+    (e: 'sideBarClick', t: string): void;
+    /** When an item is selected */
+    (e: "selectChanged", T: SelectItemType): void;
+    /** when clicked in any menu item */
+    (e: "topBarClick", T: string): void;
+}
+
+export declare interface UiWrapperInterface {
+    topbar: {
+        /** product logo */
+        logo: string;
+        /** is an alert */
+        alerted?: boolean;
+        /** brand logo */
+        accountLogo?: string;
+        /** brand profile menu */
+        profileMenu?: {
+            name: string;
+            id: string;
+        }[];
+        /** top bar search items */
+        selectItems: SelectItemType[];
+        /** top bar search selected item */
+        selectedItem: SelectItemType;
+    };
+    /** wrapper sidebar */
+    sidebar: UiSidebarV2Interface;
+}
+
+export { }