@codemonster-ru/vueforge 0.93.0 → 0.94.0

package/dist/package/components/data-table.vue.d.ts

@@ -124,6 +124,7 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     sort: (...args: any[]) => void;
     filter: (...args: any[]) => void;
     page: (...args: any[]) => void;
+    bulkAction: (...args: any[]) => void;
     columnResize: (...args: any[]) => void;
     columnReorder: (...args: any[]) => void;
     "update:sortField": (...args: any[]) => void;
@@ -135,7 +136,6 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     request: (...args: any[]) => void;
     "update:selection": (...args: any[]) => void;
     selectionChange: (...args: any[]) => void;
-    bulkAction: (...args: any[]) => void;
     "update:columnOrder": (...args: any[]) => void;
     "update:expandedRows": (...args: any[]) => void;
     rowExpand: (...args: any[]) => void;
@@ -146,6 +146,7 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     onSort?: ((...args: any[]) => any) | undefined;
     onFilter?: ((...args: any[]) => any) | undefined;
     onPage?: ((...args: any[]) => any) | undefined;
+    onBulkAction?: ((...args: any[]) => any) | undefined;
     onColumnResize?: ((...args: any[]) => any) | undefined;
     onColumnReorder?: ((...args: any[]) => any) | undefined;
     "onUpdate:sortField"?: ((...args: any[]) => any) | undefined;
@@ -157,7 +158,6 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     onRequest?: ((...args: any[]) => any) | undefined;
     "onUpdate:selection"?: ((...args: any[]) => any) | undefined;
     onSelectionChange?: ((...args: any[]) => any) | undefined;
-    onBulkAction?: ((...args: any[]) => any) | undefined;
     "onUpdate:columnOrder"?: ((...args: any[]) => any) | undefined;
     "onUpdate:expandedRows"?: ((...args: any[]) => any) | undefined;
     onRowExpand?: ((...args: any[]) => any) | undefined;
@@ -176,20 +176,20 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     selectAllAriaLabel: string;
     selectRowAriaLabel: string;
     rows: Array<Record<string, unknown>>;
+    rowKey: string | ((row: Record<string, unknown>, index: number) => string | number);
+    bulkActions: Array<DataTableBulkAction>;
+    showHeader: boolean;
     pageSize: number;
     stickyHeader: boolean;
-    rowKey: string | ((row: Record<string, unknown>, index: number) => string | number);
+    selection: DataTableRowKey | Array<DataTableRowKey> | null;
     sortable: boolean;
     sortField: string | null;
     sortOrder: SortOrder;
     striped: boolean;
     hover: boolean;
-    showHeader: boolean;
     server: boolean;
     filters: DataTableFilters;
     selectionMode: DataTableSelectionMode;
-    selection: DataTableRowKey | Array<DataTableRowKey> | null;
-    bulkActions: Array<DataTableBulkAction>;
     columnResize: boolean;
     minColumnWidth: number;
     columnReorder: boolean;

package/dist/package/components/data-view.vue.d.ts

@@ -65,8 +65,8 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     loadingText: string;
     emptyText: string;
     total: number;
-    pageSize: number;
     rowKey: string | ((item: Record<string, unknown>, index: number) => string | number);
+    pageSize: number;
     sortable: boolean;
     sortField: string | null;
     sortOrder: SortOrder;

package/dist/package/components/date-range-picker.vue.d.ts

@@ -39,8 +39,8 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     readonly: boolean;
     min: string;
     max: string;
-    panelAriaLabel: string;
     locale: string;
+    panelAriaLabel: string;
     firstDayOfWeek: number;
     startPlaceholder: string;
     endPlaceholder: string;

package/dist/package/components/datepicker.vue.d.ts

@@ -34,8 +34,8 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     readonly: boolean;
     min: string;
     max: string;
-    panelAriaLabel: string;
     locale: string;
+    panelAriaLabel: string;
     firstDayOfWeek: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     root: HTMLDivElement;

package/dist/package/components/datetimepicker.vue.d.ts

@@ -39,8 +39,8 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     format: TimeFormat;
     min: string;
     max: string;
-    panelAriaLabel: string;
     locale: string;
+    panelAriaLabel: string;
     firstDayOfWeek: number;
     minuteStep: number;
     timeListAriaLabel: string;

package/dist/package/components/diff-viewer.vue.d.ts

@@ -0,0 +1,45 @@
+type DiffMode = 'inline' | 'split';
+type DiffFormat = 'auto' | 'text' | 'json';
+interface Props {
+    before?: unknown;
+    after?: unknown;
+    mode?: DiffMode;
+    format?: DiffFormat;
+    showToolbar?: boolean;
+    copyable?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+    emptyText?: string;
+    inlineLabel?: string;
+    splitLabel?: string;
+    beforeLabel?: string;
+    afterLabel?: string;
+    copyLabel?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    copy: (payload: {
+        text: string;
+    }) => any;
+    "update:mode": (value: DiffMode) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onCopy?: ((payload: {
+        text: string;
+    }) => any) | undefined;
+    "onUpdate:mode"?: ((value: DiffMode) => any) | undefined;
+}>, {
+    disabled: boolean;
+    ariaLabel: string;
+    emptyText: string;
+    mode: DiffMode;
+    format: DiffFormat;
+    showToolbar: boolean;
+    copyable: boolean;
+    before: undefined;
+    after: undefined;
+    inlineLabel: string;
+    splitLabel: string;
+    beforeLabel: string;
+    afterLabel: string;
+    copyLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/package/components/drawer.vue.d.ts

@@ -43,10 +43,10 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     size: "sm" | "md" | "lg";
     overlay: boolean;
     closeOnOverlay: boolean;
-    position: "left" | "right" | "top" | "bottom";
     closeOnEsc: boolean;
     showClose: boolean;
     lockScroll: boolean;
+    position: "left" | "right" | "top" | "bottom";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     panel: HTMLDivElement;
 }, any>;

package/dist/package/components/dropdown.vue.d.ts

@@ -52,9 +52,9 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     disabled: boolean;
     modelValue: boolean;
     items: Array<Item>;
+    closeOnEsc: boolean;
     placement: Placement;
     offset: number;
-    closeOnEsc: boolean;
     closeOnSelect: boolean;
     matchTriggerWidth: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {

package/dist/package/components/dynamic-dialog.vue.d.ts

@@ -0,0 +1,35 @@
+import { DynamicDialogService } from '../services/dynamic-dialog-service';
+interface Props {
+    service?: DynamicDialogService;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            entry: import('../services/dynamic-dialog-service').DynamicDialogEntry<unknown, Record<string, unknown>> | null;
+            close: <TResult = unknown>(result?: TResult) => boolean;
+            dismiss: () => boolean;
+        }): any;
+        footer?(_: {
+            entry: import('../services/dynamic-dialog-service').DynamicDialogEntry<unknown, Record<string, unknown>>;
+            close: <TResult = unknown>(result?: TResult) => boolean;
+            dismiss: () => boolean;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    closeCurrent: <TResult = unknown>(result?: TResult) => boolean;
+    dismissCurrent: () => boolean;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    service: DynamicDialogService;
+}, {}, {}, {}, 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/package/components/file-manager.vue.d.ts

@@ -0,0 +1,89 @@
+type FileManagerView = 'list' | 'grid';
+type FileManagerId = string | number;
+export interface FileManagerItem {
+    id?: FileManagerId;
+    name: string;
+    kind?: 'file' | 'folder';
+    size?: number;
+    thumbnail?: string;
+    updatedAt?: string;
+    disabled?: boolean;
+}
+interface FileManagerBulkAction {
+    id: string;
+    label: string;
+    disabled?: boolean;
+}
+interface Props {
+    items?: Array<FileManagerItem>;
+    modelValue?: Array<FileManagerId>;
+    view?: FileManagerView;
+    rowKey?: string | ((item: FileManagerItem, index: number) => FileManagerId);
+    selectable?: boolean;
+    multi?: boolean;
+    previewable?: boolean;
+    showToolbar?: boolean;
+    bulkActions?: Array<FileManagerBulkAction>;
+    loading?: boolean;
+    loadingText?: string;
+    emptyText?: string;
+    disabled?: boolean;
+    ariaLabel?: string;
+    previewAriaLabel?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        loading?(_: {}): any;
+        empty?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: FileManagerId[]) => any;
+    "update:modelValue": (value: FileManagerId[]) => any;
+    itemClick: (item: FileManagerItem) => any;
+    preview: (item: FileManagerItem) => any;
+    "update:view": (value: FileManagerView) => any;
+    bulkAction: (payload: {
+        actionId: string;
+        items: Array<FileManagerItem>;
+        ids: Array<FileManagerId>;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onChange?: ((value: FileManagerId[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: FileManagerId[]) => any) | undefined;
+    onItemClick?: ((item: FileManagerItem) => any) | undefined;
+    onPreview?: ((item: FileManagerItem) => any) | undefined;
+    "onUpdate:view"?: ((value: FileManagerView) => any) | undefined;
+    onBulkAction?: ((payload: {
+        actionId: string;
+        items: Array<FileManagerItem>;
+        ids: Array<FileManagerId>;
+    }) => any) | undefined;
+}>, {
+    disabled: boolean;
+    view: FileManagerView;
+    modelValue: Array<FileManagerId>;
+    ariaLabel: string;
+    items: Array<FileManagerItem>;
+    loading: boolean;
+    previewAriaLabel: string;
+    loadingText: string;
+    emptyText: string;
+    showToolbar: boolean;
+    rowKey: string | ((item: FileManagerItem, index: number) => FileManagerId);
+    selectable: boolean;
+    multi: boolean;
+    previewable: boolean;
+    bulkActions: Array<FileManagerBulkAction>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+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/package/components/infinite-scroll.vue.d.ts

@@ -0,0 +1,72 @@
+export type InfiniteScrollLoadTrigger = 'intersection' | 'scroll' | 'retry' | 'manual';
+export type InfiniteScrollLoadPayload = {
+    trigger: InfiniteScrollLoadTrigger;
+};
+interface Props {
+    loading?: boolean;
+    error?: boolean;
+    hasMore?: boolean;
+    disabled?: boolean;
+    root?: HTMLElement | null;
+    scrollTarget?: Window | HTMLElement | null;
+    rootMargin?: string;
+    threshold?: number;
+    fallbackOffset?: number;
+    debounceMs?: number;
+    observeOnMount?: boolean;
+    loadingText?: string;
+    endText?: string;
+    retryLabel?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        error?(_: {
+            retry: () => void;
+        }): any;
+        loading?(_: {}): any;
+        end?(_: {}): any;
+        sentinel?(_: {}): any;
+    };
+    refs: {
+        sentinel: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    loadMore: () => void;
+    refresh: () => void;
+    retry: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    load: (payload: InfiniteScrollLoadPayload) => any;
+    retry: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onLoad?: ((payload: InfiniteScrollLoadPayload) => any) | undefined;
+    onRetry?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    error: boolean;
+    loading: boolean;
+    root: HTMLElement | null;
+    loadingText: string;
+    rootMargin: string;
+    threshold: number;
+    hasMore: boolean;
+    scrollTarget: Window | HTMLElement | null;
+    fallbackOffset: number;
+    debounceMs: number;
+    observeOnMount: boolean;
+    endText: string;
+    retryLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    sentinel: HTMLDivElement;
+}, HTMLDivElement>;
+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/package/components/inline-message.vue.d.ts

@@ -0,0 +1,40 @@
+type InlineMessageSeverity = 'neutral' | 'info' | 'success' | 'warn' | 'danger';
+type InlineMessageSize = 'small' | 'normal' | 'large';
+type InlineMessageRole = 'auto' | 'status' | 'alert' | 'none';
+type InlineMessageAriaLive = 'auto' | 'off' | 'polite' | 'assertive';
+interface Props {
+    title?: string;
+    message?: string;
+    severity?: InlineMessageSeverity;
+    icon?: string;
+    size?: InlineMessageSize;
+    role?: InlineMessageRole;
+    ariaLive?: InlineMessageAriaLive;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+        title?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    title: string;
+    size: InlineMessageSize;
+    role: InlineMessageRole;
+    icon: string;
+    severity: InlineMessageSeverity;
+    message: string;
+    ariaLive: InlineMessageAriaLive;
+}, {}, {}, {}, 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/package/components/json-viewer.vue.d.ts

@@ -0,0 +1,57 @@
+interface Props {
+    value?: unknown;
+    expandedDepth?: number;
+    sortKeys?: boolean;
+    showRoot?: boolean;
+    copyable?: boolean;
+    showToolbar?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+    emptyText?: string;
+    expandLabel?: string;
+    collapseLabel?: string;
+    expandAllLabel?: string;
+    collapseAllLabel?: string;
+    copyPathLabel?: string;
+    copyJsonLabel?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    copy: (payload: {
+        text: string;
+    }) => any;
+    toggle: (payload: {
+        path: string;
+        expanded: boolean;
+    }) => any;
+    copyPath: (payload: {
+        path: string;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onCopy?: ((payload: {
+        text: string;
+    }) => any) | undefined;
+    onToggle?: ((payload: {
+        path: string;
+        expanded: boolean;
+    }) => any) | undefined;
+    onCopyPath?: ((payload: {
+        path: string;
+    }) => any) | undefined;
+}>, {
+    disabled: boolean;
+    expandLabel: string;
+    collapseLabel: string;
+    ariaLabel: string;
+    value: undefined;
+    emptyText: string;
+    showToolbar: boolean;
+    expandedDepth: number;
+    sortKeys: boolean;
+    showRoot: boolean;
+    copyable: boolean;
+    expandAllLabel: string;
+    collapseAllLabel: string;
+    copyPathLabel: string;
+    copyJsonLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/package/components/kpi-stat-card.vue.d.ts

@@ -0,0 +1,46 @@
+type TrendDirection = 'up' | 'down' | 'neutral' | 'auto';
+type DeltaFormat = 'number' | 'percent';
+interface Props {
+    title?: string;
+    subtitle?: string;
+    value?: string | number;
+    caption?: string;
+    trend?: TrendDirection;
+    trendLabel?: string;
+    delta?: number | null;
+    deltaFormat?: DeltaFormat;
+    showDelta?: boolean;
+    ariaLabel?: string;
+    locale?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        sparkline?(_: {}): any;
+        value?(_: {}): any;
+        caption?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    caption: string;
+    title: string;
+    subtitle: string;
+    ariaLabel: string;
+    value: string | number;
+    locale: string;
+    trend: TrendDirection;
+    trendLabel: string;
+    delta: number | null;
+    deltaFormat: DeltaFormat;
+    showDelta: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+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/package/components/member-picker.vue.d.ts

@@ -0,0 +1,89 @@
+type MemberValue = string | number;
+export interface MemberPickerItem {
+    id: MemberValue;
+    name: string;
+    email?: string;
+    avatar?: string;
+    roleHint?: string;
+    org?: string;
+    disabled?: boolean;
+}
+interface Props {
+    modelValue?: MemberValue | Array<MemberValue> | null;
+    options?: Array<MemberPickerItem>;
+    multiple?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    placeholder?: string;
+    ariaLabel?: string;
+    loading?: boolean;
+    loadingText?: string;
+    emptyText?: string;
+    removeLabel?: string;
+    filterLocal?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        selection?(_: {
+            member: MemberPickerItem;
+            remove: () => void;
+        }): any;
+        option?(_: {
+            member: MemberPickerItem;
+            index: number;
+            selected: boolean;
+        }): any;
+        'role-hint'?(_: {
+            member: MemberPickerItem;
+        }): any;
+    };
+    refs: {
+        root: HTMLDivElement;
+        inputRef: HTMLInputElement;
+        panelRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    search: (query: string) => any;
+    blur: (ev: FocusEvent) => any;
+    change: (value: MemberValue | MemberValue[] | null) => any;
+    focus: (ev: FocusEvent) => any;
+    select: (member: MemberPickerItem) => any;
+    "update:modelValue": (value: MemberValue | MemberValue[] | null) => any;
+    remove: (member: MemberPickerItem) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onSearch?: ((query: string) => any) | undefined;
+    onBlur?: ((ev: FocusEvent) => any) | undefined;
+    onChange?: ((value: MemberValue | MemberValue[] | null) => any) | undefined;
+    onFocus?: ((ev: FocusEvent) => any) | undefined;
+    onSelect?: ((member: MemberPickerItem) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: MemberValue | MemberValue[] | null) => any) | undefined;
+    onRemove?: ((member: MemberPickerItem) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: MemberValue | Array<MemberValue> | null;
+    ariaLabel: string;
+    multiple: boolean;
+    loading: boolean;
+    placeholder: string;
+    readonly: boolean;
+    loadingText: string;
+    emptyText: string;
+    options: Array<MemberPickerItem>;
+    removeLabel: string;
+    filterLocal: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    root: HTMLDivElement;
+    inputRef: HTMLInputElement;
+    panelRef: HTMLDivElement;
+}, HTMLDivElement>;
+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/package/components/meter-group.vue.d.ts

@@ -0,0 +1,46 @@
+type MeterState = 'normal' | 'warn' | 'danger';
+export interface MeterGroupThresholds {
+    warn?: number;
+    danger?: number;
+}
+export interface MeterGroupItem {
+    id?: string | number;
+    label: string;
+    value: number;
+    max?: number;
+    description?: string;
+    thresholds?: MeterGroupThresholds;
+}
+interface Props {
+    items?: Array<MeterGroupItem>;
+    max?: number;
+    ariaLabel?: string;
+    locale?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        item?(_: {
+            item: MeterGroupItem;
+            index: number;
+            percent: number;
+            state: MeterState;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    ariaLabel: string;
+    items: Array<MeterGroupItem>;
+    max: number;
+    locale: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+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/package/components/overlay-badge-utils.d.ts

@@ -0,0 +1,23 @@
+export type OverlayBadgeSeverity = 'neutral' | 'info' | 'success' | 'warn' | 'danger';
+export type OverlayBadgePosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+export type OverlayBadgeValue = string | number | null | undefined;
+export type OverlayBadgeOptions = {
+    value?: OverlayBadgeValue;
+    hidden?: boolean;
+    dot?: boolean;
+    max?: number;
+    showZero?: boolean;
+    severity?: OverlayBadgeSeverity;
+    position?: OverlayBadgePosition;
+    ariaLabel?: string;
+};
+export type OverlayBadgeBinding = OverlayBadgeValue | OverlayBadgeOptions;
+export type OverlayBadgeResolved = {
+    text: string;
+    visible: boolean;
+    dot: boolean;
+    severity: OverlayBadgeSeverity;
+    position: OverlayBadgePosition;
+    ariaLabel: string;
+};
+export declare const resolveOverlayBadge: (binding: OverlayBadgeBinding) => OverlayBadgeResolved;