@finmars/ui 1.0.52 → 1.0.55

package/dist/src/components/fm/Chip/Chip.vue.d.ts

@@ -1,18 +1,26 @@
 import { FmChipProps, FmChipSlots } from './types';
 declare function __VLS_template(): {
     slots: Readonly<FmChipSlots> & FmChipSlots;
-    refs: {};
+    refs: {
+        chipEl: HTMLDivElement;
+    };
     attrs: Partial<{}>;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<FmChipProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    click: (value: MouseEvent) => any;
+    click: (value: {
+        event: MouseEvent;
+        element: HTMLDivElement;
+    }) => any;
     "click:prepend": (value: MouseEvent) => any;
     "click:append": (value: MouseEvent) => any;
     "click:close": (value: MouseEvent) => any;
     keydown: (value: KeyboardEvent) => any;
 }, string, import('vue').PublicProps, Readonly<FmChipProps> & Readonly<{
-    onClick?: ((value: MouseEvent) => any) | undefined;
+    onClick?: ((value: {
+        event: MouseEvent;
+        element: HTMLDivElement;
+    }) => any) | undefined;
     "onClick:prepend"?: ((value: MouseEvent) => any) | undefined;
     "onClick:append"?: ((value: MouseEvent) => any) | undefined;
     "onClick:close"?: ((value: MouseEvent) => any) | undefined;

package/dist/src/components/fm/Chip/types.d.ts

@@ -1,6 +1,7 @@
 import { VNode } from 'vue';
 import { FmComponentIcon, PlaceLocation } from '../../../types';
 export interface FmChipProps {
+    id?: string;
     value?: string;
     tooltip?: string | {
         value: string;
@@ -18,7 +19,10 @@ export interface FmChipProps {
     disabled?: boolean;
 }
 export interface FmChipEmits {
-    (event: 'click', value: MouseEvent): void;
+    (event: 'click', value: {
+        event: MouseEvent;
+        element: HTMLDivElement;
+    }): void;
     (event: 'click:prepend', value: MouseEvent): void;
     (event: 'click:append', value: MouseEvent): void;
     (event: 'click:close', value: MouseEvent): void;

package/dist/src/components/fm/DateEditor/DateEditor.vue.d.ts

@@ -2,10 +2,14 @@ import { FmDateEditorProps } from './types';
 declare const _default: import('vue').DefineComponent<FmDateEditorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     "update:modelValue": (value: string) => any;
     "click:dateIcon": () => any;
+    cancel: () => any;
 }, string, import('vue').PublicProps, Readonly<FmDateEditorProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
     "onClick:dateIcon"?: (() => any) | undefined;
+    onCancel?: (() => any) | undefined;
 }>, {
+    erroneousDates: string[];
+    nonWorkingDays: string[];
     locals: {
         enteringFieldLabel: string;
         enteringFieldPlaceholder: string;

package/dist/src/components/fm/DateEditor/constants.d.ts

@@ -1,2 +1 @@
 export declare const datesInMonth: Record<string, [number, number]>;
-export declare const displayingDateFormat = "YYYY-MM-DD";

package/dist/src/components/fm/DateEditor/types.d.ts

@@ -3,10 +3,12 @@ export interface FmDateEditorProps {
     min?: string;
     max?: string;
     nonWorkingDays?: string[];
+    erroneousDates?: string[];
     allowWeekendSelection?: boolean;
-    showWeek?: boolean;
     showAdjacentMonths?: boolean;
     calculatePreviousDayFromToday?: boolean;
+    includeTime?: boolean;
+    simple?: boolean;
     disabled?: boolean;
     locals?: {
         enteringFieldLabel: string;
@@ -21,4 +23,5 @@ export interface FmDateEditorProps {
 export interface FmDateEditorEmits {
     (event: 'update:modelValue', value: string): void;
     (event: 'click:dateIcon'): void;
+    (event: 'cancel'): void;
 }

package/dist/src/components/fm/DateEditor/useDateEditor.d.ts

@@ -1,11 +1,13 @@
-import { Dayjs } from 'dayjs';
 import { FmDateEditorEmits, FmDateEditorProps } from './types';
 export default function useDateEditor(props: FmDateEditorProps, emits: FmDateEditorEmits): {
+    DATE_FORMAT: string;
+    TIME_FORMAT: string;
     currentMenuItem: import('vue').Ref<string, string>;
     initialValue: import('vue').Ref<string, string>;
     innerValue: import('vue').Ref<string, string>;
+    initialTime: import('vue').Ref<string, string>;
+    innerTime: import('vue').Ref<string, string>;
     textFieldInput: import('vue').Ref<string | null, string | null>;
-    allowedDates: (val: Dayjs | string, ignoreWeekends?: boolean) => boolean;
     selectMenuItem: (item: "today" | "previous") => void;
     onUpdate: (val: string) => void;
     onUpdateByKeyboard: (val: string) => void;

package/dist/src/components/fm/DatePicker/DatePicker.vue.d.ts

@@ -1,40 +1,13 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "update:modelValue" | "update:month" | "update:year" | "update:viewMode", ...args: any[]) => void;
-    disabled: boolean;
-    showHeader: boolean;
-    showWeek: boolean;
+import { FmDatePickerProps } from './types';
+declare const _default: import('vue').DefineComponent<FmDatePickerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<FmDatePickerProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    max: string;
+    min: string;
+    nonSelectableDates: string[];
+    erroneousDates: string[];
     showAdjacentMonths: boolean;
-    border: boolean;
-    minWidth?: string | number | undefined;
-    modelValue?: string | undefined;
-    height?: string | number | undefined;
-    width?: string | number | undefined;
-    maxHeight?: string | number | undefined;
-    maxWidth?: string | number | undefined;
-    minHeight?: string | number | undefined;
-    header?: string | undefined;
-    title?: string | undefined;
-    max?: string | undefined;
-    min?: string | undefined;
-    allowedDates?: Function | unknown[] | undefined;
-    $props: {
-        readonly disabled?: boolean | undefined;
-        readonly showHeader?: boolean | undefined;
-        readonly showWeek?: boolean | undefined;
-        readonly showAdjacentMonths?: boolean | undefined;
-        readonly border?: boolean | undefined;
-        readonly minWidth?: string | number | undefined;
-        readonly modelValue?: string | undefined;
-        readonly height?: string | number | undefined;
-        readonly width?: string | number | undefined;
-        readonly maxHeight?: string | number | undefined;
-        readonly maxWidth?: string | number | undefined;
-        readonly minHeight?: string | number | undefined;
-        readonly header?: string | undefined;
-        readonly title?: string | undefined;
-        readonly max?: string | undefined;
-        readonly min?: string | undefined;
-        readonly allowedDates?: Function | unknown[] | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/src/components/fm/DatePicker/YearMonthPicker.vue.d.ts

@@ -0,0 +1,12 @@
+import { FmYearMonthPickerProps } from './types';
+declare const _default: import('vue').DefineComponent<FmYearMonthPickerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:year": (value: number) => any;
+    "update:month": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<FmYearMonthPickerProps> & Readonly<{
+    "onUpdate:year"?: ((value: number) => any) | undefined;
+    "onUpdate:month"?: ((value: number) => any) | undefined;
+}>, {
+    minYear: number;
+    maxYear: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/fm/DatePicker/types.d.ts

@@ -0,0 +1,32 @@
+export type DatePickerDate = {
+    dateISO: string;
+    date: number;
+    day: number;
+    disabled?: boolean;
+    erroneous?: boolean;
+};
+export interface FmDatePickerProps {
+    modelValue: string;
+    min?: string;
+    max?: string;
+    nonSelectableDates?: string[];
+    erroneousDates?: string[];
+    canWeekendsBeSelected?: boolean;
+    showAdjacentMonths?: boolean;
+    border?: boolean;
+    disabled?: boolean;
+}
+export interface FmDatePickerEmits {
+    (event: 'update:modelValue', value: string): void;
+}
+export interface FmYearMonthPickerProps {
+    year: number;
+    month: number;
+    minYear?: number;
+    maxYear?: number;
+    disabled?: boolean;
+}
+export interface FmYearMonthPickerEmits {
+    (event: 'update:year', value: number): void;
+    (event: 'update:month', value: number): void;
+}

package/dist/src/components/fm/DatePicker/utils.d.ts

@@ -0,0 +1,17 @@
+import { default as dayjs } from 'dayjs';
+import { DatePickerDate } from './types';
+export declare const DATE_FORMAT = "YYYY-MM-DD";
+export declare function transformIsoDateToObject(value: string): {
+    year: number;
+    month: number;
+    date: number | null;
+};
+export declare function getDaysOfWeek(): string[];
+export declare function getMonths(): dayjs.MonthNames;
+export declare function getYearList(min?: number, max?: number): number[];
+export declare function getWeekNumber(date: string): number;
+export declare function getMonthDayList(year: number, month: number): {
+    current: (DatePickerDate | null)[];
+    prev: (DatePickerDate | null)[];
+    next: (DatePickerDate | null)[];
+};

package/dist/src/components/fm/DateTree/DateTree.vue.d.ts

@@ -0,0 +1,9 @@
+import { FmDateTreeProps } from './types';
+declare const _default: import('vue').DefineComponent<FmDateTreeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string[]) => any;
+}, string, import('vue').PublicProps, Readonly<FmDateTreeProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+}>, {
+    modelValue: string[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/fm/DateTree/DateTreeItem.vue.d.ts

@@ -0,0 +1,9 @@
+import { FmDateTreeItemProps } from './types';
+declare const _default: import('vue').DefineComponent<FmDateTreeItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (value: MouseEvent) => any;
+    select: (value: import('./types').DateTreeItem) => any;
+}, string, import('vue').PublicProps, Readonly<FmDateTreeItemProps> & Readonly<{
+    onClick?: ((value: MouseEvent) => any) | undefined;
+    onSelect?: ((value: import('./types').DateTreeItem) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/fm/DateTree/types.d.ts

@@ -0,0 +1,24 @@
+export type DateTreeItemSelectedStatus = 'selected' | 'unselected' | 'partially';
+export type DateTreeItem = {
+    title: string;
+    value: number;
+    level: number;
+    selectedStatus: DateTreeItemSelectedStatus;
+    isOpened?: boolean;
+    children?: Array<DateTreeItem>;
+};
+export interface FmDateTreeProps {
+    modelValue: string[];
+    data: string[];
+    includeTime?: boolean;
+}
+export interface FmDateTreeEmits {
+    (event: 'update:modelValue', value: string[]): void;
+}
+export interface FmDateTreeItemProps {
+    item: DateTreeItem;
+}
+export interface FmDateTreeItemEmits {
+    (event: 'click', value: MouseEvent): void;
+    (event: 'select', value: DateTreeItem): void;
+}

package/dist/src/components/fm/DateTree/utils.d.ts

@@ -0,0 +1,33 @@
+import { DateTreeItem } from './types';
+export declare function parseDate(value: string): {
+    year: number;
+    month: number;
+    date: number;
+    hours: number;
+    minutes: number;
+    time: number;
+};
+export declare function getYearIndexInDateTree({ tree, year }: {
+    tree: DateTreeItem[];
+    year: number;
+}): number;
+export declare function getMonthIndexInDateTree({ tree, month, yearIndex }: {
+    tree: DateTreeItem[];
+    month: number;
+    yearIndex: number;
+}): number;
+export declare function getDateIndexInDateTree({ tree, date, yearIndex, monthIndex }: {
+    tree: DateTreeItem[];
+    date: number;
+    yearIndex: number;
+    monthIndex: number;
+}): number;
+export declare function getTimeIndexInDateTree({ tree, time, yearIndex, monthIndex, dateIndex, includeTime }: {
+    tree: DateTreeItem[];
+    time: number;
+    yearIndex: number;
+    monthIndex: number;
+    dateIndex: number;
+    includeTime?: boolean;
+}): number;
+export declare function makeDateTree(data?: string[], includeTime?: boolean): DateTreeItem[];

package/dist/src/components/fm/Dialog/Dialog.vue.d.ts

@@ -0,0 +1,24 @@
+import { Component } from 'vue';
+import { FmDialogComponentProps, FmDialogComponentEmits } from './types';
+declare const _default: <T extends Component>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onClose?: ((value?: unknown) => any) | undefined;
+        readonly onCancel?: ((value?: unknown) => any) | undefined;
+        readonly onOpen?: ((value?: unknown) => any) | undefined;
+        readonly onConfirm?: ((value?: unknown) => any) | undefined;
+        readonly "onBefore-close"?: ((value?: unknown) => any) | undefined;
+        readonly "onClick-overlay"?: ((value?: unknown) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onCancel" | "onClose" | "onOpen" | "onConfirm" | "onBefore-close" | "onClick-overlay"> & FmDialogComponentProps<T>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: FmDialogComponentEmits;
+}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/src/components/fm/Dialog/types.d.ts

@@ -0,0 +1,37 @@
+import { Component } from 'vue';
+import { ExtractComponentProps } from '../../../types';
+export type FmDialogEvent = 'open' | 'before-close' | 'close' | 'confirm' | 'cancel' | 'click-overlay';
+export interface FmDialogProps {
+    id?: string;
+    teleport?: string;
+    title?: string;
+    width?: string | number;
+    draggable?: boolean;
+    cssClass?: string[];
+    cssStyle?: Record<string, string>;
+    contentCssClass?: string[];
+    contentCssStyle?: Record<string, string>;
+    confirmButton?: boolean;
+    cancelButton?: boolean;
+    onClose?: () => void;
+    onConfirm?: (data: unknown) => void;
+    onCancel?: (data: unknown) => void;
+    confirmButtonText?: string;
+    cancelButtonText?: string;
+    confirmButtonType?: 'primary' | 'secondary' | 'tertiary';
+    cancelButtonType?: 'primary' | 'secondary' | 'tertiary';
+    closeOnClickOverlay?: boolean;
+}
+export interface FmDialogComponentProps<T extends Component> {
+    component: T;
+    componentProps?: ExtractComponentProps<T>;
+    dialogProps?: FmDialogProps;
+}
+export interface FmDialogComponentEmits {
+    (event: 'open', value?: unknown): void;
+    (event: 'before-close', value?: unknown): void;
+    (event: 'close', value?: unknown): void;
+    (event: 'confirm', value?: unknown): void;
+    (event: 'cancel', value?: unknown): void;
+    (event: 'click-overlay', value?: unknown): void;
+}

package/dist/src/components/fm/FileUpload/types.d.ts

@@ -11,6 +11,6 @@ export interface FmFileUploadProps extends FmDialogOptions {
     icon?: string;
     variant?: 'normal' | 'large';
     label?: string;
-    multiple: boolean;
-    indeterminate: boolean;
+    multiple?: boolean;
+    indeterminate?: boolean;
 }

package/dist/src/components/fm/Filters/FilterTypes/DatetimeFilter/DatetimeFilter.vue.d.ts

@@ -6,9 +6,9 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<FmFilterProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    update: (value: import('../../../../..').FmFilter) => any;
+    update: (value: import('../../../../../types').FmFilter) => any;
 }, string, import('vue').PublicProps, Readonly<FmFilterProps> & Readonly<{
-    onUpdate?: ((value: import('../../../../..').FmFilter) => any) | undefined;
+    onUpdate?: ((value: import('../../../../../types').FmFilter) => any) | undefined;
 }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/src/components/fm/Filters/FilterTypes/TextFilter/TextFilter.vue.d.ts

@@ -11,7 +11,7 @@ declare const __VLS_component: import('vue').DefineComponent<FmFilterProps, {},
 }, string, import('vue').PublicProps, Readonly<FmFilterProps> & Readonly<{
     onUpdate?: ((value: import('../../../../..').FmFilter) => any) | undefined;
 }>, {
-    options: FmSelectOption[];
+    options: FmSelectOption[] | string[];
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/src/components/fm/Filters/types.d.ts

@@ -4,7 +4,7 @@ import { FmSelectOption } from '../Select/types';
 export interface FmFilterProps {
     filter: FmFilter;
     filterValue: string | string[] | number | number[] | boolean | boolean[] | FmFilterRangeValues;
-    options?: FmSelectOption[];
+    options?: FmSelectOption[] | string[];
     isFilterLinked?: boolean;
 }
 export interface FmFilterEmits {

package/dist/src/components/fm/InputDate/InputDate.vue.d.ts

@@ -7,6 +7,5 @@ declare const _default: import('vue').DefineComponent<FmInputDateProps, {}, {},
     modelValue: string;
     showAdjacentMonths: boolean;
     allowWeekendSelection: boolean;
-    dateFormat: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/src/components/fm/InputDate/types.d.ts

@@ -1,10 +1,13 @@
 export interface FmInputDateProps {
     modelValue?: string;
+    min?: string;
+    max?: string;
+    includeTime?: boolean;
+    simplePicker?: boolean;
     compact?: boolean;
     label?: string;
     placeholder?: string;
     persistentPlaceholder?: boolean;
-    dateFormat?: string;
     showAdjacentMonths?: boolean;
     allowWeekendSelection?: boolean;
     disabled?: boolean;

package/dist/src/components/fm/InputTime/InputTime.vue.d.ts

@@ -0,0 +1,7 @@
+import { FmInputTimeProps } from './types';
+declare const _default: import('vue').DefineComponent<FmInputTimeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<FmInputTimeProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/fm/InputTime/types.d.ts

@@ -0,0 +1,12 @@
+export interface FmInputTimeProps {
+    modelValue: string;
+    label?: string;
+    placeholder?: string;
+    persistentPlaceholder?: boolean;
+    minutesStep?: 1 | 2 | 5 | 10 | 15 | 20 | 30;
+    size?: number;
+    disabled?: boolean;
+}
+export interface FmInputTimeEmits {
+    (event: 'update:modelValue', value: string): void;
+}

package/dist/src/components/fm/ItemPicker/ItemPickerContent/ItemPickerContent.vue.d.ts

@@ -10,5 +10,8 @@ declare const _default: import('vue').DefineComponent<FmItemPickerContentProps,
         suggested: string;
         selected: string;
     };
+    selected: string[];
+    suggested: string[];
+    initialSelected: string[];
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/src/components/fm/ItemPicker/ItemPickerGroup/ItemPickerGroup.vue.d.ts

@@ -7,5 +7,8 @@ declare const _default: import('vue').DefineComponent<FmItemPickerGroupProps, {}
     "onUpdate:suggested"?: ((value: string) => any) | undefined;
 }>, {
     mode: "add" | "update";
+    selected: string[];
+    suggested: string[];
+    initialSelected: string[];
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/src/components/fm/Menu/Menu.vue.d.ts

@@ -20,8 +20,8 @@ declare const __VLS_component: import('vue').DefineComponent<{}, {
     openOnClick: boolean;
     openOnFocus: boolean;
     attach: string | boolean | Record<string, any>;
-    items: unknown[];
     itemSize: string;
+    items: unknown[];
     minWidth?: string | number | undefined;
     activator?: string | Record<string, any> | undefined;
     location?: string | undefined;
@@ -49,8 +49,8 @@ declare const __VLS_component: import('vue').DefineComponent<{}, {
         readonly openOnClick?: boolean | undefined;
         readonly openOnFocus?: boolean | undefined;
         readonly attach?: string | boolean | Record<string, any> | undefined;
-        readonly items?: unknown[] | undefined;
         readonly itemSize?: string | undefined;
+        readonly items?: unknown[] | undefined;
         readonly minWidth?: string | number | undefined;
         readonly activator?: string | Record<string, any> | undefined;
         readonly location?: string | undefined;

package/dist/src/components/fm/Navigation/NavigationItem.vue.d.ts

@@ -8,9 +8,9 @@ declare const _default: import('vue').DefineComponent<{}, {
     label?: string | undefined;
     style?: Record<string, any> | undefined;
     children?: unknown[] | undefined;
+    classes?: string | undefined;
     level?: number | undefined;
     action?: Function | undefined;
-    classes?: string | undefined;
     alternativeLink?: string | undefined;
     route?: Record<string, any> | undefined;
     $props: {
@@ -21,9 +21,9 @@ declare const _default: import('vue').DefineComponent<{}, {
         readonly label?: string | undefined;
         readonly style?: Record<string, any> | undefined;
         readonly children?: unknown[] | undefined;
+        readonly classes?: string | undefined;
         readonly level?: number | undefined;
         readonly action?: Function | undefined;
-        readonly classes?: string | undefined;
         readonly alternativeLink?: string | undefined;
         readonly route?: Record<string, any> | undefined;
     };

package/dist/src/components/fm/Pagination/Pagination.vue.d.ts

@@ -1,16 +1,16 @@
 import { FmPaginationProps } from './types';
 declare const _default: import('vue').DefineComponent<FmPaginationProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     "update:modelValue": (value: number) => any;
-    first: (value: number) => any;
-    last: (value: number) => any;
     prev: (value: number) => any;
     next: (value: number) => any;
+    first: (value: number) => any;
+    last: (value: number) => any;
 }, string, import('vue').PublicProps, Readonly<FmPaginationProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: number) => any) | undefined;
-    onFirst?: ((value: number) => any) | undefined;
-    onLast?: ((value: number) => any) | undefined;
     onPrev?: ((value: number) => any) | undefined;
     onNext?: ((value: number) => any) | undefined;
+    onFirst?: ((value: number) => any) | undefined;
+    onLast?: ((value: number) => any) | undefined;
 }>, {
     modelValue: number;
     locals: {

package/dist/src/components/fm/TimePicker/TimePicker.vue.d.ts

@@ -0,0 +1,11 @@
+import { FmTimePickerProps } from './types';
+declare const _default: import('vue').DefineComponent<FmTimePickerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<FmTimePickerProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    size: number;
+    modelValue: string;
+    minutesStep: 1 | 2 | 5 | 10 | 15 | 20 | 30;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/fm/TimePicker/types.d.ts

@@ -0,0 +1,8 @@
+export interface FmTimePickerProps {
+    modelValue: string;
+    minutesStep?: 1 | 2 | 5 | 10 | 15 | 20 | 30;
+    size?: number;
+}
+export interface FmTimePickerEmits {
+    (event: 'update:modelValue', value: string): void;
+}

package/dist/src/directives/fm/Html.d.ts

@@ -0,0 +1,6 @@
+import { DirectiveBinding } from 'vue';
+declare const _default: {
+    mounted(el: Element, binding: DirectiveBinding): void;
+    updated(el: Element, binding: DirectiveBinding): void;
+};
+export default _default;

package/dist/src/directives/index.d.ts

@@ -0,0 +1,2 @@
+import { default as FmHtml } from './fm/Html';
+export { FmHtml };