@finmars/ui 1.0.47 → 1.0.49

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

@@ -0,0 +1,9 @@
+import { FmBreadcrumbProps } from './types';
+declare const _default: import('vue').DefineComponent<FmBreadcrumbProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    updateCrumbs: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<FmBreadcrumbProps> & Readonly<{
+    onUpdateCrumbs?: ((...args: any[]) => any) | undefined;
+}>, {
+    crumbs: import('./types').FmBreadcrumbItem[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,7 @@
+export interface FmBreadcrumbItem {
+    title: string;
+    path?: string;
+}
+export interface FmBreadcrumbProps {
+    crumbs: FmBreadcrumbItem[];
+}

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

@@ -5,12 +5,14 @@ declare const _default: import('vue').DefineComponent<{}, {
     indeterminate: boolean;
     error: boolean;
     value: boolean;
+    label?: string | undefined;
     $props: {
         readonly disabled?: boolean | undefined;
         readonly modelValue?: boolean | undefined;
         readonly indeterminate?: boolean | undefined;
         readonly error?: boolean | undefined;
         readonly value?: boolean | undefined;
+        readonly label?: string | undefined;
     };
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;

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

@@ -7,6 +7,7 @@ export interface FmChipProps {
         location: PlaceLocation;
     };
     type?: 'standard' | 'outlined';
+    compact?: boolean;
     prependIcon?: FmComponentIcon | string;
     appendIcon?: FmComponentIcon | string;
     closable?: boolean;

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

@@ -1,8 +1,8 @@
 import { FmFileUploadProps } from './types';
 declare const _default: import('vue').DefineComponent<FmFileUploadProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FmFileUploadProps> & Readonly<{}>, {
     icon: string;
-    indeterminate: boolean;
     label: string;
+    indeterminate: boolean;
     variant: "normal" | "large";
     multiple: boolean;
     dialogTitle: string;

package/dist/src/components/fm/Filters/Blocks/FilterLinkedBlock/FilterLinkedBlock.vue.d.ts

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

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

@@ -0,0 +1,16 @@
+import { FmSelectOption } from '../../../Select/types';
+import { FmAttribute, FmFilter } from '../../../../../types';
+export interface FmFilterLinkedBlockProps {
+    filter: FmFilter;
+    getSourceLinkedGroups: <T extends FmSelectOption>(filter: FmFilter) => Promise<T[]>;
+    getSourceLinkedGroupAttributes: (filter: FmFilter) => FmAttribute[];
+    locals?: {
+        linkedGroupPlaceholder?: string;
+        linkedFieldPlaceholder?: string;
+        linkedCondition?: string;
+        linkedFilterTypePlaceholder?: string;
+    };
+}
+export interface FmFilterLinkedBlockEmits {
+    (event: 'update', value: FmFilter): void;
+}

package/dist/src/components/fm/Filters/Blocks/FilterOptionListBlock/FilterOptionListBlock.vue.d.ts

@@ -0,0 +1,19 @@
+import { FmSelectOption } from '../../../Select/types';
+import { FmFilterOptionListBlockProps, FmFilterOptionListBlockEmits } from './types';
+declare const _default: <T extends FmSelectOption>(__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 onUpdate?: ((value: T[]) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate"> & FmFilterOptionListBlockProps<T>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: FmFilterOptionListBlockEmits<T>;
+}>) => 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/Filters/Blocks/FilterOptionListBlock/types.d.ts

@@ -0,0 +1,14 @@
+import { FmSelectOption } from '../../../Select/types';
+export interface FmFilterOptionListBlockProps<T extends FmSelectOption> {
+    options: T[];
+    selected: T[];
+    multiple?: boolean;
+    locals?: {
+        and?: string;
+        search?: string;
+        selectAll?: string;
+    };
+}
+export interface FmFilterOptionListBlockEmits<T extends FmSelectOption> {
+    (event: 'update', value: T[]): void;
+}

package/dist/src/components/fm/Filters/Blocks/FilterTypeSelectorBlock/FilterTypeSelectorBlock.vue.d.ts

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

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

@@ -0,0 +1,8 @@
+import { FmFilter, FmFilterType } from '../../../../../types';
+export interface FmFilterTypeSelectorBlockProps {
+    filter: FmFilter;
+    isFilterLinked?: boolean;
+}
+export interface FmFilterTypeSelectorBlockEmits {
+    (event: 'update', value: FmFilterType): void;
+}

package/dist/src/components/fm/Filters/FilterEditor/FilterEditor.vue.d.ts

@@ -0,0 +1,17 @@
+import { FmFilter } from '../../../../types';
+import { FmFilterEditorProps } from './types';
+declare const _default: import('vue').DefineComponent<FmFilterEditorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: FmFilter) => any;
+    cancel: () => any;
+}, string, import('vue').PublicProps, Readonly<FmFilterEditorProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: FmFilter) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+}>, {
+    locals: {
+        linkedGroupPlaceholder?: string;
+        linkedFieldPlaceholder?: string;
+        linkedCondition?: string;
+        linkedFilterTypePlaceholder?: string;
+    };
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,18 @@
+import { FmAttribute, FmFilter } from '../../../../types';
+import { FmSelectOption } from '../../Select/types';
+export interface FmFilterEditorProps {
+    value?: FmFilter;
+    getFilterOptions: <T extends FmSelectOption>(filter: FmFilter) => Promise<T[]>;
+    getSourceLinkedGroups: <T extends FmSelectOption>(filter: FmFilter) => Promise<T[]>;
+    getSourceLinkedGroupAttributes: (filter: FmFilter) => FmAttribute[];
+    locals?: {
+        linkedGroupPlaceholder?: string;
+        linkedFieldPlaceholder?: string;
+        linkedCondition?: string;
+        linkedFilterTypePlaceholder?: string;
+    };
+}
+export interface FmFilterEditorEmits {
+    (event: 'cancel'): void;
+    (event: 'update:modelValue', value: FmFilter): void;
+}

package/dist/src/components/fm/Filters/FilterToolbar/FilterToolbar.vue.d.ts

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

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

@@ -0,0 +1,27 @@
+import { FmFilter, FmAttribute } from '../../../../types';
+import { FmSelectOption } from '../../Select/types';
+export interface FmFilterAttribute extends FmAttribute {
+    value_types: number;
+    layout_name?: string;
+}
+export interface FmFilterAttributes {
+    title: string;
+    selectedAttributes: string[];
+    favoriteAttributes: string[];
+    attributes: FmFilterAttribute[];
+}
+export interface FmtFilterToolbarProps {
+    value: FmFilter[];
+    attributes: FmFilterAttribute[];
+    suggestedAttrs: string[];
+    showLinkedFilters?: boolean;
+    getFilterOptions: <T extends FmSelectOption>(filter: FmFilter) => Promise<T[]>;
+    getSourceLinkedGroups: <T extends FmSelectOption>(filter: FmFilter) => Promise<T[]>;
+    getSourceLinkedGroupAttributes: (filter: FmFilter) => FmAttribute[];
+    expandable?: boolean;
+    disabled?: boolean;
+}
+export interface FmtFilterToolbarEmits {
+    (event: 'update:modelValue', value: FmFilter[]): void;
+    (event: 'update:suggested', value: string): void;
+}

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

@@ -0,0 +1,19 @@
+import { FmFilterProps, FmFilterSlots } from '../../types';
+declare function __VLS_template(): {
+    slots: Readonly<FmFilterSlots> & FmFilterSlots;
+    refs: {};
+    attrs: Partial<{}>;
+};
+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;
+}, string, import('vue').PublicProps, Readonly<FmFilterProps> & Readonly<{
+    onUpdate?: ((value: import('../../../../..').FmFilter) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,19 @@
+import { FmFilterProps, FmFilterSlots } from '../../types';
+declare function __VLS_template(): {
+    slots: Readonly<FmFilterSlots> & FmFilterSlots;
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<FmFilterProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    update: (value: import('../../../../../types').FmFilter) => any;
+}, string, import('vue').PublicProps, Readonly<FmFilterProps> & Readonly<{
+    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;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,19 @@
+import { FmFilterProps, FmFilterSlots } from '../../types';
+declare function __VLS_template(): {
+    slots: Readonly<FmFilterSlots> & FmFilterSlots;
+    refs: {};
+    attrs: Partial<{}>;
+};
+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;
+}, string, import('vue').PublicProps, Readonly<FmFilterProps> & Readonly<{
+    onUpdate?: ((value: import('../../../../..').FmFilter) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,19 @@
+import { FmFilterProps, FmFilterSlots } from '../../types';
+declare function __VLS_template(): {
+    slots: Readonly<FmFilterSlots> & FmFilterSlots;
+    refs: {};
+    attrs: Partial<{}>;
+};
+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;
+}, string, import('vue').PublicProps, Readonly<FmFilterProps> & Readonly<{
+    onUpdate?: ((value: import('../../../../..').FmFilter) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,19 @@
+import { FmFilterProps, FmFilterSlots } from '../../types';
+declare function __VLS_template(): {
+    slots: Readonly<FmFilterSlots> & FmFilterSlots;
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<FmFilterProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    update: (value: import('../../../../../types').FmFilter) => any;
+}, string, import('vue').PublicProps, Readonly<FmFilterProps> & Readonly<{
+    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;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,22 @@
+import { FmFilterProps, FmFilterSlots } from '../../types';
+import { FmSelectOption } from '../../../Select/types';
+declare function __VLS_template(): {
+    slots: Readonly<FmFilterSlots> & FmFilterSlots;
+    refs: {};
+    attrs: Partial<{}>;
+};
+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;
+}, string, import('vue').PublicProps, Readonly<FmFilterProps> & Readonly<{
+    onUpdate?: ((value: import('../../../../..').FmFilter) => any) | undefined;
+}>, {
+    options: FmSelectOption[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/fm/Filters/FilterTypes/useFilter.d.ts

@@ -0,0 +1,12 @@
+import { ComputedRef } from 'vue';
+import { FmFilterProps } from '../types';
+export default function useFilter(props: FmFilterProps): {
+    simpleMode: ComputedRef<boolean>;
+    selectorMode: ComputedRef<boolean>;
+    rangeMode: ComputedRef<boolean>;
+    emptyMode: ComputedRef<boolean>;
+    displayValueIfSelect: ComputedRef<{
+        value: string;
+        tooltip: string;
+    }>;
+};

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

@@ -0,0 +1,8 @@
+import { FmFilterType } from '../../../types';
+import { FmSelectOption } from '../Select/types';
+export declare const FILTER_CONDITIONS: {
+    name: string;
+    id: FmFilterType;
+    availableInFilters: Array<number | 'field'>;
+}[];
+export declare const SELECTORS_BOOLEAN_OPTIONS: FmSelectOption[];

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

@@ -0,0 +1,17 @@
+import { VNode } from 'vue';
+import { FmFilter, FmFilterRangeValues } from '../../../types';
+import { FmSelectOption } from '../Select/types';
+export interface FmFilterProps {
+    filter: FmFilter;
+    filterValue: string | string[] | number | number[] | boolean | boolean[] | FmFilterRangeValues;
+    options?: FmSelectOption[];
+    isFilterLinked?: boolean;
+}
+export interface FmFilterEmits {
+    (event: 'update', value: FmFilter): void;
+}
+export interface FmFilterSlots {
+    'type-selector': () => VNode;
+    'option-list': () => VNode;
+    linked: () => VNode;
+}

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

@@ -0,0 +1 @@
+export declare function formatEnteredNumber(value: string): string;

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

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

@@ -0,0 +1,14 @@
+export interface FmInputDateProps {
+    modelValue?: string;
+    compact?: boolean;
+    label?: string;
+    placeholder?: string;
+    persistentPlaceholder?: boolean;
+    dateFormat?: string;
+    showAdjacentMonths?: boolean;
+    allowWeekendSelection?: boolean;
+    disabled?: boolean;
+}
+export interface FmInputDateEmits {
+    (event: 'update:modelValue', value: string): void;
+}

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

@@ -0,0 +1,25 @@
+import { FmItemPickerProps } from './types';
+declare const _default: import('vue').DefineComponent<FmItemPickerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string[]) => any;
+    close: () => any;
+    "update:suggested": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<FmItemPickerProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    "onUpdate:suggested"?: ((value: string) => any) | undefined;
+}>, {
+    height: number | string;
+    width: number | string;
+    locals: {
+        searchPlaceholder?: string;
+        noResultText?: string;
+        searchResultCategoryLabel?: string;
+        suggestedLabel?: string;
+        selectedLabel?: string;
+        cancelBtn?: string;
+        addBtn?: string;
+        updateBtn?: string;
+    };
+    mode: "add" | "update";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,25 @@
+import { FmAttribute } from '../../../../types';
+export interface FmItemPickerProps {
+    modelValue?: string[];
+    attributes?: FmAttribute[];
+    suggested?: string[];
+    mode?: 'add' | 'update';
+    multiple?: boolean;
+    width?: number | string;
+    height?: number | string;
+    locals?: {
+        searchPlaceholder?: string;
+        noResultText?: string;
+        searchResultCategoryLabel?: string;
+        suggestedLabel?: string;
+        selectedLabel?: string;
+        cancelBtn?: string;
+        addBtn?: string;
+        updateBtn?: string;
+    };
+}
+export interface FmItemPickerEmits {
+    (event: 'close'): void;
+    (event: 'update:suggested', value: string): void;
+    (event: 'update:modelValue', value: string[]): void;
+}

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

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

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

@@ -0,0 +1,21 @@
+import { FmAttribute } from '../../../../types';
+export interface FmAttributeGroup {
+    [key: string]: FmAttributeGroup | FmAttribute;
+}
+export interface FmItemPickerContentProps {
+    category: string;
+    attributes?: Record<string, FmAttributeGroup>;
+    suggested: string[];
+    selected: string[];
+    initialSelected: string[];
+    multiple?: boolean;
+    mode: 'add' | 'update';
+    locals?: {
+        suggested: string;
+        selected: string;
+    };
+}
+export interface FmItemPickerContentEmits {
+    (event: 'update:suggested', value: string): void;
+    (event: 'update:modelValue', value: string): void;
+}

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

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

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

@@ -0,0 +1,14 @@
+import { FmAttributeGroup } from '../ItemPickerContent/types';
+export interface FmItemPickerGroupProps {
+    level: number;
+    items: FmAttributeGroup;
+    mode: 'add' | 'update';
+    selected: string[];
+    suggested: string[];
+    initialSelected: string[];
+    multiple?: boolean;
+}
+export interface FmItemPickerGroupEmits {
+    (event: 'update:modelValue', value: string): void;
+    (event: 'update:suggested', value: string): void;
+}

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

@@ -0,0 +1,20 @@
+import { FmAttribute } from '../../../../types';
+import { FmItemPickerItemProps, FmItemPickerItemEmits } from './types';
+declare const _default: <T extends FmAttribute>(__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 "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        readonly "onUpdate:suggested"?: ((value: string) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:suggested"> & FmItemPickerItemProps<T>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: FmItemPickerItemEmits;
+}>) => 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/ItemPicker/ItemPickerItem/types.d.ts

@@ -0,0 +1,12 @@
+import { FmAttribute } from '../../../../types';
+export interface FmItemPickerItemProps<T extends FmAttribute> {
+    item: T;
+    selected: string[];
+    suggested: string[];
+    multiple?: boolean;
+    disabled?: boolean;
+}
+export interface FmItemPickerItemEmits {
+    (event: 'update:modelValue', value: string): void;
+    (event: 'update:suggested', value: string): void;
+}

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

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

package/dist/src/components/fm/ItemPicker/ItemPickerList/types.d.ts

@@ -0,0 +1,9 @@
+export interface FmItemPickerListProps {
+    categories: string[];
+    currentCategory?: string;
+    selectedCategoryName: string;
+    selectedCount?: number;
+}
+export interface FmItemPickerListEmits {
+    (event: 'select:category', value: string): void;
+}

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

@@ -0,0 +1,20 @@
+import { FmAttribute } from '../../../../types';
+import { FmItemPickerSearchResultProps, FmItemPickerSearchResultEmits } from './types';
+declare const _default: <T extends FmAttribute>(__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 onSelect?: ((value: string) => any) | undefined;
+        readonly "onAdd:suggested"?: ((value: string) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onSelect" | "onAdd:suggested"> & FmItemPickerSearchResultProps<T>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: FmItemPickerSearchResultEmits;
+}>) => 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/ItemPicker/ItemPickerSearchResult/types.d.ts

@@ -0,0 +1,13 @@
+import { FmAttribute } from '../../../../types';
+export interface FmItemPickerSearchResultProps<T extends FmAttribute> {
+    searchText?: string;
+    items: T[];
+    initialSelectedItems: string[];
+    selectedItems: string[];
+    multiple?: boolean;
+    mode: 'add' | 'update';
+}
+export interface FmItemPickerSearchResultEmits {
+    (event: 'select', value: string): void;
+    (event: 'add:suggested', value: string): void;
+}