@hotelinking/ui 10.42.12 → 10.42.13

package/dist/types/index.d.ts

@@ -0,0 +1,1183 @@
+import { FunctionalComponent } from 'vue';
+export declare const Colors: readonly ["primary", "secondary", "light", "green", "yellow", "red"];
+export declare const UiInputTypes: readonly ["text", "email", "password", "number", "date", "datetime-local"];
+export declare const MonoColors: readonly ["black", "gray", "white"];
+export declare const AllColors: readonly ["primary", "secondary", "light", "green", "yellow", "red", "black", "gray", "white"];
+export declare const Sizes: readonly ["small", "medium", "big"];
+export declare const BiggerSizes: readonly ["bigger", "huge", "massive"];
+export declare const AllSizes: readonly ["small", "medium", "big", "bigger", "huge", "massive"];
+export declare const Types: string[];
+type Colors = typeof Colors[number];
+type AllColors = typeof AllColors[number];
+type InputTypes = typeof UiInputTypes[number];
+type Sizes = typeof Sizes[number];
+type AllSizes = typeof AllSizes[number];
+type Types = typeof Types[number];
+export interface UiButtonInterface {
+    /** Defines if button as block class applied or not */
+    block?: boolean;
+    /** Color options (see type Colors) */
+    color?: Colors;
+    /** 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;
+}
+export 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 interface UiCheckboxEventsInterface {
+    /** Emitted when click over checkbox */
+    (e: 'checkboxChanged', checkbox: UiCheckboxType): void;
+}
+export type UiCheckboxType = {
+    /** Is checked or not */
+    checked: boolean;
+    /** Internal value of checkbox */
+    value: string;
+};
+export 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 interface UiDropdownEventsInterface {
+    /** On option selected */
+    (e: 'optionSelected', v: UiDropdownItemType): void;
+}
+export type UiDropdownItemType = {
+    /** Name of item */
+    name: string;
+    /** Value of item */
+    value: string;
+    /** Is it active or not */
+    active?: boolean;
+};
+export interface UiIconInterface {
+    /** Imported icon from '@heroicons/vue/24/outline' */
+    icon: FunctionalComponent;
+    /** Size options (see type AllSizes) */
+    size?: AllSizes;
+    /** Color options (see type AllColors) */
+    color?: AllColors;
+    /** Is loading or not */
+    loading: boolean;
+}
+export 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;
+    /** 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 interface UiInputEventsInterface {
+    /** Whenever the input changes */
+    (e: "inputChanged", T: InputType): void;
+    /** Right addon is clicked */
+    (e: "rightAddOnClicked"): void;
+    /** Addon clicked */
+    (e: "addOnClicked"): void;
+}
+export type InputType = {
+    /** Name of the input field */
+    name: string;
+    /** Internal value of input field */
+    value: string;
+};
+export 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 type FileInputType = {
+    /** Id of the input field */
+    id: string;
+    /** Uploaded files */
+    files: any;
+};
+export interface UiInputFileEventsInterface {
+    /** Whenever files are dragged inside input field, or send the default way */
+    (e: "filesUploaded", T: FileInputType): void;
+}
+export 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 interface UiRangeSliderEventsInterface {
+    /** Whenever the slider is changed */
+    (e: "sliderUpdated", T: any): void;
+}
+export 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;
+    /** 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 interface UiSelectEventsInterface {
+    /** When a item is selected */
+    (e: "selectChanged", T: SelectItemType): void;
+}
+export type SelectItemType = {
+    /** Unique value inside the select */
+    id: string;
+    /** Name of the item */
+    name: string;
+};
+export interface UiTagInterface {
+    /** Color options (see type AllColors) */
+    color?: AllColors;
+    /** Is loading or not */
+    loading?: boolean;
+    /** Size options (see type Sizes) */
+    size?: Sizes;
+    /** 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 interface UiTagEventsInterface {
+    /** When clicked, if props.event is defined. It emits the value of props.event */
+    (e: "tagEvent", T: UiTagInterface["event"]): void;
+}
+export 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;
+    /** 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 interface UiTextAreaEventsInterface {
+    /** Whenever text area value changes is emitted */
+    (e: "inputChanged", T: {
+        name: string;
+        value?: string;
+    }): void;
+}
+export 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 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 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 interface UiAlertEventsInterface {
+    /** When an alert action is clicked emits UiAlertInterface["actions"]["event"] */
+    (e: 'alertEvent', T: string): void;
+}
+export 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 interface UiBreadcrumbsEventInterface {
+    /** emits UiBreadcrumbsInterface["pages"]["routeName"] when a breadcrumb is clicked */
+    (e: 'breadCrumbClicked', T: string): void;
+}
+export 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 interface UiCardEventsInterface {
+    /** Emits when card is clicked */
+    (e: 'cardSelected', T: {
+        id: UiCardInterface["id"];
+        name: UiCardInterface["name"];
+        type: UiCardInterface["type"];
+        tags: UiCardInterface["tags"];
+    }): void;
+}
+export interface UiDeviceStatusInterface {
+    /** device id */
+    id: string;
+    /** device name */
+    name: string;
+    /** icon component from Heroicons */
+    icon: any;
+    /** icon background color */
+    color: AllColors;
+    /** device quantity */
+    qty: number;
+    /** tags array */
+    tags?: UiTagInterface[];
+    /** show skeleton */
+    loading: boolean;
+}
+export 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 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 interface UiFilterEventsInterface {
+    /** emits UiFilterInterface["items"]["value"] when filter is selected */
+    (e: 'filterSelected', T: string): void;
+}
+/** uiSmartFilter */
+export 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 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;
+}
+export 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;
+    /** show skeleton */
+    loading?: boolean;
+}
+export interface UiModalEventsInterface {
+    /** emitted when a modal action is clicked, action emits: UiModalInterface["actions"]["value"] */
+    (e: 'modalAction', T: {
+        modal: UiModalInterface["modalName"];
+        action: string;
+    }): void;
+}
+export interface UiNotificationInterface {
+    /** notification type */
+    type?: Types;
+    /** notification title */
+    title: string;
+    /** notification message */
+    message?: string;
+    /** not in use, only for DS purposes */
+    fixed: boolean;
+    /** show or not */
+    show: boolean;
+}
+export interface UiNotificationEventsInterface {
+    /** emitted when X icon is clicked */
+    (e: 'closeNotification'): void;
+}
+export interface UiSectionTitleInterface {
+    /** section title */
+    title: string;
+    /** section description */
+    description?: string;
+}
+export 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 interface UiTaskList {
+    /** list of tasks */
+    tasks: TaskType[];
+    /** show skeleton */
+    loading?: boolean;
+}
+export 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 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 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 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;
+    /** 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 interface UiDateRangeEventsInterface {
+    /** emitted when date range button is clicked */
+    (e: 'uiDateRangeButtonClicked', t: UiDateRangeInterface["values"] | undefined): void;
+}
+export interface UiDragAndDropInterface {
+    /** drag and drop array of elements */
+    elements: {
+        id: number;
+        name: string;
+        description: string;
+    }[];
+    /** show skeleton */
+    loading?: boolean;
+}
+export interface UiDragAndDropEventsInterface {
+    /** emitted when drag and drop elements are updated (dragged)*/
+    (e: "dragAndDropUpdated", T: any): void;
+}
+export 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 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 interface UiLoadScreenInterface {
+    /** title string */
+    title?: string;
+    /** message string */
+    message?: string;
+    /** not in use, only for DS purposes */
+    fixed?: boolean;
+}
+export 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 interface UiNoResultsEventsInterface {
+    /** action button clicked */
+    (e: "action", T: string): void;
+    /** dropdown option selected */
+    (e: "noResultsOptionSelected", T: UiDropdownItemType): void;
+}
+export interface UiPaginationInterface {
+    /** current page number */
+    current: number;
+    /** total number of pages */
+    total: number;
+    /** show skeleton */
+    loading?: boolean;
+}
+export interface UiPaginationEventsInterface {
+    /** emits when a button is clicked, emits a page number */
+    (e: "changePage", T: number): void;
+}
+export interface UiRightSidebarInterface {
+    /** Sidebar title */
+    title?: string;
+    /** sidebar description or secondary text */
+    description?: string;
+    /** is sidebar open? */
+    open: boolean;
+}
+export interface UiRightSidebarEventsInterface {
+    /** emits when click outside bar or X icon */
+    (e: "closeRightBar"): void;
+}
+export 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 interface UiSidebarEventsInterface {
+    /** emitted when a link is clicked, emits item id */
+    (e: 'sideBarClick', t: string): any;
+}
+export 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 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 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;
+        /** show footer with action */
+        showFooter?: boolean;
+    };
+    /** show skeleton */
+    loading?: boolean;
+}
+export interface UiStatsEventsInterface {
+    /** emits when actionText is clicked, emits item.id */
+    (e: "statClick", T: string): void;
+}
+export 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 interface UiStripedCardEventsInterface {
+    /** emits when link is clicked, emits item emits */
+    (e: "itemClicked", T: string): void;
+}
+export 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;
+        /** 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 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 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 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 interface UiTabEventsInterface {
+    /** emits when a tab is clicked, emits tab id */
+    (e: "tabClicked", T: string): void;
+}
+export 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 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 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 interface UiTopbarEventsInterface {
+    /** when clicked in any menu item */
+    (e: "topBarClick", T: string): void;
+}
+export 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 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 interface UiDynamicStatsInterface {
+    /** uiStat Array */
+    dynamicStats: UiStatsInterface["item"][];
+    /** show skeleton */
+    loading: boolean;
+}
+export 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 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[];
+};
+/** selection prices for this room based on dates */
+export type UiRoomTypeSelectionPriceType = {
+    date: Date;
+    price: number;
+};
+export 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 {};