@turquoisehealth/pit-viper 2.194.3-dev.2 → 2.194.4

package/pv-components/dist/vue/visualizations/components/base/PvFilterPanel/types.d.ts

@@ -0,0 +1,402 @@
+import { Component, Ref } from 'vue';
+import { AdvancedFilterModel, FilterModel } from 'ag-grid-enterprise';
+import { MenuOption, MultiSelectState } from '../../../types';
+import { ColDef, ValueFormatterFunc } from 'ag-grid-community';
+import { PvRangeValue } from '../PvRange/types';
+export type PvFilterPanelCategory = string;
+export type PvFilterPanelFilterType = "value" | "range" | "boolean" | "exists";
+export type PvFilterPanelFilterModelType = "advanced" | "regular";
+export type PvFilterPanelFilterModel = AdvancedFilterModel | FilterModel | null;
+export type PvFilterPanelResultCount = number | string;
+export type PvFilterPanelOptionRawValue = boolean | number | string | null;
+export interface PvFilterPanelOption {
+    children?: PvFilterPanelOption[];
+    colField?: string;
+    /** Explicit field this option filters. Prefer this over colField or scoped value parsing for new consumers. */
+    field?: string;
+    isPreference?: boolean;
+    isSelectable?: boolean;
+    label?: string;
+    matchedField?: string;
+    matchedValue?: string;
+    menuOption?: Partial<MenuOption<PvFilterPanelOption>>;
+    /** Metadata that can be associated with the value and passed through renderers/handlers. */
+    metadata?: any;
+    /** Explicit raw filter value. Prefer this over metadata.rawValue or scoped value parsing for new consumers. */
+    rawValue?: PvFilterPanelOptionRawValue;
+    resultCount?: PvFilterPanelResultCount | null;
+    subduedText?: string;
+    subText?: string;
+    totalChildCount?: number;
+    value: string;
+}
+export interface PvFilterPanelFilterGroup {
+    fields: string[];
+    label: string;
+}
+export interface PvFilterPanelAggregateFieldHierarchy {
+    /** Field represented by this hierarchy node. Parent/child relationships are determined by nesting. */
+    field: string;
+    /** Child fields nested under this field. */
+    children?: PvFilterPanelAggregateFieldHierarchy[];
+}
+export interface PvFilterPanelRangeConfig {
+    /** Minimum bound for range controls in reusable filter panel UIs. */
+    min?: number | null;
+    /** Maximum bound for range controls in reusable filter panel UIs. */
+    max?: number | null;
+    /** Step increment for range controls in reusable filter panel UIs. */
+    step?: number | null;
+}
+export interface PvFilterPanelColDefContext {
+    /**
+     * Hierarchy of fields represented by this aggregate filter column.
+     *
+     * Example: `{ field: "health_system", children: [{ field: "provider_id" }] }`
+     * renders health systems as parent options and providers as nested child options.
+     * Fields must be present as their own columns in the table. Filters for the
+     * hierarchy fields are hidden from the filter panel in favor of this aggregate filter.
+     *
+     * Requires `enableAdvancedFilter: true` on the table — columns with an aggregate hierarchy
+     * are excluded (and may log a console warning) when advanced filtering is disabled.
+     */
+    aggregateFieldHierarchy?: PvFilterPanelAggregateFieldHierarchy;
+    /**
+     * Aggregate filter column for columns that have "peer" relationships, as opposed to hierarchical
+     * Requires `enableAdvancedFilter: true` on the table — columns with aggregate fields
+     * are excluded (and may log a console warning) when advanced filtering is disabled.
+     */
+    aggregateFields?: string[];
+    /**
+     * The data type of the column values, used for things like formatting, icons, etc.
+     */
+    dataType?: string | null;
+    /**
+     * If true, this column is considered a "dev" column and will only be shown when devMode is enabled
+     */
+    devOnly?: boolean;
+    /**
+     * An optional renderer to use for dropdown values when no results are found
+     */
+    emptyFilterResultsRenderer?: Component;
+    /**
+     * Optional renderer to provide content below the filter options list
+     */
+    filterFooterRenderer?: Component;
+    /**
+     * A group of boolean sub-fields to render as a hover submenu above the filter options.
+     * Each field in `fields` must be present as a column in the table.
+     * Selecting an item toggles a `<field> = "true"` condition in the advanced filter model.
+     */
+    filterGroup?: PvFilterPanelFilterGroup;
+    /**
+     * Optional renderer to provide content above the filter options list
+     */
+    filterHeaderRenderer?: Component;
+    /**
+     * Optional renderer to override the default filter options list
+     */
+    filterOptionsRenderer?: Component;
+    /**
+     * An optional description to show in the tooltip explaining how the dropdown values are sorted
+     */
+    filterOptionsSortDescription?: string;
+    /**
+     * The primary text for the optional tooltip
+     */
+    filterOptionsSortTooltip?: string;
+    /**
+     * Category label used by reusable filter panel UIs to group this column.
+     */
+    filterPanelCategory?: PvFilterPanelCategory | null;
+    /**
+     * Custom label for exists filters. Defaults to `Has ${headerName}`.
+     */
+    filterPanelExistsLabel?: string;
+    /**
+     * If true, hide this column from reusable filter panel UIs.
+     */
+    filterPanelHidden?: boolean;
+    /**
+     * Range control configuration used by reusable filter panel UIs. Presence infers a range filter type.
+     */
+    filterPanelRange?: PvFilterPanelRangeConfig;
+    /**
+     * Placeholder shown in value filter search inputs.
+     */
+    filterPanelSearchPlaceholder?: string;
+    /**
+     * Filter control type used by reusable filter panel UIs.
+     */
+    filterPanelType?: PvFilterPanelFilterType;
+    /**
+     * Labels for boolean values, keyed by `true` and `false`.
+     */
+    filterPanelValueLabels?: Record<string, string> | null;
+    /**
+     * If true, will show a search box to filter the available filter options
+     */
+    filterSearch?: boolean;
+    /**
+     * If true, grouped data will not be displayed until a filter is applied
+     */
+    filterRequiredToGroup?: boolean;
+    /**
+     * The max number of allowable selections for filters on this column
+     */
+    filterSelectMax?: number;
+    /**
+     * The min number of allowable selections for filters on this column
+     */
+    filterSelectMin?: number;
+    /**
+     * Formatter for the filter values in the dropdown
+     */
+    filterValueFormatter?: string | ValueFormatterFunc | null;
+    /**
+     * Determines how values are formatted when the field contains array data
+     */
+    isArrayField?: boolean;
+    /**
+     * A list of associated fields that can be expected and used for custom formatting
+     */
+    metadataDisplayFields?: string[];
+    /**
+     * For server-side filtering, list of associated column IDs to query against when searching for filter values.
+     */
+    queryColIds?: string[];
+    /**
+     * Number of decimal places to show for numeric values (if applicable)
+     */
+    valueDecimals?: number | null;
+}
+export type PvFilterPanelColDef = Omit<ColDef, "context"> & {
+    context?: PvFilterPanelColDefContext;
+};
+export interface PvFilterPanelAppliedValue {
+    field?: string;
+    label: string;
+    resultCount?: PvFilterPanelResultCount | null;
+    subText?: string;
+    subduedText?: string;
+    type?: PvFilterPanelFilterType;
+    value: string;
+}
+export interface PvFilterPanelAppliedGroup {
+    key: string;
+    label: string;
+    values: PvFilterPanelAppliedValue[];
+}
+export type PvFilterPanelControlChange = {
+    checked: boolean;
+    field?: string;
+    type: "value";
+    value: string;
+} | {
+    field?: string;
+    type: "range";
+    value: PvRangeValue;
+} | {
+    field?: string;
+    type: "boolean";
+    value: boolean | null;
+} | {
+    field?: string;
+    type: "exists";
+    value: boolean;
+} | {
+    type: "aggregate-selection";
+    value: MultiSelectState;
+};
+export interface PvFilterPanelSuggestion {
+    field: string;
+    filter: PvFilterPanelControlChange;
+    icon?: string;
+    iconClasses?: string[];
+    key?: string;
+    label: string;
+    option?: PvFilterPanelOption;
+}
+export type PvFilterPanelFilterChangeReason = "boolean-change" | "clear-all" | "exists-change" | "range-change" | "remove-filter" | "value-toggle";
+export interface PvFilterPanelFilterChangeEvent {
+    colDef?: PvFilterPanelColDef;
+    field?: string;
+    filterModel: PvFilterPanelFilterModel;
+    previousFilterModel: PvFilterPanelFilterModel;
+    reason: PvFilterPanelFilterChangeReason;
+    type?: PvFilterPanelFilterType;
+}
+export interface PvFilterPanelGroupOption {
+    field: string;
+    isActive: boolean;
+    label: string;
+}
+export type PvFilterPanelOptionsHandlerReason = "open" | "search" | "load-more" | "child-load-more";
+export interface PvFilterPanelOptionsHandlerParams {
+    field: string;
+    colDef: PvFilterPanelColDef;
+    filterModel?: PvFilterPanelFilterModel;
+    limit?: number;
+    offset?: number;
+    parentId?: string;
+    query?: string;
+    reason: PvFilterPanelOptionsHandlerReason;
+    selectedValues?: (string | null)[];
+}
+export interface PvFilterPanelOptionsResponse {
+    hasMore?: boolean;
+    totalCount?: number;
+    values: (PvFilterPanelOption | null)[];
+}
+export type PvFilterPanelOptionsHandler = (params: PvFilterPanelOptionsHandlerParams) => Promise<PvFilterPanelOptionsResponse | (PvFilterPanelOption | null)[]>;
+export interface PvFilterStoreFetchOptionsParams extends Omit<PvFilterPanelOptionsHandlerParams, "offset"> {
+    offset?: number;
+}
+export interface PvFilterStore {
+    clearStagedFilterSelections: () => void;
+    commitStagedFilterSelections: () => void;
+    fetchFilterOptions: (params: PvFilterStoreFetchOptionsParams) => Promise<(string | null)[]>;
+    filterHasMoreMap: Ref<Record<string, boolean | undefined>>;
+    filterLoadingMap: Ref<Record<string, boolean | undefined>>;
+    filterLoadingMoreMap: Ref<Record<string, boolean | undefined>>;
+    filterModel: Ref<PvFilterPanelFilterModel>;
+    filterModelType: Ref<PvFilterPanelFilterModelType | undefined>;
+    filterOptionsHandler: Ref<PvFilterPanelOptionsHandler | undefined>;
+    filterOptionsMap: Ref<Record<string, (PvFilterPanelOption | null)[]>>;
+    filterRequestIdMap: Ref<Record<string, number | undefined>>;
+    filterSearchQueries: Ref<Record<string, string | null | undefined>>;
+    filterStaleMap: Ref<Record<string, boolean | undefined>>;
+    filterSelectedMetadataMap: Ref<Record<string, (PvFilterPanelOption | null)[]>>;
+    filterSelectedValueMap: Ref<Record<string, (string | null)[]>>;
+    filterTotalCountMap: Ref<Record<string, number | undefined>>;
+    filterChildHasMoreMap: Ref<Record<string, boolean | undefined>>;
+    filterChildTotalCountMap: Ref<Record<string, number | undefined>>;
+    getFilterOptions: (field: string) => (PvFilterPanelOption | null)[];
+    getFilterSelectedValues: (field: string, staged?: boolean) => (string | null)[];
+    initStagedFilterSelections: () => void;
+    setFilterOptions: (field: string, options: (PvFilterPanelOption | null)[]) => void;
+    setFilterOptionsHandler: (handler?: PvFilterPanelOptionsHandler) => void;
+    setFilterSearchQuery: (field: string, query: string | null | undefined) => void;
+    setFilterSelectedValues: (field: string, values: (string | null)[], staged?: boolean) => void;
+    stagedFilterModel: Ref<PvFilterPanelFilterModel>;
+    stagedFilterSelectedMetadataMap: Ref<Record<string, (PvFilterPanelOption | null)[]>>;
+    stagedFilterSelectedValueMap: Ref<Record<string, (string | null)[]>>;
+}
+export interface PvFilterPanelResolvedFilter {
+    aggregateSelectionState?: MultiSelectState;
+    booleanValue?: boolean | null;
+    category?: PvFilterPanelCategory | null;
+    colDef: PvFilterPanelColDef;
+    dataType?: string | null;
+    disabled?: boolean;
+    displayPreferencesIcon?: boolean;
+    emptyResultsRenderer?: Component;
+    existsLabel?: string;
+    existsValue?: boolean;
+    filterFooterRenderer?: Component;
+    filterGroupLabel?: string;
+    filterGroupOptions?: PvFilterPanelGroupOption[];
+    filterHeaderRenderer?: Component;
+    filterOptionsRenderer?: Component;
+    filterOptionsSortDescription?: string;
+    filterOptionsSortTooltip?: string;
+    focusText?: string;
+    focusedValues?: string[];
+    focusedValuesByField?: Record<string, string[] | undefined>;
+    hasMore?: boolean;
+    isAggregate?: boolean;
+    isFocusable?: boolean;
+    isLoading?: boolean;
+    isLoadingMore?: boolean;
+    isOpen?: boolean;
+    key: string;
+    knownOptions?: PvFilterPanelOption[];
+    label: string;
+    options?: PvFilterPanelOption[];
+    rangeMax?: number | null;
+    rangeMin?: number | null;
+    rangeStep?: number | null;
+    rangeValue?: PvRangeValue;
+    searchPlaceholder?: string;
+    searchQuery?: string;
+    selectedValues?: string[];
+    type: PvFilterPanelFilterType;
+    valueDecimals?: number | null;
+    valueLabels?: Record<string, string> | null;
+}
+export interface PvFilterPanelAccordionProps {
+    filter: PvFilterPanelResolvedFilter;
+}
+export interface PvFilterPanelAppliedFiltersSectionProps {
+    appliedCount?: number;
+    appliedGroups?: PvFilterPanelAppliedGroup[];
+    readOnly?: boolean;
+}
+export interface PvFilterPanelCategoryButtonRowProps {
+    categoryOrder?: PvFilterPanelCategory[];
+    filters?: PvFilterPanelResolvedFilter[];
+}
+export interface PvFilterPanelOptionRowProps {
+    ariaLabel?: string;
+    depth?: number;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    focusText?: string;
+    isFocused?: boolean;
+    label: string;
+    queryText?: string | null;
+    renderer?: Component;
+    resultCount?: PvFilterPanelResultCount | null;
+    selected?: boolean;
+    showFocusAction?: boolean;
+    subText?: string;
+    subduedText?: string;
+    value: string;
+}
+export interface PvFilterPanelProps {
+    applyLabel?: string;
+    ariaLabel?: string;
+    /** Auto-hide backing fields represented by aggregate filters and child fields represented by filter groups. */
+    autoHideRelatedFilterFields?: boolean;
+    cancelLabel?: string;
+    categoryOrder?: PvFilterPanelCategory[];
+    clearAllBody?: string;
+    clearAllHeader?: string;
+    clearAllLabel?: string;
+    colDefs?: PvFilterPanelColDef[];
+    /** Whether dev-only filters should be shown. */
+    devMode?: boolean;
+    displayPreferencesIcon?: boolean;
+    enableFocusView?: boolean;
+    /** @deprecated Prefer filterStore/filterOptionsHandler. Whether more value-filter options can be loaded, keyed by column key (`colId` when present, otherwise `field`). */
+    filterHasMoreMap?: Record<string, boolean | undefined>;
+    /** @deprecated Prefer filterStore/filterOptionsHandler. Initial/options loading state keyed by column key (`colId` when present, otherwise `field`). */
+    filterLoadingMap?: Record<string, boolean | undefined>;
+    /** @deprecated Prefer filterStore/filterOptionsHandler. See-more loading state keyed by column key (`colId` when present, otherwise `field`). */
+    filterLoadingMoreMap?: Record<string, boolean | undefined>;
+    /** Current AG Grid advanced/regular filter model (used with v-model:filter-model). */
+    filterModel?: PvFilterPanelFilterModel;
+    /** Declares whether filterModel is a regular AG Grid FilterModel or AdvancedFilterModel. */
+    filterModelType?: PvFilterPanelFilterModelType;
+    /** @deprecated Prefer filterStore/filterOptionsHandler. Value-filter options keyed by column key (`colId` when present, otherwise `field`). */
+    filterOptions?: Record<string, PvFilterPanelOption[]>;
+    /** Fetches value-filter options. When provided without filterStore, PvFilterPanel creates an internal PvFilterStore. */
+    filterOptionsHandler?: PvFilterPanelOptionsHandler;
+    /** @deprecated Prefer filterStore/filterOptionsHandler. Value-filter search queries keyed by column key (`colId` when present, otherwise `field`). */
+    filterSearchQueries?: Record<string, string | undefined>;
+    /** Suggested filter shortcuts shown above the category carousel. Active suggestions are hidden automatically. */
+    filterSuggestions?: PvFilterPanelSuggestion[];
+    /** External generic filter store. When provided, store state wins over controlled option/loading props. */
+    filterStore?: PvFilterStore;
+    /** Fields that can receive focus actions. Defaults to all fields when enableFocusView is true. */
+    focusableFields?: string[];
+    /** Values currently focused, keyed by field. */
+    focusedValues?: Record<string, string[] | undefined>;
+    focusText?: string;
+    /** Debounce range filter model updates by this many milliseconds. Set 0 to emit every range update. */
+    rangeDebounceMs?: number;
+    readOnly?: boolean;
+    /** Stage edits locally until Apply is clicked. */
+    staged?: boolean;
+    width?: string;
+}

package/pv-components/dist/vue/visualizations/components/base/PvFilterPanel/usePvFilterStore.d.ts

@@ -0,0 +1,5 @@
+import { PvFilterStore } from './types';
+export declare const createPvFilterStore: () => PvFilterStore;
+export declare const providePvFilterStore: (filterStore: PvFilterStore) => void;
+export declare const useOptionalPvFilterStore: () => PvFilterStore | null;
+export declare const usePvFilterStore: () => PvFilterStore;

package/pv-components/dist/vue/visualizations/components/base/PvHorizontalScroller/PvHorizontalScroller.vue.d.ts

@@ -0,0 +1,36 @@
+import { PvHorizontalScrollerProps } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { PvButtonSize, PvButtonVariant } from '../PvButton/types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        scrollContainer: HTMLDivElement;
+        contentContainer: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<PvHorizontalScrollerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PvHorizontalScrollerProps> & Readonly<{}>, {
+    ariaLabel: string;
+    scrollBehavior: ScrollBehavior;
+    buttonSize: PvButtonSize;
+    buttonVariant: PvButtonVariant;
+    hideScrollbar: boolean;
+    leftAriaLabel: string;
+    rightAriaLabel: string;
+    scrollFraction: number;
+    showFades: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    scrollContainer: HTMLDivElement;
+    contentContainer: 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/pv-components/dist/vue/visualizations/components/base/PvHorizontalScroller/types.d.ts

@@ -0,0 +1,21 @@
+import { PvButtonSize, PvButtonVariant } from '../PvButton/types';
+export interface PvHorizontalScrollerProps {
+    /** Accessible label for the scrollable region. */
+    ariaLabel?: string;
+    /** Size for the left/right scroll buttons. */
+    buttonSize?: PvButtonSize;
+    /** Variant for the left/right scroll buttons. */
+    buttonVariant?: PvButtonVariant;
+    /** Hide the native horizontal scrollbar while keeping wheel/touch scrolling enabled. */
+    hideScrollbar?: boolean;
+    /** Accessible label for the left scroll button. */
+    leftAriaLabel?: string;
+    /** Accessible label for the right scroll button. */
+    rightAriaLabel?: string;
+    /** Browser scroll behavior used when clicking an arrow. */
+    scrollBehavior?: ScrollBehavior;
+    /** Fraction of the visible container width to scroll per arrow click. */
+    scrollFraction?: number;
+    /** Show gradient edge fades behind the arrow buttons. */
+    showFades?: boolean;
+}

package/pv-components/dist/vue/visualizations/components/base/PvRange/PvRange.vue.d.ts

@@ -1,24 +1,36 @@
+import { PvRangeProps, PvRangeValue, PvRangeSize, PvRangeColor, PvRangeMode } from './types';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-type __VLS_Props = {
-    /** Minimum value of the range slider */
-    min?: number;
-    /** Maximum value of the range slider */
-    max?: number;
-    /** Step increment between values */
-    step?: number;
-    /** Accessible name for the range slider */
-    ariaLabel?: string;
-};
+type __VLS_Props = PvRangeProps;
 type __VLS_PublicProps = {
-    modelValue: number;
+    modelValue?: number;
+    "rangeValue"?: PvRangeValue;
 } & __VLS_Props;
 declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     "update:modelValue": (value: number) => any;
+    "update:rangeValue": (value: PvRangeValue) => any;
 }, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    "onUpdate:rangeValue"?: ((value: PvRangeValue) => any) | undefined;
 }>, {
-    min: number;
-    max: number;
-    step: number;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLInputElement>;
+    label: string;
+    min: number | null;
+    max: number | null;
+    size: PvRangeSize;
+    color: PvRangeColor;
+    disabled: boolean;
+    mode: PvRangeMode;
+    showClear: boolean;
+    step: number | null;
+    allowMinMaxEqual: boolean;
+    alwaysEditMin: boolean;
+    dataType: string | null;
+    maxLabel: string;
+    minLabel: string;
+    showBoundLabels: boolean;
+    showInputs: boolean;
+    showValueTooltips: boolean;
+    valueDecimals: number | null;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    sliderRef: HTMLDivElement;
+}, any>;
 export default _default;

package/pv-components/dist/vue/visualizations/components/base/PvRange/types.d.ts

@@ -0,0 +1,44 @@
+export type PvRangeColor = "single" | "multiple";
+export type PvRangeMode = "single" | "dual";
+export type PvRangeSize = "sm" | "md" | "lg";
+export interface PvRangeProps {
+    /** When true, min and max handles may have the same value in dual mode. */
+    allowMinMaxEqual?: boolean;
+    /** When true, track clicks always move the minimum handle instead of the nearest handle in dual mode. */
+    alwaysEditMin?: boolean;
+    /** Accessible name for the range slider. */
+    ariaLabel?: string;
+    /** Track color mode. `single` uses a neutral unselected track, `multiple` uses the secondary data color. */
+    color?: PvRangeColor;
+    /** Value display type for dual-mode inputs, tooltips, and bound labels. */
+    dataType?: string | null;
+    disabled?: boolean;
+    /** Accessible group label in dual mode. */
+    label?: string;
+    /** Upper slider bound. */
+    max?: number | null;
+    maxLabel?: string;
+    /** Lower slider bound. */
+    min?: number | null;
+    minLabel?: string;
+    /** Slider interaction mode. `single` uses the default v-model; `dual` ignores modelValue and uses v-model:rangeValue. */
+    mode?: PvRangeMode;
+    /** Whether to show min/max bound values above the slider in dual mode. */
+    showBoundLabels?: boolean;
+    /** Whether to show the Clear range action when a dual-mode value is active. */
+    showClear?: boolean;
+    /** Whether to show min/max text inputs in dual mode. */
+    showInputs?: boolean;
+    /** Whether to show handle value tooltips while interacting in dual mode. */
+    showValueTooltips?: boolean;
+    /** Visual size. */
+    size?: PvRangeSize;
+    /** Slider/input step. Use 0 for continuous values. */
+    step?: number | null;
+    /** Decimal places for dual-mode display values. */
+    valueDecimals?: number | null;
+}
+export interface PvRangeValue {
+    max: number | null;
+    min: number | null;
+}

package/pv-components/dist/vue/visualizations/components/base/index.d.ts

@@ -57,6 +57,8 @@ export { default as PvTree } from './PvTree/PvTree.vue';
 export { default as PvTreeGroup } from './PvTree/PvTreeGroup.vue';
 export { default as PvProgressBar } from './PvProgressBar/PvProgressBar.vue';
 export { default as PvDistributionBar } from './PvDistributionBar/PvDistributionBar.vue';
+export { default as PvFilterPanel } from './PvFilterPanel/PvFilterPanel.vue';
+export { default as PvHorizontalScroller } from './PvHorizontalScroller/PvHorizontalScroller.vue';
 export { default as PvQueryBuilderInput } from './PvQueryBuilderInput/PvQueryBuilderInput.vue';
 export { default as PvRange } from './PvRange/PvRange.vue';
 export { default as PvMenu } from './PvMenu/PvMenu.vue';
@@ -73,3 +75,7 @@ export type { PvMultiSelectButtonSlotProps } from './PvMultiSelectButton/types';
 export type { PvTreeOption, PvTreeSetting, PvTreeSettings } from './PvTree/types';
 export type { RadioGroupOption } from './PvRadioGroup/types';
 export type { PvTableOfContentsItem } from './PvTableOfContents/types';
+export type { PvHorizontalScrollerProps } from './PvHorizontalScroller/types';
+export type { PvFilterPanelAggregateFieldHierarchy, PvFilterPanelColDef, PvFilterPanelColDefContext, PvFilterPanelControlChange, PvFilterPanelFilterChangeEvent, PvFilterPanelFilterChangeReason, PvFilterPanelFilterGroup, PvFilterPanelFilterModel, PvFilterPanelFilterModelType, PvFilterPanelFilterType, PvFilterPanelOption, PvFilterPanelOptionsHandler, PvFilterPanelOptionsHandlerParams, PvFilterPanelOptionsHandlerReason, PvFilterPanelOptionsResponse, PvFilterPanelOptionRawValue, PvFilterPanelProps, PvFilterPanelRangeConfig, PvFilterPanelResultCount, PvFilterPanelSuggestion, PvFilterStore, PvFilterStoreFetchOptionsParams, } from './PvFilterPanel/types';
+export { createPvFilterStore, providePvFilterStore, useOptionalPvFilterStore, usePvFilterStore, } from './PvFilterPanel/usePvFilterStore';
+export type { PvRangeColor, PvRangeMode, PvRangeProps, PvRangeSize, PvRangeValue, } from './PvRange/types';

package/pv-components/dist/vue/visualizations/components/charts/PvDataTableWithChart/PvDataTableWithChart.vue.d.ts

@@ -27,7 +27,7 @@ declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>
         getCsvData: () => Promise<string | null> | undefined;
         refreshData: (params?: RefreshServerSideParams | null) => Promise<void> | undefined;
         getFilterValueSelectedMetadataMap: () => Record<string, ( FilterValueResponseOption | null)[]> | undefined;
-        getPvFilterModel: () => FilterModel | AdvancedFilterModel | null | undefined;
+        getPvFilterModel: () => AdvancedFilterModel | FilterModel | null | undefined;
         setPvFilterModel: (model: FilterModel | AdvancedFilterModel | null) => boolean | undefined;
     }>): void;
     attrs: any;

package/pv-components/dist/vue/visualizations/components/tables/PvDataTable/table-components/SetFilter.vue.d.ts

@@ -15,10 +15,10 @@ export interface SetFilterProps<T> {
 }
 declare const _default: <T>(__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 "onHandle-settings-icon"?: ((value: string) => any) | undefined;
         readonly "onFilter-selection-changed"?: (() => any) | undefined;
         readonly "onFilter-closed"?: (() => any) | undefined;
-        readonly "onHandle-settings-icon"?: ((value: string) => any) | undefined;
-    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onFilter-selection-changed" | "onFilter-closed" | "onHandle-settings-icon"> & SetFilterProps<T> & Partial<{}>> & PublicProps;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onHandle-settings-icon" | "onFilter-selection-changed" | "onFilter-closed"> & SetFilterProps<T> & Partial<{}>> & PublicProps;
     expose(exposed: ShallowUnwrapRef<{}>): void;
     attrs: any;
     slots: {};

package/pv-components/dist/vue/visualizations/pv-components-visualizations.mjs

@@ -3392,7 +3392,10 @@ var pa = {
 		}, 16, ["modelValue"]));
 	}
 });
-Math.random().toString(), Math.random().toString();
+Math.random().toString(), Math.random().toString(), new Intl.NumberFormat("en-US", {
+	maximumFractionDigits: 1,
+	notation: "compact"
+});
 //#endregion
 //#region src/components/base/PvQueryBuilderInput/useQueryBuilder.ts
 var Za = () => {